1 // Copyright (C) 2018 The Android Open Source Project
2 // Copyright (C) 2018 Google Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15
16 // Autogenerated module VkDecoder
17 //
18 // (impl) generated by scripts/genvk.py -registry
19 // ../../../../../hardware/google/gfxstream/codegen/vulkan/vulkan-docs-next/xml/vk.xml
20 // -registryGfxstream xml/vk_gfxstream.xml cereal -o
21 // ../../../../../hardware/google/gfxstream/host/vulkan/cereal
22 //
23 // Please do not modify directly;
24 // re-run mesa3d/src/gfxstream/codegen/generate-gfxstream-vulkan.sh,
25 // or directly from Python by defining:
26 // VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
27 // VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
28 // CEREAL_OUTPUT_DIR: Where to put the generated sources.
29 //
30 // python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
31 // $CEREAL_OUTPUT_DIR
32 //
33
34 #include "VkDecoder.h"
35
36 #include <functional>
37 #include <optional>
38 #include <unordered_map>
39
40 #include "FrameBuffer.h"
41 #include "VkDecoderGlobalState.h"
42 #include "VkDecoderSnapshot.h"
43 #include "VulkanDispatch.h"
44 #include "VulkanStream.h"
45 #include "aemu/base/BumpPool.h"
46 #include "aemu/base/Metrics.h"
47 #include "aemu/base/system/System.h"
48 #include "common/goldfish_vk_marshaling.h"
49 #include "common/goldfish_vk_reserved_marshaling.h"
50 #include "common/goldfish_vk_transform.h"
51 #include "gfxstream/host/Tracing.h"
52 #include "goldfish_vk_private_defs.h"
53 #include "host-common/GfxstreamFatalError.h"
54 #include "host-common/feature_control.h"
55 #include "host-common/logging.h"
56 #include "render-utils/IOStream.h"
57 #define MAX_PACKET_LENGTH (400 * 1024 * 1024) // 400MB
58
59 namespace gfxstream {
60 namespace vk {
61
62 using android::base::MetricEventBadPacketLength;
63 using android::base::MetricEventDuplicateSequenceNum;
64
65 class VkDecoder::Impl {
66 public:
Impl()67 Impl()
68 : m_logCalls(android::base::getEnvironmentVariable("ANDROID_EMU_VK_LOG_CALLS") == "1"),
69 m_vk(vkDispatch()),
70 m_state(VkDecoderGlobalState::get()),
71 m_vkStream(nullptr, m_state->getFeatures()),
72 m_vkMemReadingStream(nullptr, m_state->getFeatures()),
73 m_boxedHandleUnwrapMapping(m_state),
74 m_boxedHandleCreateMapping(m_state),
75 m_boxedHandleDestroyMapping(m_state),
76 m_boxedHandleUnwrapAndDeleteMapping(m_state),
77 m_boxedHandleUnwrapAndDeletePreserveBoxedMapping(m_state),
78 m_prevSeqno(std::nullopt),
79 m_queueSubmitWithCommandsEnabled(
80 m_state->getFeatures().VulkanQueueSubmitWithCommands.enabled) {}
stream()81 VulkanStream* stream() { return &m_vkStream; }
readStream()82 VulkanMemReadingStream* readStream() { return &m_vkMemReadingStream; }
83
setForSnapshotLoad(bool forSnapshotLoad)84 void setForSnapshotLoad(bool forSnapshotLoad) { m_forSnapshotLoad = forSnapshotLoad; }
85
86 size_t decode(void* buf, size_t bufsize, IOStream* stream,
87 const ProcessResources* processResources, const VkDecoderContext&);
88
89 private:
90 bool m_logCalls;
91 bool m_forSnapshotLoad = false;
92 VulkanDispatch* m_vk;
93 VkDecoderGlobalState* m_state;
94 VulkanStream m_vkStream;
95 VulkanMemReadingStream m_vkMemReadingStream;
96 BoxedHandleUnwrapMapping m_boxedHandleUnwrapMapping;
97 BoxedHandleCreateMapping m_boxedHandleCreateMapping;
98 BoxedHandleDestroyMapping m_boxedHandleDestroyMapping;
99 BoxedHandleUnwrapAndDeleteMapping m_boxedHandleUnwrapAndDeleteMapping;
100 android::base::BumpPool m_pool;
101 BoxedHandleUnwrapAndDeletePreserveBoxedMapping m_boxedHandleUnwrapAndDeletePreserveBoxedMapping;
102 std::optional<uint32_t> m_prevSeqno;
103 bool m_queueSubmitWithCommandsEnabled = false;
104 };
105
VkDecoder()106 VkDecoder::VkDecoder() : mImpl(new VkDecoder::Impl()) {}
107
108 VkDecoder::~VkDecoder() = default;
109
setForSnapshotLoad(bool forSnapshotLoad)110 void VkDecoder::setForSnapshotLoad(bool forSnapshotLoad) {
111 mImpl->setForSnapshotLoad(forSnapshotLoad);
112 }
113
decode(void * buf,size_t bufsize,IOStream * stream,const ProcessResources * processResources,const VkDecoderContext & context)114 size_t VkDecoder::decode(void* buf, size_t bufsize, IOStream* stream,
115 const ProcessResources* processResources,
116 const VkDecoderContext& context) {
117 return mImpl->decode(buf, bufsize, stream, processResources, context);
118 }
119
120 // VkDecoder::Impl::decode to follow
121
decode(void * buf,size_t len,IOStream * ioStream,const ProcessResources * processResources,const VkDecoderContext & context)122 size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
123 const ProcessResources* processResources,
124 const VkDecoderContext& context) {
125 const char* processName = context.processName;
126 auto& gfx_logger = *context.gfxApiLogger;
127 auto* healthMonitor = context.healthMonitor;
128 auto& metricsLogger = *context.metricsLogger;
129 if (len < 8) return 0;
130 unsigned char* ptr = (unsigned char*)buf;
131 const unsigned char* const end = (const unsigned char*)buf + len;
132 if (m_forSnapshotLoad) {
133 ptr += m_state->setCreatedHandlesForSnapshotLoad(ptr);
134 }
135 while (end - ptr >= 8) {
136 uint32_t opcode = *(uint32_t*)ptr;
137 uint32_t packetLen = *(uint32_t*)(ptr + 4);
138
139 // packetLen should be at least 8 (op code and packet length) and should not be excessively
140 // large
141 if (packetLen < 8 || packetLen > MAX_PACKET_LENGTH) {
142 WARN("Bad packet length %d detected, decode may fail", packetLen);
143 metricsLogger.logMetricEvent(MetricEventBadPacketLength{.len = packetLen});
144 }
145
146 if (end - ptr < packetLen) return ptr - (unsigned char*)buf;
147 gfx_logger.record(ptr, std::min(size_t(packetLen + 8), size_t(end - ptr)));
148 stream()->setStream(ioStream);
149 VulkanStream* vkStream = stream();
150 VulkanMemReadingStream* vkReadStream = readStream();
151 vkReadStream->setBuf((uint8_t*)(ptr + 8));
152 uint8_t* readStreamPtr = vkReadStream->getBuf();
153 uint8_t** readStreamPtrPtr = &readStreamPtr;
154 uint8_t* snapshotTraceBegin = vkReadStream->beginTrace();
155 vkReadStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
156
157 std::unique_ptr<EventHangMetadata::HangAnnotations> executionData =
158 std::make_unique<EventHangMetadata::HangAnnotations>();
159 if (healthMonitor) {
160 executionData->insert(
161 {{"packet_length", std::to_string(packetLen)}, {"opcode", std::to_string(opcode)}});
162 if (processName) {
163 executionData->insert({{"renderthread_guest_process", std::string(processName)}});
164 }
165 if (m_prevSeqno) {
166 executionData->insert({{"previous_seqno", std::to_string(m_prevSeqno.value())}});
167 }
168 }
169
170 std::atomic<uint32_t>* seqnoPtr =
171 processResources ? processResources->getSequenceNumberPtr() : nullptr;
172
173 if (m_queueSubmitWithCommandsEnabled &&
174 ((opcode >= OP_vkFirst && opcode < OP_vkLast) ||
175 (opcode >= OP_vkFirst_old && opcode < OP_vkLast_old))) {
176 uint32_t seqno;
177 memcpy(&seqno, *readStreamPtrPtr, sizeof(uint32_t));
178 *readStreamPtrPtr += sizeof(uint32_t);
179 if (healthMonitor) executionData->insert({{"seqno", std::to_string(seqno)}});
180 if (m_prevSeqno && seqno == m_prevSeqno.value()) {
181 WARN(
182 "Seqno %d is the same as previously processed on thread %d. It might be a "
183 "duplicate command.",
184 seqno, getCurrentThreadId());
185 metricsLogger.logMetricEvent(MetricEventDuplicateSequenceNum{.opcode = opcode});
186 }
187 if (seqnoPtr && !m_forSnapshotLoad) {
188 {
189 auto seqnoWatchdog =
190 WATCHDOG_BUILDER(healthMonitor, "RenderThread seqno loop")
191 .setHangType(EventHangMetadata::HangType::kRenderThread)
192 .setAnnotations(std::make_unique<EventHangMetadata::HangAnnotations>(
193 *executionData))
194 /* Data gathered if this hangs*/
195 .setOnHangCallback([=]() {
196 auto annotations =
197 std::make_unique<EventHangMetadata::HangAnnotations>();
198 annotations->insert(
199 {{"seqnoPtr",
200 std::to_string(seqnoPtr->load(std::memory_order_seq_cst))}});
201 return annotations;
202 })
203 .build();
204 while ((seqno - seqnoPtr->load(std::memory_order_seq_cst) != 1)) {
205 #if (defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64)))
206 _mm_pause();
207 #elif (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)))
208 __asm__ __volatile__("pause;");
209 #endif
210 }
211 m_prevSeqno = seqno;
212 }
213 }
214 }
215
216 gfx_logger.recordCommandExecution();
217
218 auto executionWatchdog =
219 WATCHDOG_BUILDER(healthMonitor, "RenderThread VkDecoder command execution")
220 .setHangType(EventHangMetadata::HangType::kRenderThread)
221 .setAnnotations(std::move(executionData))
222 .build();
223
224 auto vk = m_vk;
225 switch (opcode) {
226 #ifdef VK_VERSION_1_0
227 case OP_vkCreateInstance: {
228 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
229 "VkDecoder vkCreateInstance");
230 const VkInstanceCreateInfo* pCreateInfo;
231 const VkAllocationCallbacks* pAllocator;
232 VkInstance* pInstance;
233 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkInstanceCreateInfo));
234 reservedunmarshal_VkInstanceCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
235 (VkInstanceCreateInfo*)(pCreateInfo),
236 readStreamPtrPtr);
237 // WARNING PTR CHECK
238 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
239 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
240 *readStreamPtrPtr += 8;
241 if (pAllocator) {
242 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
243 reservedunmarshal_VkAllocationCallbacks(
244 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
245 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
246 }
247 // Begin manual dispatchable handle unboxing for pInstance;
248 vkReadStream->unsetHandleMapping();
249 vkReadStream->alloc((void**)&pInstance, sizeof(VkInstance));
250 uint64_t cgen_var_1;
251 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 8);
252 *readStreamPtrPtr += 8;
253 *(VkInstance*)pInstance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_1));
254 if (pCreateInfo) {
255 transform_tohost_VkInstanceCreateInfo(m_state,
256 (VkInstanceCreateInfo*)(pCreateInfo));
257 }
258 if (pAllocator) {
259 transform_tohost_VkAllocationCallbacks(m_state,
260 (VkAllocationCallbacks*)(pAllocator));
261 }
262 if (m_logCalls) {
263 fprintf(stderr, "stream %p: call vkCreateInstance 0x%llx 0x%llx 0x%llx \n",
264 ioStream, (unsigned long long)pCreateInfo,
265 (unsigned long long)pAllocator, (unsigned long long)pInstance);
266 }
267 VkResult vkCreateInstance_VkResult_return = (VkResult)0;
268 vkCreateInstance_VkResult_return =
269 m_state->on_vkCreateInstance(&m_pool, pCreateInfo, pAllocator, pInstance);
270 if ((vkCreateInstance_VkResult_return) == VK_ERROR_DEVICE_LOST)
271 m_state->on_DeviceLost();
272 m_state->on_CheckOutOfMemory(vkCreateInstance_VkResult_return, opcode, context);
273 vkStream->unsetHandleMapping();
274 uint64_t cgen_var_2;
275 static_assert(8 == sizeof(VkInstance),
276 "handle map overwrite requires VkInstance to be 8 bytes long");
277 vkStream->handleMapping()->mapHandles_VkInstance((VkInstance*)pInstance, 1);
278 vkStream->write((VkInstance*)pInstance, 8 * 1);
279 vkStream->write(&vkCreateInstance_VkResult_return, sizeof(VkResult));
280 vkStream->commitWrite();
281 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
282 (uintptr_t)snapshotTraceBegin);
283 size_t snapshotTraceBytes = vkReadStream->endTrace();
284 if (m_state->snapshotsEnabled()) {
285 m_state->snapshot()->vkCreateInstance(snapshotTraceBegin, snapshotTraceBytes,
286 &m_pool, vkCreateInstance_VkResult_return,
287 pCreateInfo, pAllocator, pInstance);
288 }
289 vkReadStream->clearPool();
290 if (m_queueSubmitWithCommandsEnabled)
291 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
292 break;
293 }
294 case OP_vkDestroyInstance: {
295 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
296 "VkDecoder vkDestroyInstance");
297 VkInstance instance;
298 const VkAllocationCallbacks* pAllocator;
299 // Begin global wrapped dispatchable handle unboxing for instance;
300 uint64_t cgen_var_0;
301 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
302 *readStreamPtrPtr += 1 * 8;
303 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
304 // WARNING PTR CHECK
305 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
306 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
307 *readStreamPtrPtr += 8;
308 if (pAllocator) {
309 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
310 reservedunmarshal_VkAllocationCallbacks(
311 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
312 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
313 }
314 if (pAllocator) {
315 transform_tohost_VkAllocationCallbacks(m_state,
316 (VkAllocationCallbacks*)(pAllocator));
317 }
318 if (m_logCalls) {
319 fprintf(stderr, "stream %p: call vkDestroyInstance 0x%llx 0x%llx \n", ioStream,
320 (unsigned long long)instance, (unsigned long long)pAllocator);
321 }
322 m_state->on_vkDestroyInstance(&m_pool, instance, pAllocator);
323 vkStream->unsetHandleMapping();
324 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
325 (uintptr_t)snapshotTraceBegin);
326 size_t snapshotTraceBytes = vkReadStream->endTrace();
327 if (m_state->snapshotsEnabled()) {
328 m_state->snapshot()->vkDestroyInstance(snapshotTraceBegin, snapshotTraceBytes,
329 &m_pool, instance, pAllocator);
330 }
331 vkReadStream->clearPool();
332 if (m_queueSubmitWithCommandsEnabled)
333 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
334 break;
335 }
336 case OP_vkEnumeratePhysicalDevices: {
337 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
338 "VkDecoder vkEnumeratePhysicalDevices");
339 VkInstance instance;
340 uint32_t* pPhysicalDeviceCount;
341 VkPhysicalDevice* pPhysicalDevices;
342 // Begin global wrapped dispatchable handle unboxing for instance;
343 uint64_t cgen_var_0;
344 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
345 *readStreamPtrPtr += 1 * 8;
346 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
347 // Begin manual dispatchable handle unboxing for pPhysicalDeviceCount;
348 vkReadStream->unsetHandleMapping();
349 // WARNING PTR CHECK
350 memcpy((uint32_t**)&pPhysicalDeviceCount, (*readStreamPtrPtr), 8);
351 android::base::Stream::fromBe64((uint8_t*)&pPhysicalDeviceCount);
352 *readStreamPtrPtr += 8;
353 if (pPhysicalDeviceCount) {
354 vkReadStream->alloc((void**)&pPhysicalDeviceCount, sizeof(uint32_t));
355 memcpy((uint32_t*)pPhysicalDeviceCount, *readStreamPtrPtr, sizeof(uint32_t));
356 *readStreamPtrPtr += sizeof(uint32_t);
357 }
358 // Begin manual dispatchable handle unboxing for pPhysicalDevices;
359 vkReadStream->unsetHandleMapping();
360 // WARNING PTR CHECK
361 memcpy((VkPhysicalDevice**)&pPhysicalDevices, (*readStreamPtrPtr), 8);
362 android::base::Stream::fromBe64((uint8_t*)&pPhysicalDevices);
363 *readStreamPtrPtr += 8;
364 if (pPhysicalDevices) {
365 vkReadStream->alloc((void**)&pPhysicalDevices,
366 (*(pPhysicalDeviceCount)) * sizeof(VkPhysicalDevice));
367 if ((*(pPhysicalDeviceCount))) {
368 uint8_t* cgen_var_2_0_ptr = (uint8_t*)(*readStreamPtrPtr);
369 *readStreamPtrPtr += 8 * (*(pPhysicalDeviceCount));
370 if (pPhysicalDeviceCount) {
371 for (uint32_t k = 0; k < (*(pPhysicalDeviceCount)); ++k) {
372 uint64_t tmpval;
373 memcpy(&tmpval, cgen_var_2_0_ptr + k * 8, sizeof(uint64_t));
374 *(((VkPhysicalDevice*)pPhysicalDevices) + k) =
375 tmpval ? (VkPhysicalDevice)(VkPhysicalDevice)((
376 VkPhysicalDevice)tmpval)
377 : VK_NULL_HANDLE;
378 }
379 }
380 }
381 }
382 if (m_logCalls) {
383 fprintf(stderr,
384 "stream %p: call vkEnumeratePhysicalDevices 0x%llx 0x%llx 0x%llx \n",
385 ioStream, (unsigned long long)instance,
386 (unsigned long long)pPhysicalDeviceCount,
387 (unsigned long long)pPhysicalDevices);
388 }
389 VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
390 vkEnumeratePhysicalDevices_VkResult_return = m_state->on_vkEnumeratePhysicalDevices(
391 &m_pool, instance, pPhysicalDeviceCount, pPhysicalDevices);
392 if ((vkEnumeratePhysicalDevices_VkResult_return) == VK_ERROR_DEVICE_LOST)
393 m_state->on_DeviceLost();
394 m_state->on_CheckOutOfMemory(vkEnumeratePhysicalDevices_VkResult_return, opcode,
395 context);
396 vkStream->unsetHandleMapping();
397 // WARNING PTR CHECK
398 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pPhysicalDeviceCount;
399 vkStream->putBe64(cgen_var_3);
400 if (pPhysicalDeviceCount) {
401 vkStream->write((uint32_t*)pPhysicalDeviceCount, sizeof(uint32_t));
402 }
403 // WARNING PTR CHECK
404 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pPhysicalDevices;
405 vkStream->putBe64(cgen_var_4);
406 if (pPhysicalDevices) {
407 if ((*(pPhysicalDeviceCount))) {
408 uint64_t* cgen_var_4_0;
409 vkStream->alloc((void**)&cgen_var_4_0, (*(pPhysicalDeviceCount)) * 8);
410 static_assert(
411 8 == sizeof(VkPhysicalDevice),
412 "handle map overwrite requires VkPhysicalDevice to be 8 bytes long");
413 vkStream->handleMapping()->mapHandles_VkPhysicalDevice(
414 (VkPhysicalDevice*)pPhysicalDevices, (*(pPhysicalDeviceCount)));
415 vkStream->write((VkPhysicalDevice*)pPhysicalDevices,
416 8 * (*(pPhysicalDeviceCount)));
417 }
418 }
419 vkStream->write(&vkEnumeratePhysicalDevices_VkResult_return, sizeof(VkResult));
420 vkStream->commitWrite();
421 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
422 (uintptr_t)snapshotTraceBegin);
423 size_t snapshotTraceBytes = vkReadStream->endTrace();
424 if (m_state->snapshotsEnabled()) {
425 m_state->snapshot()->vkEnumeratePhysicalDevices(
426 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
427 vkEnumeratePhysicalDevices_VkResult_return, instance, pPhysicalDeviceCount,
428 pPhysicalDevices);
429 }
430 vkReadStream->clearPool();
431 if (m_queueSubmitWithCommandsEnabled)
432 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
433 break;
434 }
435 case OP_vkGetPhysicalDeviceFeatures: {
436 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
437 "VkDecoder vkGetPhysicalDeviceFeatures");
438 VkPhysicalDevice physicalDevice;
439 VkPhysicalDeviceFeatures* pFeatures;
440 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
441 uint64_t cgen_var_0;
442 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
443 *readStreamPtrPtr += 1 * 8;
444 *(VkPhysicalDevice*)&physicalDevice =
445 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
446 // Begin manual dispatchable handle unboxing for pFeatures;
447 vkReadStream->unsetHandleMapping();
448 vkReadStream->alloc((void**)&pFeatures, sizeof(VkPhysicalDeviceFeatures));
449 reservedunmarshal_VkPhysicalDeviceFeatures(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
450 (VkPhysicalDeviceFeatures*)(pFeatures),
451 readStreamPtrPtr);
452 if (pFeatures) {
453 transform_tohost_VkPhysicalDeviceFeatures(
454 m_state, (VkPhysicalDeviceFeatures*)(pFeatures));
455 }
456 if (m_logCalls) {
457 fprintf(stderr, "stream %p: call vkGetPhysicalDeviceFeatures 0x%llx 0x%llx \n",
458 ioStream, (unsigned long long)physicalDevice,
459 (unsigned long long)pFeatures);
460 }
461 m_state->on_vkGetPhysicalDeviceFeatures(&m_pool, physicalDevice, pFeatures);
462 vkStream->unsetHandleMapping();
463 if (pFeatures) {
464 transform_fromhost_VkPhysicalDeviceFeatures(
465 m_state, (VkPhysicalDeviceFeatures*)(pFeatures));
466 }
467 marshal_VkPhysicalDeviceFeatures(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
468 (VkPhysicalDeviceFeatures*)(pFeatures));
469 vkStream->commitWrite();
470 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
471 (uintptr_t)snapshotTraceBegin);
472 size_t snapshotTraceBytes = vkReadStream->endTrace();
473 if (m_state->snapshotsEnabled()) {
474 m_state->snapshot()->vkGetPhysicalDeviceFeatures(
475 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice, pFeatures);
476 }
477 vkReadStream->clearPool();
478 if (m_queueSubmitWithCommandsEnabled)
479 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
480 break;
481 }
482 case OP_vkGetPhysicalDeviceFormatProperties: {
483 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
484 "VkDecoder vkGetPhysicalDeviceFormatProperties");
485 VkPhysicalDevice physicalDevice;
486 VkFormat format;
487 VkFormatProperties* pFormatProperties;
488 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
489 uint64_t cgen_var_0;
490 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
491 *readStreamPtrPtr += 1 * 8;
492 *(VkPhysicalDevice*)&physicalDevice =
493 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
494 memcpy((VkFormat*)&format, *readStreamPtrPtr, sizeof(VkFormat));
495 *readStreamPtrPtr += sizeof(VkFormat);
496 // Begin manual dispatchable handle unboxing for pFormatProperties;
497 vkReadStream->unsetHandleMapping();
498 vkReadStream->alloc((void**)&pFormatProperties, sizeof(VkFormatProperties));
499 reservedunmarshal_VkFormatProperties(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
500 (VkFormatProperties*)(pFormatProperties),
501 readStreamPtrPtr);
502 if (pFormatProperties) {
503 transform_tohost_VkFormatProperties(m_state,
504 (VkFormatProperties*)(pFormatProperties));
505 }
506 if (m_logCalls) {
507 fprintf(stderr,
508 "stream %p: call vkGetPhysicalDeviceFormatProperties 0x%llx 0x%llx "
509 "0x%llx \n",
510 ioStream, (unsigned long long)physicalDevice,
511 (unsigned long long)format, (unsigned long long)pFormatProperties);
512 }
513 m_state->on_vkGetPhysicalDeviceFormatProperties(&m_pool, physicalDevice, format,
514 pFormatProperties);
515 vkStream->unsetHandleMapping();
516 if (pFormatProperties) {
517 transform_fromhost_VkFormatProperties(m_state,
518 (VkFormatProperties*)(pFormatProperties));
519 }
520 marshal_VkFormatProperties(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
521 (VkFormatProperties*)(pFormatProperties));
522 vkStream->commitWrite();
523 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
524 (uintptr_t)snapshotTraceBegin);
525 size_t snapshotTraceBytes = vkReadStream->endTrace();
526 if (m_state->snapshotsEnabled()) {
527 m_state->snapshot()->vkGetPhysicalDeviceFormatProperties(
528 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice, format,
529 pFormatProperties);
530 }
531 vkReadStream->clearPool();
532 if (m_queueSubmitWithCommandsEnabled)
533 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
534 break;
535 }
536 case OP_vkGetPhysicalDeviceImageFormatProperties: {
537 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
538 "VkDecoder vkGetPhysicalDeviceImageFormatProperties");
539 VkPhysicalDevice physicalDevice;
540 VkFormat format;
541 VkImageType type;
542 VkImageTiling tiling;
543 VkImageUsageFlags usage;
544 VkImageCreateFlags flags;
545 VkImageFormatProperties* pImageFormatProperties;
546 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
547 uint64_t cgen_var_0;
548 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
549 *readStreamPtrPtr += 1 * 8;
550 *(VkPhysicalDevice*)&physicalDevice =
551 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
552 memcpy((VkFormat*)&format, *readStreamPtrPtr, sizeof(VkFormat));
553 *readStreamPtrPtr += sizeof(VkFormat);
554 memcpy((VkImageType*)&type, *readStreamPtrPtr, sizeof(VkImageType));
555 *readStreamPtrPtr += sizeof(VkImageType);
556 memcpy((VkImageTiling*)&tiling, *readStreamPtrPtr, sizeof(VkImageTiling));
557 *readStreamPtrPtr += sizeof(VkImageTiling);
558 memcpy((VkImageUsageFlags*)&usage, *readStreamPtrPtr, sizeof(VkImageUsageFlags));
559 *readStreamPtrPtr += sizeof(VkImageUsageFlags);
560 memcpy((VkImageCreateFlags*)&flags, *readStreamPtrPtr, sizeof(VkImageCreateFlags));
561 *readStreamPtrPtr += sizeof(VkImageCreateFlags);
562 // Begin manual dispatchable handle unboxing for pImageFormatProperties;
563 vkReadStream->unsetHandleMapping();
564 vkReadStream->alloc((void**)&pImageFormatProperties,
565 sizeof(VkImageFormatProperties));
566 reservedunmarshal_VkImageFormatProperties(
567 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
568 (VkImageFormatProperties*)(pImageFormatProperties), readStreamPtrPtr);
569 if (pImageFormatProperties) {
570 transform_tohost_VkImageFormatProperties(
571 m_state, (VkImageFormatProperties*)(pImageFormatProperties));
572 }
573 if (m_logCalls) {
574 fprintf(stderr,
575 "stream %p: call vkGetPhysicalDeviceImageFormatProperties 0x%llx "
576 "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
577 ioStream, (unsigned long long)physicalDevice,
578 (unsigned long long)format, (unsigned long long)type,
579 (unsigned long long)tiling, (unsigned long long)usage,
580 (unsigned long long)flags, (unsigned long long)pImageFormatProperties);
581 }
582 VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
583 vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
584 m_state->on_vkGetPhysicalDeviceImageFormatProperties(
585 &m_pool, physicalDevice, format, type, tiling, usage, flags,
586 pImageFormatProperties);
587 if ((vkGetPhysicalDeviceImageFormatProperties_VkResult_return) ==
588 VK_ERROR_DEVICE_LOST)
589 m_state->on_DeviceLost();
590 m_state->on_CheckOutOfMemory(
591 vkGetPhysicalDeviceImageFormatProperties_VkResult_return, opcode, context);
592 vkStream->unsetHandleMapping();
593 if (pImageFormatProperties) {
594 transform_fromhost_VkImageFormatProperties(
595 m_state, (VkImageFormatProperties*)(pImageFormatProperties));
596 }
597 marshal_VkImageFormatProperties(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
598 (VkImageFormatProperties*)(pImageFormatProperties));
599 vkStream->write(&vkGetPhysicalDeviceImageFormatProperties_VkResult_return,
600 sizeof(VkResult));
601 vkStream->commitWrite();
602 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
603 (uintptr_t)snapshotTraceBegin);
604 size_t snapshotTraceBytes = vkReadStream->endTrace();
605 if (m_state->snapshotsEnabled()) {
606 m_state->snapshot()->vkGetPhysicalDeviceImageFormatProperties(
607 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
608 vkGetPhysicalDeviceImageFormatProperties_VkResult_return, physicalDevice,
609 format, type, tiling, usage, flags, pImageFormatProperties);
610 }
611 vkReadStream->clearPool();
612 if (m_queueSubmitWithCommandsEnabled)
613 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
614 break;
615 }
616 case OP_vkGetPhysicalDeviceProperties: {
617 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
618 "VkDecoder vkGetPhysicalDeviceProperties");
619 VkPhysicalDevice physicalDevice;
620 VkPhysicalDeviceProperties* pProperties;
621 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
622 uint64_t cgen_var_0;
623 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
624 *readStreamPtrPtr += 1 * 8;
625 *(VkPhysicalDevice*)&physicalDevice =
626 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
627 // Begin manual dispatchable handle unboxing for pProperties;
628 vkReadStream->unsetHandleMapping();
629 vkReadStream->alloc((void**)&pProperties, sizeof(VkPhysicalDeviceProperties));
630 reservedunmarshal_VkPhysicalDeviceProperties(
631 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
632 (VkPhysicalDeviceProperties*)(pProperties), readStreamPtrPtr);
633 if (pProperties) {
634 transform_tohost_VkPhysicalDeviceProperties(
635 m_state, (VkPhysicalDeviceProperties*)(pProperties));
636 }
637 if (m_logCalls) {
638 fprintf(stderr,
639 "stream %p: call vkGetPhysicalDeviceProperties 0x%llx 0x%llx \n",
640 ioStream, (unsigned long long)physicalDevice,
641 (unsigned long long)pProperties);
642 }
643 m_state->on_vkGetPhysicalDeviceProperties(&m_pool, physicalDevice, pProperties);
644 vkStream->unsetHandleMapping();
645 if (pProperties) {
646 transform_fromhost_VkPhysicalDeviceProperties(
647 m_state, (VkPhysicalDeviceProperties*)(pProperties));
648 }
649 marshal_VkPhysicalDeviceProperties(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
650 (VkPhysicalDeviceProperties*)(pProperties));
651 vkStream->commitWrite();
652 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
653 (uintptr_t)snapshotTraceBegin);
654 size_t snapshotTraceBytes = vkReadStream->endTrace();
655 if (m_state->snapshotsEnabled()) {
656 m_state->snapshot()->vkGetPhysicalDeviceProperties(snapshotTraceBegin,
657 snapshotTraceBytes, &m_pool,
658 physicalDevice, pProperties);
659 }
660 vkReadStream->clearPool();
661 if (m_queueSubmitWithCommandsEnabled)
662 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
663 break;
664 }
665 case OP_vkGetPhysicalDeviceQueueFamilyProperties: {
666 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
667 "VkDecoder vkGetPhysicalDeviceQueueFamilyProperties");
668 VkPhysicalDevice physicalDevice;
669 uint32_t* pQueueFamilyPropertyCount;
670 VkQueueFamilyProperties* pQueueFamilyProperties;
671 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
672 uint64_t cgen_var_0;
673 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
674 *readStreamPtrPtr += 1 * 8;
675 *(VkPhysicalDevice*)&physicalDevice =
676 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
677 // Begin manual dispatchable handle unboxing for pQueueFamilyPropertyCount;
678 vkReadStream->unsetHandleMapping();
679 // WARNING PTR CHECK
680 memcpy((uint32_t**)&pQueueFamilyPropertyCount, (*readStreamPtrPtr), 8);
681 android::base::Stream::fromBe64((uint8_t*)&pQueueFamilyPropertyCount);
682 *readStreamPtrPtr += 8;
683 if (pQueueFamilyPropertyCount) {
684 vkReadStream->alloc((void**)&pQueueFamilyPropertyCount, sizeof(uint32_t));
685 memcpy((uint32_t*)pQueueFamilyPropertyCount, *readStreamPtrPtr,
686 sizeof(uint32_t));
687 *readStreamPtrPtr += sizeof(uint32_t);
688 }
689 // Begin manual dispatchable handle unboxing for pQueueFamilyProperties;
690 vkReadStream->unsetHandleMapping();
691 // WARNING PTR CHECK
692 memcpy((VkQueueFamilyProperties**)&pQueueFamilyProperties, (*readStreamPtrPtr), 8);
693 android::base::Stream::fromBe64((uint8_t*)&pQueueFamilyProperties);
694 *readStreamPtrPtr += 8;
695 if (pQueueFamilyProperties) {
696 vkReadStream->alloc(
697 (void**)&pQueueFamilyProperties,
698 (*(pQueueFamilyPropertyCount)) * sizeof(VkQueueFamilyProperties));
699 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
700 reservedunmarshal_VkQueueFamilyProperties(
701 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
702 (VkQueueFamilyProperties*)(pQueueFamilyProperties + i),
703 readStreamPtrPtr);
704 }
705 }
706 if (pQueueFamilyPropertyCount) {
707 if (pQueueFamilyProperties) {
708 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
709 transform_tohost_VkQueueFamilyProperties(
710 m_state, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
711 }
712 }
713 }
714 if (m_logCalls) {
715 fprintf(stderr,
716 "stream %p: call vkGetPhysicalDeviceQueueFamilyProperties 0x%llx "
717 "0x%llx 0x%llx \n",
718 ioStream, (unsigned long long)physicalDevice,
719 (unsigned long long)pQueueFamilyPropertyCount,
720 (unsigned long long)pQueueFamilyProperties);
721 }
722 m_state->on_vkGetPhysicalDeviceQueueFamilyProperties(
723 &m_pool, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
724 vkStream->unsetHandleMapping();
725 // WARNING PTR CHECK
726 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
727 vkStream->putBe64(cgen_var_3);
728 if (pQueueFamilyPropertyCount) {
729 vkStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
730 }
731 if (pQueueFamilyPropertyCount) {
732 if (pQueueFamilyProperties) {
733 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
734 transform_fromhost_VkQueueFamilyProperties(
735 m_state, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
736 }
737 }
738 }
739 // WARNING PTR CHECK
740 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
741 vkStream->putBe64(cgen_var_4);
742 if (pQueueFamilyProperties) {
743 if (pQueueFamilyPropertyCount) {
744 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
745 marshal_VkQueueFamilyProperties(
746 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
747 (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
748 }
749 }
750 }
751 vkStream->commitWrite();
752 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
753 (uintptr_t)snapshotTraceBegin);
754 size_t snapshotTraceBytes = vkReadStream->endTrace();
755 if (m_state->snapshotsEnabled()) {
756 m_state->snapshot()->vkGetPhysicalDeviceQueueFamilyProperties(
757 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
758 pQueueFamilyPropertyCount, pQueueFamilyProperties);
759 }
760 vkReadStream->clearPool();
761 if (m_queueSubmitWithCommandsEnabled)
762 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
763 break;
764 }
765 case OP_vkGetPhysicalDeviceMemoryProperties: {
766 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
767 "VkDecoder vkGetPhysicalDeviceMemoryProperties");
768 VkPhysicalDevice physicalDevice;
769 VkPhysicalDeviceMemoryProperties* pMemoryProperties;
770 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
771 uint64_t cgen_var_0;
772 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
773 *readStreamPtrPtr += 1 * 8;
774 *(VkPhysicalDevice*)&physicalDevice =
775 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
776 // Begin manual dispatchable handle unboxing for pMemoryProperties;
777 vkReadStream->unsetHandleMapping();
778 vkReadStream->alloc((void**)&pMemoryProperties,
779 sizeof(VkPhysicalDeviceMemoryProperties));
780 reservedunmarshal_VkPhysicalDeviceMemoryProperties(
781 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
782 (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties), readStreamPtrPtr);
783 if (pMemoryProperties) {
784 transform_tohost_VkPhysicalDeviceMemoryProperties(
785 m_state, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
786 }
787 if (m_logCalls) {
788 fprintf(stderr,
789 "stream %p: call vkGetPhysicalDeviceMemoryProperties 0x%llx 0x%llx \n",
790 ioStream, (unsigned long long)physicalDevice,
791 (unsigned long long)pMemoryProperties);
792 }
793 m_state->on_vkGetPhysicalDeviceMemoryProperties(&m_pool, physicalDevice,
794 pMemoryProperties);
795 vkStream->unsetHandleMapping();
796 if (pMemoryProperties) {
797 transform_fromhost_VkPhysicalDeviceMemoryProperties(
798 m_state, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
799 }
800 marshal_VkPhysicalDeviceMemoryProperties(
801 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
802 (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
803 vkStream->commitWrite();
804 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
805 (uintptr_t)snapshotTraceBegin);
806 size_t snapshotTraceBytes = vkReadStream->endTrace();
807 if (m_state->snapshotsEnabled()) {
808 m_state->snapshot()->vkGetPhysicalDeviceMemoryProperties(
809 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
810 pMemoryProperties);
811 }
812 vkReadStream->clearPool();
813 if (m_queueSubmitWithCommandsEnabled)
814 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
815 break;
816 }
817 case OP_vkGetInstanceProcAddr: {
818 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
819 "VkDecoder vkGetInstanceProcAddr");
820 VkInstance instance;
821 const char* pName;
822 // Begin non wrapped dispatchable handle unboxing for instance;
823 uint64_t cgen_var_0;
824 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
825 *readStreamPtrPtr += 1 * 8;
826 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
827 auto unboxed_instance = unbox_VkInstance(instance);
828 auto vk = dispatch_VkInstance(instance);
829 // End manual dispatchable handle unboxing for instance;
830 vkReadStream->loadStringInPlaceWithStreamPtr((char**)&pName, readStreamPtrPtr);
831 if (m_logCalls) {
832 fprintf(stderr, "stream %p: call vkGetInstanceProcAddr 0x%llx 0x%llx \n",
833 ioStream, (unsigned long long)instance, (unsigned long long)pName);
834 }
835 PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return =
836 (PFN_vkVoidFunction)0;
837 vkGetInstanceProcAddr_PFN_vkVoidFunction_return =
838 vk->vkGetInstanceProcAddr(unboxed_instance, pName);
839 vkStream->unsetHandleMapping();
840 vkStream->write(&vkGetInstanceProcAddr_PFN_vkVoidFunction_return,
841 sizeof(PFN_vkVoidFunction));
842 vkStream->commitWrite();
843 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
844 (uintptr_t)snapshotTraceBegin);
845 size_t snapshotTraceBytes = vkReadStream->endTrace();
846 if (m_state->snapshotsEnabled()) {
847 m_state->snapshot()->vkGetInstanceProcAddr(
848 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
849 vkGetInstanceProcAddr_PFN_vkVoidFunction_return, instance, pName);
850 }
851 vkReadStream->clearPool();
852 if (m_queueSubmitWithCommandsEnabled)
853 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
854 break;
855 }
856 case OP_vkGetDeviceProcAddr: {
857 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
858 "VkDecoder vkGetDeviceProcAddr");
859 VkDevice device;
860 const char* pName;
861 // Begin non wrapped dispatchable handle unboxing for device;
862 uint64_t cgen_var_0;
863 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
864 *readStreamPtrPtr += 1 * 8;
865 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
866 auto unboxed_device = unbox_VkDevice(device);
867 auto vk = dispatch_VkDevice(device);
868 // End manual dispatchable handle unboxing for device;
869 vkReadStream->loadStringInPlaceWithStreamPtr((char**)&pName, readStreamPtrPtr);
870 if (m_logCalls) {
871 fprintf(stderr, "stream %p: call vkGetDeviceProcAddr 0x%llx 0x%llx \n",
872 ioStream, (unsigned long long)device, (unsigned long long)pName);
873 }
874 PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return =
875 (PFN_vkVoidFunction)0;
876 vkGetDeviceProcAddr_PFN_vkVoidFunction_return =
877 vk->vkGetDeviceProcAddr(unboxed_device, pName);
878 vkStream->unsetHandleMapping();
879 vkStream->write(&vkGetDeviceProcAddr_PFN_vkVoidFunction_return,
880 sizeof(PFN_vkVoidFunction));
881 vkStream->commitWrite();
882 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
883 (uintptr_t)snapshotTraceBegin);
884 size_t snapshotTraceBytes = vkReadStream->endTrace();
885 if (m_state->snapshotsEnabled()) {
886 m_state->snapshot()->vkGetDeviceProcAddr(
887 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
888 vkGetDeviceProcAddr_PFN_vkVoidFunction_return, device, pName);
889 }
890 vkReadStream->clearPool();
891 if (m_queueSubmitWithCommandsEnabled)
892 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
893 break;
894 }
895 case OP_vkCreateDevice: {
896 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCreateDevice");
897 VkPhysicalDevice physicalDevice;
898 const VkDeviceCreateInfo* pCreateInfo;
899 const VkAllocationCallbacks* pAllocator;
900 VkDevice* pDevice;
901 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
902 uint64_t cgen_var_0;
903 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
904 *readStreamPtrPtr += 1 * 8;
905 *(VkPhysicalDevice*)&physicalDevice =
906 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
907 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkDeviceCreateInfo));
908 reservedunmarshal_VkDeviceCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
909 (VkDeviceCreateInfo*)(pCreateInfo),
910 readStreamPtrPtr);
911 // WARNING PTR CHECK
912 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
913 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
914 *readStreamPtrPtr += 8;
915 if (pAllocator) {
916 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
917 reservedunmarshal_VkAllocationCallbacks(
918 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
919 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
920 }
921 // Begin manual dispatchable handle unboxing for pDevice;
922 vkReadStream->unsetHandleMapping();
923 vkReadStream->alloc((void**)&pDevice, sizeof(VkDevice));
924 uint64_t cgen_var_2;
925 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
926 *readStreamPtrPtr += 8;
927 *(VkDevice*)pDevice = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_2));
928 if (pCreateInfo) {
929 transform_tohost_VkDeviceCreateInfo(m_state,
930 (VkDeviceCreateInfo*)(pCreateInfo));
931 }
932 if (pAllocator) {
933 transform_tohost_VkAllocationCallbacks(m_state,
934 (VkAllocationCallbacks*)(pAllocator));
935 }
936 if (m_logCalls) {
937 fprintf(stderr, "stream %p: call vkCreateDevice 0x%llx 0x%llx 0x%llx 0x%llx \n",
938 ioStream, (unsigned long long)physicalDevice,
939 (unsigned long long)pCreateInfo, (unsigned long long)pAllocator,
940 (unsigned long long)pDevice);
941 }
942 VkResult vkCreateDevice_VkResult_return = (VkResult)0;
943 vkCreateDevice_VkResult_return = m_state->on_vkCreateDevice(
944 &m_pool, physicalDevice, pCreateInfo, pAllocator, pDevice);
945 if ((vkCreateDevice_VkResult_return) == VK_ERROR_DEVICE_LOST)
946 m_state->on_DeviceLost();
947 m_state->on_CheckOutOfMemory(vkCreateDevice_VkResult_return, opcode, context);
948 vkStream->unsetHandleMapping();
949 uint64_t cgen_var_3;
950 static_assert(8 == sizeof(VkDevice),
951 "handle map overwrite requires VkDevice to be 8 bytes long");
952 vkStream->handleMapping()->mapHandles_VkDevice((VkDevice*)pDevice, 1);
953 vkStream->write((VkDevice*)pDevice, 8 * 1);
954 vkStream->write(&vkCreateDevice_VkResult_return, sizeof(VkResult));
955 vkStream->commitWrite();
956 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
957 (uintptr_t)snapshotTraceBegin);
958 size_t snapshotTraceBytes = vkReadStream->endTrace();
959 if (m_state->snapshotsEnabled()) {
960 m_state->snapshot()->vkCreateDevice(snapshotTraceBegin, snapshotTraceBytes,
961 &m_pool, vkCreateDevice_VkResult_return,
962 physicalDevice, pCreateInfo, pAllocator,
963 pDevice);
964 }
965 vkReadStream->clearPool();
966 if (m_queueSubmitWithCommandsEnabled)
967 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
968 break;
969 }
970 case OP_vkDestroyDevice: {
971 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
972 "VkDecoder vkDestroyDevice");
973 VkDevice device;
974 const VkAllocationCallbacks* pAllocator;
975 // Begin global wrapped dispatchable handle unboxing for device;
976 uint64_t cgen_var_0;
977 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
978 *readStreamPtrPtr += 1 * 8;
979 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
980 // WARNING PTR CHECK
981 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
982 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
983 *readStreamPtrPtr += 8;
984 if (pAllocator) {
985 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
986 reservedunmarshal_VkAllocationCallbacks(
987 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
988 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
989 }
990 if (pAllocator) {
991 transform_tohost_VkAllocationCallbacks(m_state,
992 (VkAllocationCallbacks*)(pAllocator));
993 }
994 if (m_logCalls) {
995 fprintf(stderr, "stream %p: call vkDestroyDevice 0x%llx 0x%llx \n", ioStream,
996 (unsigned long long)device, (unsigned long long)pAllocator);
997 }
998 m_state->on_vkDestroyDevice(&m_pool, device, pAllocator);
999 vkStream->unsetHandleMapping();
1000 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1001 (uintptr_t)snapshotTraceBegin);
1002 size_t snapshotTraceBytes = vkReadStream->endTrace();
1003 if (m_state->snapshotsEnabled()) {
1004 m_state->snapshot()->vkDestroyDevice(snapshotTraceBegin, snapshotTraceBytes,
1005 &m_pool, device, pAllocator);
1006 }
1007 vkReadStream->clearPool();
1008 if (m_queueSubmitWithCommandsEnabled)
1009 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1010 break;
1011 }
1012 case OP_vkEnumerateInstanceExtensionProperties: {
1013 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1014 "VkDecoder vkEnumerateInstanceExtensionProperties");
1015 const char* pLayerName;
1016 uint32_t* pPropertyCount;
1017 VkExtensionProperties* pProperties;
1018 if (vkReadStream->getFeatureBits() &
1019 VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
1020 // WARNING PTR CHECK
1021 memcpy((char**)&pLayerName, (*readStreamPtrPtr), 8);
1022 android::base::Stream::fromBe64((uint8_t*)&pLayerName);
1023 *readStreamPtrPtr += 8;
1024 if (pLayerName) {
1025 vkReadStream->loadStringInPlaceWithStreamPtr((char**)&pLayerName,
1026 readStreamPtrPtr);
1027 }
1028 } else {
1029 vkReadStream->loadStringInPlaceWithStreamPtr((char**)&pLayerName,
1030 readStreamPtrPtr);
1031 }
1032 // Begin manual dispatchable handle unboxing for pPropertyCount;
1033 vkReadStream->unsetHandleMapping();
1034 // WARNING PTR CHECK
1035 memcpy((uint32_t**)&pPropertyCount, (*readStreamPtrPtr), 8);
1036 android::base::Stream::fromBe64((uint8_t*)&pPropertyCount);
1037 *readStreamPtrPtr += 8;
1038 if (pPropertyCount) {
1039 vkReadStream->alloc((void**)&pPropertyCount, sizeof(uint32_t));
1040 memcpy((uint32_t*)pPropertyCount, *readStreamPtrPtr, sizeof(uint32_t));
1041 *readStreamPtrPtr += sizeof(uint32_t);
1042 }
1043 // Begin manual dispatchable handle unboxing for pProperties;
1044 vkReadStream->unsetHandleMapping();
1045 // WARNING PTR CHECK
1046 memcpy((VkExtensionProperties**)&pProperties, (*readStreamPtrPtr), 8);
1047 android::base::Stream::fromBe64((uint8_t*)&pProperties);
1048 *readStreamPtrPtr += 8;
1049 if (pProperties) {
1050 vkReadStream->alloc((void**)&pProperties,
1051 (*(pPropertyCount)) * sizeof(VkExtensionProperties));
1052 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1053 reservedunmarshal_VkExtensionProperties(
1054 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1055 (VkExtensionProperties*)(pProperties + i), readStreamPtrPtr);
1056 }
1057 }
1058 if (pPropertyCount) {
1059 if (pProperties) {
1060 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1061 transform_tohost_VkExtensionProperties(
1062 m_state, (VkExtensionProperties*)(pProperties + i));
1063 }
1064 }
1065 }
1066 if (m_logCalls) {
1067 fprintf(stderr,
1068 "stream %p: call vkEnumerateInstanceExtensionProperties 0x%llx 0x%llx "
1069 "0x%llx \n",
1070 ioStream, (unsigned long long)pLayerName,
1071 (unsigned long long)pPropertyCount, (unsigned long long)pProperties);
1072 }
1073 VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
1074 vkEnumerateInstanceExtensionProperties_VkResult_return =
1075 vk->vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount,
1076 pProperties);
1077 if ((vkEnumerateInstanceExtensionProperties_VkResult_return) ==
1078 VK_ERROR_DEVICE_LOST)
1079 m_state->on_DeviceLost();
1080 m_state->on_CheckOutOfMemory(vkEnumerateInstanceExtensionProperties_VkResult_return,
1081 opcode, context);
1082 vkStream->unsetHandleMapping();
1083 // WARNING PTR CHECK
1084 uint64_t cgen_var_2 = (uint64_t)(uintptr_t)pPropertyCount;
1085 vkStream->putBe64(cgen_var_2);
1086 if (pPropertyCount) {
1087 vkStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
1088 }
1089 if (pPropertyCount) {
1090 if (pProperties) {
1091 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1092 transform_fromhost_VkExtensionProperties(
1093 m_state, (VkExtensionProperties*)(pProperties + i));
1094 }
1095 }
1096 }
1097 // WARNING PTR CHECK
1098 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pProperties;
1099 vkStream->putBe64(cgen_var_3);
1100 if (pProperties) {
1101 if (pPropertyCount) {
1102 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1103 marshal_VkExtensionProperties(
1104 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1105 (VkExtensionProperties*)(pProperties + i));
1106 }
1107 }
1108 }
1109 vkStream->write(&vkEnumerateInstanceExtensionProperties_VkResult_return,
1110 sizeof(VkResult));
1111 vkStream->commitWrite();
1112 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1113 (uintptr_t)snapshotTraceBegin);
1114 size_t snapshotTraceBytes = vkReadStream->endTrace();
1115 if (m_state->snapshotsEnabled()) {
1116 m_state->snapshot()->vkEnumerateInstanceExtensionProperties(
1117 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
1118 vkEnumerateInstanceExtensionProperties_VkResult_return, pLayerName,
1119 pPropertyCount, pProperties);
1120 }
1121 vkReadStream->clearPool();
1122 if (m_queueSubmitWithCommandsEnabled)
1123 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1124 break;
1125 }
1126 case OP_vkEnumerateDeviceExtensionProperties: {
1127 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1128 "VkDecoder vkEnumerateDeviceExtensionProperties");
1129 VkPhysicalDevice physicalDevice;
1130 const char* pLayerName;
1131 uint32_t* pPropertyCount;
1132 VkExtensionProperties* pProperties;
1133 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
1134 uint64_t cgen_var_0;
1135 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1136 *readStreamPtrPtr += 1 * 8;
1137 *(VkPhysicalDevice*)&physicalDevice =
1138 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
1139 if (vkReadStream->getFeatureBits() &
1140 VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
1141 // WARNING PTR CHECK
1142 memcpy((char**)&pLayerName, (*readStreamPtrPtr), 8);
1143 android::base::Stream::fromBe64((uint8_t*)&pLayerName);
1144 *readStreamPtrPtr += 8;
1145 if (pLayerName) {
1146 vkReadStream->loadStringInPlaceWithStreamPtr((char**)&pLayerName,
1147 readStreamPtrPtr);
1148 }
1149 } else {
1150 vkReadStream->loadStringInPlaceWithStreamPtr((char**)&pLayerName,
1151 readStreamPtrPtr);
1152 }
1153 // Begin manual dispatchable handle unboxing for pPropertyCount;
1154 vkReadStream->unsetHandleMapping();
1155 // WARNING PTR CHECK
1156 memcpy((uint32_t**)&pPropertyCount, (*readStreamPtrPtr), 8);
1157 android::base::Stream::fromBe64((uint8_t*)&pPropertyCount);
1158 *readStreamPtrPtr += 8;
1159 if (pPropertyCount) {
1160 vkReadStream->alloc((void**)&pPropertyCount, sizeof(uint32_t));
1161 memcpy((uint32_t*)pPropertyCount, *readStreamPtrPtr, sizeof(uint32_t));
1162 *readStreamPtrPtr += sizeof(uint32_t);
1163 }
1164 // Begin manual dispatchable handle unboxing for pProperties;
1165 vkReadStream->unsetHandleMapping();
1166 // WARNING PTR CHECK
1167 memcpy((VkExtensionProperties**)&pProperties, (*readStreamPtrPtr), 8);
1168 android::base::Stream::fromBe64((uint8_t*)&pProperties);
1169 *readStreamPtrPtr += 8;
1170 if (pProperties) {
1171 vkReadStream->alloc((void**)&pProperties,
1172 (*(pPropertyCount)) * sizeof(VkExtensionProperties));
1173 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1174 reservedunmarshal_VkExtensionProperties(
1175 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1176 (VkExtensionProperties*)(pProperties + i), readStreamPtrPtr);
1177 }
1178 }
1179 if (pPropertyCount) {
1180 if (pProperties) {
1181 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1182 transform_tohost_VkExtensionProperties(
1183 m_state, (VkExtensionProperties*)(pProperties + i));
1184 }
1185 }
1186 }
1187 if (m_logCalls) {
1188 fprintf(stderr,
1189 "stream %p: call vkEnumerateDeviceExtensionProperties 0x%llx 0x%llx "
1190 "0x%llx 0x%llx \n",
1191 ioStream, (unsigned long long)physicalDevice,
1192 (unsigned long long)pLayerName, (unsigned long long)pPropertyCount,
1193 (unsigned long long)pProperties);
1194 }
1195 VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
1196 vkEnumerateDeviceExtensionProperties_VkResult_return =
1197 m_state->on_vkEnumerateDeviceExtensionProperties(
1198 &m_pool, physicalDevice, pLayerName, pPropertyCount, pProperties);
1199 if ((vkEnumerateDeviceExtensionProperties_VkResult_return) == VK_ERROR_DEVICE_LOST)
1200 m_state->on_DeviceLost();
1201 m_state->on_CheckOutOfMemory(vkEnumerateDeviceExtensionProperties_VkResult_return,
1202 opcode, context);
1203 vkStream->unsetHandleMapping();
1204 // WARNING PTR CHECK
1205 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pPropertyCount;
1206 vkStream->putBe64(cgen_var_3);
1207 if (pPropertyCount) {
1208 vkStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
1209 }
1210 if (pPropertyCount) {
1211 if (pProperties) {
1212 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1213 transform_fromhost_VkExtensionProperties(
1214 m_state, (VkExtensionProperties*)(pProperties + i));
1215 }
1216 }
1217 }
1218 // WARNING PTR CHECK
1219 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pProperties;
1220 vkStream->putBe64(cgen_var_4);
1221 if (pProperties) {
1222 if (pPropertyCount) {
1223 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1224 marshal_VkExtensionProperties(
1225 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1226 (VkExtensionProperties*)(pProperties + i));
1227 }
1228 }
1229 }
1230 vkStream->write(&vkEnumerateDeviceExtensionProperties_VkResult_return,
1231 sizeof(VkResult));
1232 vkStream->commitWrite();
1233 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1234 (uintptr_t)snapshotTraceBegin);
1235 size_t snapshotTraceBytes = vkReadStream->endTrace();
1236 if (m_state->snapshotsEnabled()) {
1237 m_state->snapshot()->vkEnumerateDeviceExtensionProperties(
1238 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
1239 vkEnumerateDeviceExtensionProperties_VkResult_return, physicalDevice,
1240 pLayerName, pPropertyCount, pProperties);
1241 }
1242 vkReadStream->clearPool();
1243 if (m_queueSubmitWithCommandsEnabled)
1244 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1245 break;
1246 }
1247 case OP_vkEnumerateInstanceLayerProperties: {
1248 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1249 "VkDecoder vkEnumerateInstanceLayerProperties");
1250 uint32_t* pPropertyCount;
1251 VkLayerProperties* pProperties;
1252 // Begin manual dispatchable handle unboxing for pPropertyCount;
1253 vkReadStream->unsetHandleMapping();
1254 // WARNING PTR CHECK
1255 memcpy((uint32_t**)&pPropertyCount, (*readStreamPtrPtr), 8);
1256 android::base::Stream::fromBe64((uint8_t*)&pPropertyCount);
1257 *readStreamPtrPtr += 8;
1258 if (pPropertyCount) {
1259 vkReadStream->alloc((void**)&pPropertyCount, sizeof(uint32_t));
1260 memcpy((uint32_t*)pPropertyCount, *readStreamPtrPtr, sizeof(uint32_t));
1261 *readStreamPtrPtr += sizeof(uint32_t);
1262 }
1263 // Begin manual dispatchable handle unboxing for pProperties;
1264 vkReadStream->unsetHandleMapping();
1265 // WARNING PTR CHECK
1266 memcpy((VkLayerProperties**)&pProperties, (*readStreamPtrPtr), 8);
1267 android::base::Stream::fromBe64((uint8_t*)&pProperties);
1268 *readStreamPtrPtr += 8;
1269 if (pProperties) {
1270 vkReadStream->alloc((void**)&pProperties,
1271 (*(pPropertyCount)) * sizeof(VkLayerProperties));
1272 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1273 reservedunmarshal_VkLayerProperties(
1274 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1275 (VkLayerProperties*)(pProperties + i), readStreamPtrPtr);
1276 }
1277 }
1278 if (pPropertyCount) {
1279 if (pProperties) {
1280 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1281 transform_tohost_VkLayerProperties(
1282 m_state, (VkLayerProperties*)(pProperties + i));
1283 }
1284 }
1285 }
1286 if (m_logCalls) {
1287 fprintf(stderr,
1288 "stream %p: call vkEnumerateInstanceLayerProperties 0x%llx 0x%llx \n",
1289 ioStream, (unsigned long long)pPropertyCount,
1290 (unsigned long long)pProperties);
1291 }
1292 VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
1293 vkEnumerateInstanceLayerProperties_VkResult_return =
1294 vk->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
1295 if ((vkEnumerateInstanceLayerProperties_VkResult_return) == VK_ERROR_DEVICE_LOST)
1296 m_state->on_DeviceLost();
1297 m_state->on_CheckOutOfMemory(vkEnumerateInstanceLayerProperties_VkResult_return,
1298 opcode, context);
1299 vkStream->unsetHandleMapping();
1300 // WARNING PTR CHECK
1301 uint64_t cgen_var_2 = (uint64_t)(uintptr_t)pPropertyCount;
1302 vkStream->putBe64(cgen_var_2);
1303 if (pPropertyCount) {
1304 vkStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
1305 }
1306 if (pPropertyCount) {
1307 if (pProperties) {
1308 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1309 transform_fromhost_VkLayerProperties(
1310 m_state, (VkLayerProperties*)(pProperties + i));
1311 }
1312 }
1313 }
1314 // WARNING PTR CHECK
1315 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pProperties;
1316 vkStream->putBe64(cgen_var_3);
1317 if (pProperties) {
1318 if (pPropertyCount) {
1319 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1320 marshal_VkLayerProperties(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1321 (VkLayerProperties*)(pProperties + i));
1322 }
1323 }
1324 }
1325 vkStream->write(&vkEnumerateInstanceLayerProperties_VkResult_return,
1326 sizeof(VkResult));
1327 vkStream->commitWrite();
1328 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1329 (uintptr_t)snapshotTraceBegin);
1330 size_t snapshotTraceBytes = vkReadStream->endTrace();
1331 if (m_state->snapshotsEnabled()) {
1332 m_state->snapshot()->vkEnumerateInstanceLayerProperties(
1333 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
1334 vkEnumerateInstanceLayerProperties_VkResult_return, pPropertyCount,
1335 pProperties);
1336 }
1337 vkReadStream->clearPool();
1338 if (m_queueSubmitWithCommandsEnabled)
1339 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1340 break;
1341 }
1342 case OP_vkEnumerateDeviceLayerProperties: {
1343 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1344 "VkDecoder vkEnumerateDeviceLayerProperties");
1345 VkPhysicalDevice physicalDevice;
1346 uint32_t* pPropertyCount;
1347 VkLayerProperties* pProperties;
1348 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
1349 uint64_t cgen_var_0;
1350 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1351 *readStreamPtrPtr += 1 * 8;
1352 *(VkPhysicalDevice*)&physicalDevice =
1353 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
1354 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
1355 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
1356 // End manual dispatchable handle unboxing for physicalDevice;
1357 // Begin manual dispatchable handle unboxing for pPropertyCount;
1358 vkReadStream->unsetHandleMapping();
1359 // WARNING PTR CHECK
1360 memcpy((uint32_t**)&pPropertyCount, (*readStreamPtrPtr), 8);
1361 android::base::Stream::fromBe64((uint8_t*)&pPropertyCount);
1362 *readStreamPtrPtr += 8;
1363 if (pPropertyCount) {
1364 vkReadStream->alloc((void**)&pPropertyCount, sizeof(uint32_t));
1365 memcpy((uint32_t*)pPropertyCount, *readStreamPtrPtr, sizeof(uint32_t));
1366 *readStreamPtrPtr += sizeof(uint32_t);
1367 }
1368 // Begin manual dispatchable handle unboxing for pProperties;
1369 vkReadStream->unsetHandleMapping();
1370 // WARNING PTR CHECK
1371 memcpy((VkLayerProperties**)&pProperties, (*readStreamPtrPtr), 8);
1372 android::base::Stream::fromBe64((uint8_t*)&pProperties);
1373 *readStreamPtrPtr += 8;
1374 if (pProperties) {
1375 vkReadStream->alloc((void**)&pProperties,
1376 (*(pPropertyCount)) * sizeof(VkLayerProperties));
1377 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1378 reservedunmarshal_VkLayerProperties(
1379 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1380 (VkLayerProperties*)(pProperties + i), readStreamPtrPtr);
1381 }
1382 }
1383 if (pPropertyCount) {
1384 if (pProperties) {
1385 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1386 transform_tohost_VkLayerProperties(
1387 m_state, (VkLayerProperties*)(pProperties + i));
1388 }
1389 }
1390 }
1391 if (m_logCalls) {
1392 fprintf(
1393 stderr,
1394 "stream %p: call vkEnumerateDeviceLayerProperties 0x%llx 0x%llx 0x%llx \n",
1395 ioStream, (unsigned long long)physicalDevice,
1396 (unsigned long long)pPropertyCount, (unsigned long long)pProperties);
1397 }
1398 VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
1399 vkEnumerateDeviceLayerProperties_VkResult_return =
1400 vk->vkEnumerateDeviceLayerProperties(unboxed_physicalDevice, pPropertyCount,
1401 pProperties);
1402 if ((vkEnumerateDeviceLayerProperties_VkResult_return) == VK_ERROR_DEVICE_LOST)
1403 m_state->on_DeviceLost();
1404 m_state->on_CheckOutOfMemory(vkEnumerateDeviceLayerProperties_VkResult_return,
1405 opcode, context);
1406 vkStream->unsetHandleMapping();
1407 // WARNING PTR CHECK
1408 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pPropertyCount;
1409 vkStream->putBe64(cgen_var_3);
1410 if (pPropertyCount) {
1411 vkStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
1412 }
1413 if (pPropertyCount) {
1414 if (pProperties) {
1415 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1416 transform_fromhost_VkLayerProperties(
1417 m_state, (VkLayerProperties*)(pProperties + i));
1418 }
1419 }
1420 }
1421 // WARNING PTR CHECK
1422 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pProperties;
1423 vkStream->putBe64(cgen_var_4);
1424 if (pProperties) {
1425 if (pPropertyCount) {
1426 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
1427 marshal_VkLayerProperties(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1428 (VkLayerProperties*)(pProperties + i));
1429 }
1430 }
1431 }
1432 vkStream->write(&vkEnumerateDeviceLayerProperties_VkResult_return,
1433 sizeof(VkResult));
1434 vkStream->commitWrite();
1435 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1436 (uintptr_t)snapshotTraceBegin);
1437 size_t snapshotTraceBytes = vkReadStream->endTrace();
1438 if (m_state->snapshotsEnabled()) {
1439 m_state->snapshot()->vkEnumerateDeviceLayerProperties(
1440 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
1441 vkEnumerateDeviceLayerProperties_VkResult_return, physicalDevice,
1442 pPropertyCount, pProperties);
1443 }
1444 vkReadStream->clearPool();
1445 if (m_queueSubmitWithCommandsEnabled)
1446 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1447 break;
1448 }
1449 case OP_vkGetDeviceQueue: {
1450 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1451 "VkDecoder vkGetDeviceQueue");
1452 VkDevice device;
1453 uint32_t queueFamilyIndex;
1454 uint32_t queueIndex;
1455 VkQueue* pQueue;
1456 // Begin global wrapped dispatchable handle unboxing for device;
1457 uint64_t cgen_var_0;
1458 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1459 *readStreamPtrPtr += 1 * 8;
1460 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
1461 memcpy((uint32_t*)&queueFamilyIndex, *readStreamPtrPtr, sizeof(uint32_t));
1462 *readStreamPtrPtr += sizeof(uint32_t);
1463 memcpy((uint32_t*)&queueIndex, *readStreamPtrPtr, sizeof(uint32_t));
1464 *readStreamPtrPtr += sizeof(uint32_t);
1465 // Begin manual dispatchable handle unboxing for pQueue;
1466 vkReadStream->unsetHandleMapping();
1467 vkReadStream->alloc((void**)&pQueue, sizeof(VkQueue));
1468 uint64_t cgen_var_1;
1469 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 8);
1470 *readStreamPtrPtr += 8;
1471 *(VkQueue*)pQueue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_1));
1472 if (m_logCalls) {
1473 fprintf(
1474 stderr, "stream %p: call vkGetDeviceQueue 0x%llx 0x%llx 0x%llx 0x%llx \n",
1475 ioStream, (unsigned long long)device, (unsigned long long)queueFamilyIndex,
1476 (unsigned long long)queueIndex, (unsigned long long)pQueue);
1477 }
1478 m_state->on_vkGetDeviceQueue(&m_pool, device, queueFamilyIndex, queueIndex, pQueue);
1479 vkStream->unsetHandleMapping();
1480 uint64_t cgen_var_2;
1481 static_assert(8 == sizeof(VkQueue),
1482 "handle map overwrite requires VkQueue to be 8 bytes long");
1483 vkStream->handleMapping()->mapHandles_VkQueue((VkQueue*)pQueue, 1);
1484 vkStream->write((VkQueue*)pQueue, 8 * 1);
1485 vkStream->commitWrite();
1486 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1487 (uintptr_t)snapshotTraceBegin);
1488 size_t snapshotTraceBytes = vkReadStream->endTrace();
1489 if (m_state->snapshotsEnabled()) {
1490 m_state->snapshot()->vkGetDeviceQueue(snapshotTraceBegin, snapshotTraceBytes,
1491 &m_pool, device, queueFamilyIndex,
1492 queueIndex, pQueue);
1493 }
1494 vkReadStream->clearPool();
1495 if (m_queueSubmitWithCommandsEnabled)
1496 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1497 break;
1498 }
1499 case OP_vkQueueSubmit: {
1500 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkQueueSubmit");
1501 VkQueue queue;
1502 uint32_t submitCount;
1503 const VkSubmitInfo* pSubmits;
1504 VkFence fence;
1505 // Begin global wrapped dispatchable handle unboxing for queue;
1506 uint64_t cgen_var_0;
1507 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1508 *readStreamPtrPtr += 1 * 8;
1509 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
1510 memcpy((uint32_t*)&submitCount, *readStreamPtrPtr, sizeof(uint32_t));
1511 *readStreamPtrPtr += sizeof(uint32_t);
1512 vkReadStream->alloc((void**)&pSubmits,
1513 ((submitCount)) * sizeof(const VkSubmitInfo));
1514 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
1515 reservedunmarshal_VkSubmitInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1516 (VkSubmitInfo*)(pSubmits + i), readStreamPtrPtr);
1517 }
1518 uint64_t cgen_var_1;
1519 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1520 *readStreamPtrPtr += 1 * 8;
1521 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
1522 if (pSubmits) {
1523 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
1524 transform_tohost_VkSubmitInfo(m_state, (VkSubmitInfo*)(pSubmits + i));
1525 }
1526 }
1527 if (m_logCalls) {
1528 fprintf(stderr, "stream %p: call vkQueueSubmit 0x%llx 0x%llx 0x%llx 0x%llx \n",
1529 ioStream, (unsigned long long)queue, (unsigned long long)submitCount,
1530 (unsigned long long)pSubmits, (unsigned long long)fence);
1531 }
1532 VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
1533 vkQueueSubmit_VkResult_return =
1534 m_state->on_vkQueueSubmit(&m_pool, queue, submitCount, pSubmits, fence);
1535 if ((vkQueueSubmit_VkResult_return) == VK_ERROR_DEVICE_LOST)
1536 m_state->on_DeviceLost();
1537 m_state->on_CheckOutOfMemory(vkQueueSubmit_VkResult_return, opcode, context);
1538 vkStream->unsetHandleMapping();
1539 vkStream->write(&vkQueueSubmit_VkResult_return, sizeof(VkResult));
1540 vkStream->commitWrite();
1541 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1542 (uintptr_t)snapshotTraceBegin);
1543 size_t snapshotTraceBytes = vkReadStream->endTrace();
1544 if (m_state->snapshotsEnabled()) {
1545 m_state->snapshot()->vkQueueSubmit(snapshotTraceBegin, snapshotTraceBytes,
1546 &m_pool, vkQueueSubmit_VkResult_return,
1547 queue, submitCount, pSubmits, fence);
1548 }
1549 vkReadStream->clearPool();
1550 if (m_queueSubmitWithCommandsEnabled)
1551 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1552 break;
1553 }
1554 case OP_vkQueueWaitIdle: {
1555 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1556 "VkDecoder vkQueueWaitIdle");
1557 VkQueue queue;
1558 // Begin global wrapped dispatchable handle unboxing for queue;
1559 uint64_t cgen_var_0;
1560 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1561 *readStreamPtrPtr += 1 * 8;
1562 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
1563 if (m_logCalls) {
1564 fprintf(stderr, "stream %p: call vkQueueWaitIdle 0x%llx \n", ioStream,
1565 (unsigned long long)queue);
1566 }
1567 if (m_queueSubmitWithCommandsEnabled)
1568 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1569 VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
1570 vkQueueWaitIdle_VkResult_return = m_state->on_vkQueueWaitIdle(&m_pool, queue);
1571 if ((vkQueueWaitIdle_VkResult_return) == VK_ERROR_DEVICE_LOST)
1572 m_state->on_DeviceLost();
1573 m_state->on_CheckOutOfMemory(vkQueueWaitIdle_VkResult_return, opcode, context);
1574 vkStream->unsetHandleMapping();
1575 vkStream->write(&vkQueueWaitIdle_VkResult_return, sizeof(VkResult));
1576 vkStream->commitWrite();
1577 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1578 (uintptr_t)snapshotTraceBegin);
1579 size_t snapshotTraceBytes = vkReadStream->endTrace();
1580 if (m_state->snapshotsEnabled()) {
1581 m_state->snapshot()->vkQueueWaitIdle(snapshotTraceBegin, snapshotTraceBytes,
1582 &m_pool, vkQueueWaitIdle_VkResult_return,
1583 queue);
1584 }
1585 vkReadStream->clearPool();
1586 break;
1587 }
1588 case OP_vkDeviceWaitIdle: {
1589 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1590 "VkDecoder vkDeviceWaitIdle");
1591 VkDevice device;
1592 // Begin non wrapped dispatchable handle unboxing for device;
1593 uint64_t cgen_var_0;
1594 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1595 *readStreamPtrPtr += 1 * 8;
1596 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
1597 auto unboxed_device = unbox_VkDevice(device);
1598 auto vk = dispatch_VkDevice(device);
1599 // End manual dispatchable handle unboxing for device;
1600 if (m_logCalls) {
1601 fprintf(stderr, "stream %p: call vkDeviceWaitIdle 0x%llx \n", ioStream,
1602 (unsigned long long)device);
1603 }
1604 if (m_queueSubmitWithCommandsEnabled)
1605 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1606 VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
1607 vkDeviceWaitIdle_VkResult_return = vk->vkDeviceWaitIdle(unboxed_device);
1608 if ((vkDeviceWaitIdle_VkResult_return) == VK_ERROR_DEVICE_LOST)
1609 m_state->on_DeviceLost();
1610 m_state->on_CheckOutOfMemory(vkDeviceWaitIdle_VkResult_return, opcode, context);
1611 vkStream->unsetHandleMapping();
1612 vkStream->write(&vkDeviceWaitIdle_VkResult_return, sizeof(VkResult));
1613 vkStream->commitWrite();
1614 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1615 (uintptr_t)snapshotTraceBegin);
1616 size_t snapshotTraceBytes = vkReadStream->endTrace();
1617 if (m_state->snapshotsEnabled()) {
1618 m_state->snapshot()->vkDeviceWaitIdle(snapshotTraceBegin, snapshotTraceBytes,
1619 &m_pool, vkDeviceWaitIdle_VkResult_return,
1620 device);
1621 }
1622 vkReadStream->clearPool();
1623 break;
1624 }
1625 case OP_vkAllocateMemory: {
1626 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1627 "VkDecoder vkAllocateMemory");
1628 VkDevice device;
1629 const VkMemoryAllocateInfo* pAllocateInfo;
1630 const VkAllocationCallbacks* pAllocator;
1631 VkDeviceMemory* pMemory;
1632 // Begin global wrapped dispatchable handle unboxing for device;
1633 uint64_t cgen_var_0;
1634 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1635 *readStreamPtrPtr += 1 * 8;
1636 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
1637 vkReadStream->alloc((void**)&pAllocateInfo, sizeof(const VkMemoryAllocateInfo));
1638 reservedunmarshal_VkMemoryAllocateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1639 (VkMemoryAllocateInfo*)(pAllocateInfo),
1640 readStreamPtrPtr);
1641 // WARNING PTR CHECK
1642 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
1643 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
1644 *readStreamPtrPtr += 8;
1645 if (pAllocator) {
1646 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
1647 reservedunmarshal_VkAllocationCallbacks(
1648 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1649 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
1650 }
1651 // Begin manual dispatchable handle unboxing for pMemory;
1652 vkReadStream->unsetHandleMapping();
1653 vkReadStream->alloc((void**)&pMemory, sizeof(VkDeviceMemory));
1654 uint64_t cgen_var_2;
1655 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
1656 *readStreamPtrPtr += 8;
1657 *(VkDeviceMemory*)pMemory =
1658 (VkDeviceMemory)(VkDeviceMemory)((VkDeviceMemory)(*&cgen_var_2));
1659 if (pAllocateInfo) {
1660 transform_tohost_VkMemoryAllocateInfo(m_state,
1661 (VkMemoryAllocateInfo*)(pAllocateInfo));
1662 }
1663 if (pAllocator) {
1664 transform_tohost_VkAllocationCallbacks(m_state,
1665 (VkAllocationCallbacks*)(pAllocator));
1666 }
1667 if (m_logCalls) {
1668 fprintf(stderr,
1669 "stream %p: call vkAllocateMemory 0x%llx 0x%llx 0x%llx 0x%llx \n",
1670 ioStream, (unsigned long long)device, (unsigned long long)pAllocateInfo,
1671 (unsigned long long)pAllocator, (unsigned long long)pMemory);
1672 }
1673 VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
1674 vkAllocateMemory_VkResult_return = m_state->on_vkAllocateMemory(
1675 &m_pool, device, pAllocateInfo, pAllocator, pMemory);
1676 if ((vkAllocateMemory_VkResult_return) == VK_ERROR_DEVICE_LOST)
1677 m_state->on_DeviceLost();
1678 m_state->on_CheckOutOfMemory(
1679 vkAllocateMemory_VkResult_return, opcode, context,
1680 std::make_optional<uint64_t>(pAllocateInfo->allocationSize));
1681 vkStream->unsetHandleMapping();
1682 // Begin manual non dispatchable handle create for pMemory;
1683 vkStream->unsetHandleMapping();
1684 uint64_t cgen_var_3;
1685 static_assert(8 == sizeof(VkDeviceMemory),
1686 "handle map overwrite requires VkDeviceMemory to be 8 bytes long");
1687 vkStream->handleMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)pMemory, 1);
1688 vkStream->write((VkDeviceMemory*)pMemory, 8 * 1);
1689 // Begin manual non dispatchable handle create for pMemory;
1690 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
1691 vkStream->write(&vkAllocateMemory_VkResult_return, sizeof(VkResult));
1692 vkStream->commitWrite();
1693 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1694 (uintptr_t)snapshotTraceBegin);
1695 size_t snapshotTraceBytes = vkReadStream->endTrace();
1696 if (m_state->snapshotsEnabled()) {
1697 m_state->snapshot()->vkAllocateMemory(snapshotTraceBegin, snapshotTraceBytes,
1698 &m_pool, vkAllocateMemory_VkResult_return,
1699 device, pAllocateInfo, pAllocator,
1700 pMemory);
1701 }
1702 vkReadStream->clearPool();
1703 if (m_queueSubmitWithCommandsEnabled)
1704 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1705 break;
1706 }
1707 case OP_vkFreeMemory: {
1708 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkFreeMemory");
1709 VkDevice device;
1710 VkDeviceMemory memory;
1711 const VkAllocationCallbacks* pAllocator;
1712 // Begin global wrapped dispatchable handle unboxing for device;
1713 uint64_t cgen_var_0;
1714 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1715 *readStreamPtrPtr += 1 * 8;
1716 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
1717 // Begin manual non dispatchable handle destroy unboxing for memory;
1718 VkDeviceMemory boxed_memory_preserve;
1719 uint64_t cgen_var_1;
1720 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1721 *readStreamPtrPtr += 1 * 8;
1722 *(VkDeviceMemory*)&memory =
1723 (VkDeviceMemory)(VkDeviceMemory)((VkDeviceMemory)(*&cgen_var_1));
1724 boxed_memory_preserve = memory;
1725 memory = try_unbox_VkDeviceMemory(memory);
1726 // WARNING PTR CHECK
1727 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
1728 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
1729 *readStreamPtrPtr += 8;
1730 if (pAllocator) {
1731 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
1732 reservedunmarshal_VkAllocationCallbacks(
1733 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1734 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
1735 }
1736 if (pAllocator) {
1737 transform_tohost_VkAllocationCallbacks(m_state,
1738 (VkAllocationCallbacks*)(pAllocator));
1739 }
1740 if (m_logCalls) {
1741 fprintf(stderr, "stream %p: call vkFreeMemory 0x%llx 0x%llx 0x%llx \n",
1742 ioStream, (unsigned long long)device, (unsigned long long)memory,
1743 (unsigned long long)pAllocator);
1744 }
1745 m_state->on_vkFreeMemory(&m_pool, device, memory, pAllocator);
1746 vkStream->unsetHandleMapping();
1747 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1748 (uintptr_t)snapshotTraceBegin);
1749 size_t snapshotTraceBytes = vkReadStream->endTrace();
1750 if (m_state->snapshotsEnabled()) {
1751 m_state->snapshot()->vkFreeMemory(snapshotTraceBegin, snapshotTraceBytes,
1752 &m_pool, device, boxed_memory_preserve,
1753 pAllocator);
1754 }
1755 delete_VkDeviceMemory(boxed_memory_preserve);
1756 vkReadStream->clearPool();
1757 if (m_queueSubmitWithCommandsEnabled)
1758 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1759 break;
1760 }
1761 case OP_vkMapMemory: {
1762 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkMapMemory");
1763 VkDevice device;
1764 VkDeviceMemory memory;
1765 VkDeviceSize offset;
1766 VkDeviceSize size;
1767 VkMemoryMapFlags flags;
1768 void** ppData;
1769 // Begin global wrapped dispatchable handle unboxing for device;
1770 uint64_t cgen_var_0;
1771 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1772 *readStreamPtrPtr += 1 * 8;
1773 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
1774 uint64_t cgen_var_1;
1775 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1776 *readStreamPtrPtr += 1 * 8;
1777 *(VkDeviceMemory*)&memory =
1778 (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_1));
1779 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1780 *readStreamPtrPtr += sizeof(VkDeviceSize);
1781 memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
1782 *readStreamPtrPtr += sizeof(VkDeviceSize);
1783 memcpy((VkMemoryMapFlags*)&flags, *readStreamPtrPtr, sizeof(VkMemoryMapFlags));
1784 *readStreamPtrPtr += sizeof(VkMemoryMapFlags);
1785 // Begin manual dispatchable handle unboxing for ppData;
1786 vkReadStream->unsetHandleMapping();
1787 // WARNING PTR CHECK
1788 memcpy((void***)&ppData, (*readStreamPtrPtr), 8);
1789 android::base::Stream::fromBe64((uint8_t*)&ppData);
1790 *readStreamPtrPtr += 8;
1791 if (ppData) {
1792 vkReadStream->alloc((void**)&ppData, sizeof(void*));
1793 memcpy((void**)ppData, *readStreamPtrPtr, sizeof(void*));
1794 *readStreamPtrPtr += sizeof(void*);
1795 }
1796 if (m_logCalls) {
1797 fprintf(
1798 stderr,
1799 "stream %p: call vkMapMemory 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
1800 ioStream, (unsigned long long)device, (unsigned long long)memory,
1801 (unsigned long long)offset, (unsigned long long)size,
1802 (unsigned long long)flags, (unsigned long long)ppData);
1803 }
1804 VkResult vkMapMemory_VkResult_return = (VkResult)0;
1805 vkMapMemory_VkResult_return =
1806 m_state->on_vkMapMemory(&m_pool, device, memory, offset, size, flags, ppData);
1807 if ((vkMapMemory_VkResult_return) == VK_ERROR_DEVICE_LOST) m_state->on_DeviceLost();
1808 m_state->on_CheckOutOfMemory(vkMapMemory_VkResult_return, opcode, context);
1809 vkStream->unsetHandleMapping();
1810 // WARNING PTR CHECK
1811 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)ppData;
1812 vkStream->putBe64(cgen_var_3);
1813 if (ppData) {
1814 vkStream->write((void**)ppData, sizeof(void*));
1815 }
1816 vkStream->write(&vkMapMemory_VkResult_return, sizeof(VkResult));
1817 vkStream->commitWrite();
1818 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1819 (uintptr_t)snapshotTraceBegin);
1820 size_t snapshotTraceBytes = vkReadStream->endTrace();
1821 if (m_state->snapshotsEnabled()) {
1822 m_state->snapshot()->vkMapMemory(snapshotTraceBegin, snapshotTraceBytes,
1823 &m_pool, vkMapMemory_VkResult_return, device,
1824 memory, offset, size, flags, ppData);
1825 }
1826 vkReadStream->clearPool();
1827 if (m_queueSubmitWithCommandsEnabled)
1828 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1829 break;
1830 }
1831 case OP_vkUnmapMemory: {
1832 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkUnmapMemory");
1833 VkDevice device;
1834 VkDeviceMemory memory;
1835 // Begin global wrapped dispatchable handle unboxing for device;
1836 uint64_t cgen_var_0;
1837 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1838 *readStreamPtrPtr += 1 * 8;
1839 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
1840 uint64_t cgen_var_1;
1841 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1842 *readStreamPtrPtr += 1 * 8;
1843 *(VkDeviceMemory*)&memory =
1844 (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_1));
1845 if (m_logCalls) {
1846 fprintf(stderr, "stream %p: call vkUnmapMemory 0x%llx 0x%llx \n", ioStream,
1847 (unsigned long long)device, (unsigned long long)memory);
1848 }
1849 m_state->on_vkUnmapMemory(&m_pool, device, memory);
1850 vkStream->unsetHandleMapping();
1851 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1852 (uintptr_t)snapshotTraceBegin);
1853 size_t snapshotTraceBytes = vkReadStream->endTrace();
1854 if (m_state->snapshotsEnabled()) {
1855 m_state->snapshot()->vkUnmapMemory(snapshotTraceBegin, snapshotTraceBytes,
1856 &m_pool, device, memory);
1857 }
1858 vkReadStream->clearPool();
1859 if (m_queueSubmitWithCommandsEnabled)
1860 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1861 break;
1862 }
1863 case OP_vkFlushMappedMemoryRanges: {
1864 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1865 "VkDecoder vkFlushMappedMemoryRanges");
1866 VkDevice device;
1867 uint32_t memoryRangeCount;
1868 const VkMappedMemoryRange* pMemoryRanges;
1869 // Begin non wrapped dispatchable handle unboxing for device;
1870 uint64_t cgen_var_0;
1871 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1872 *readStreamPtrPtr += 1 * 8;
1873 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
1874 auto unboxed_device = unbox_VkDevice(device);
1875 auto vk = dispatch_VkDevice(device);
1876 // End manual dispatchable handle unboxing for device;
1877 memcpy((uint32_t*)&memoryRangeCount, *readStreamPtrPtr, sizeof(uint32_t));
1878 *readStreamPtrPtr += sizeof(uint32_t);
1879 vkReadStream->alloc((void**)&pMemoryRanges,
1880 ((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
1881 for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
1882 reservedunmarshal_VkMappedMemoryRange(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1883 (VkMappedMemoryRange*)(pMemoryRanges + i),
1884 readStreamPtrPtr);
1885 }
1886 if (pMemoryRanges) {
1887 for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
1888 transform_tohost_VkMappedMemoryRange(
1889 m_state, (VkMappedMemoryRange*)(pMemoryRanges + i));
1890 }
1891 }
1892 if (m_logCalls) {
1893 fprintf(
1894 stderr, "stream %p: call vkFlushMappedMemoryRanges 0x%llx 0x%llx 0x%llx \n",
1895 ioStream, (unsigned long long)device, (unsigned long long)memoryRangeCount,
1896 (unsigned long long)pMemoryRanges);
1897 }
1898 if (!m_state->usingDirectMapping()) {
1899 // This is to deal with a deficiency in the encoder,;
1900 // where usingDirectMapping fails to set the proper packet size,;
1901 // meaning we can read off the end of the packet.;
1902 uint64_t sizeLeft = end - *readStreamPtrPtr;
1903 for (uint32_t i = 0; i < memoryRangeCount; ++i) {
1904 if (sizeLeft < sizeof(uint64_t)) {
1905 if (m_prevSeqno) {
1906 m_prevSeqno = m_prevSeqno.value() - 1;
1907 }
1908 return ptr - (unsigned char*)buf;
1909 ;
1910 }
1911 auto range = pMemoryRanges[i];
1912 auto memory = pMemoryRanges[i].memory;
1913 auto size = pMemoryRanges[i].size;
1914 auto offset = pMemoryRanges[i].offset;
1915 uint64_t readStream = 0;
1916 memcpy(&readStream, *readStreamPtrPtr, sizeof(uint64_t));
1917 *readStreamPtrPtr += sizeof(uint64_t);
1918 sizeLeft -= sizeof(uint64_t);
1919 auto hostPtr = m_state->getMappedHostPointer(memory);
1920 if (!hostPtr && readStream > 0)
1921 GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER));
1922 if (!hostPtr) continue;
1923 if (sizeLeft < readStream) {
1924 if (m_prevSeqno) {
1925 m_prevSeqno = m_prevSeqno.value() - 1;
1926 }
1927 return ptr - (unsigned char*)buf;
1928 ;
1929 }
1930 sizeLeft -= readStream;
1931 uint8_t* targetRange = hostPtr + offset;
1932 memcpy(targetRange, *readStreamPtrPtr, readStream);
1933 *readStreamPtrPtr += readStream;
1934 packetLen += 8 + readStream;
1935 }
1936 }
1937 VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
1938 vkFlushMappedMemoryRanges_VkResult_return =
1939 vk->vkFlushMappedMemoryRanges(unboxed_device, memoryRangeCount, pMemoryRanges);
1940 if ((vkFlushMappedMemoryRanges_VkResult_return) == VK_ERROR_DEVICE_LOST)
1941 m_state->on_DeviceLost();
1942 m_state->on_CheckOutOfMemory(vkFlushMappedMemoryRanges_VkResult_return, opcode,
1943 context);
1944 vkStream->unsetHandleMapping();
1945 vkStream->write(&vkFlushMappedMemoryRanges_VkResult_return, sizeof(VkResult));
1946 vkStream->commitWrite();
1947 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
1948 (uintptr_t)snapshotTraceBegin);
1949 size_t snapshotTraceBytes = vkReadStream->endTrace();
1950 if (m_state->snapshotsEnabled()) {
1951 m_state->snapshot()->vkFlushMappedMemoryRanges(
1952 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
1953 vkFlushMappedMemoryRanges_VkResult_return, device, memoryRangeCount,
1954 pMemoryRanges);
1955 }
1956 vkReadStream->clearPool();
1957 if (m_queueSubmitWithCommandsEnabled)
1958 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
1959 break;
1960 }
1961 case OP_vkInvalidateMappedMemoryRanges: {
1962 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1963 "VkDecoder vkInvalidateMappedMemoryRanges");
1964 VkDevice device;
1965 uint32_t memoryRangeCount;
1966 const VkMappedMemoryRange* pMemoryRanges;
1967 // Begin non wrapped dispatchable handle unboxing for device;
1968 uint64_t cgen_var_0;
1969 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1970 *readStreamPtrPtr += 1 * 8;
1971 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
1972 auto unboxed_device = unbox_VkDevice(device);
1973 auto vk = dispatch_VkDevice(device);
1974 // End manual dispatchable handle unboxing for device;
1975 memcpy((uint32_t*)&memoryRangeCount, *readStreamPtrPtr, sizeof(uint32_t));
1976 *readStreamPtrPtr += sizeof(uint32_t);
1977 vkReadStream->alloc((void**)&pMemoryRanges,
1978 ((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
1979 for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
1980 reservedunmarshal_VkMappedMemoryRange(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1981 (VkMappedMemoryRange*)(pMemoryRanges + i),
1982 readStreamPtrPtr);
1983 }
1984 if (pMemoryRanges) {
1985 for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
1986 transform_tohost_VkMappedMemoryRange(
1987 m_state, (VkMappedMemoryRange*)(pMemoryRanges + i));
1988 }
1989 }
1990 if (m_logCalls) {
1991 fprintf(
1992 stderr,
1993 "stream %p: call vkInvalidateMappedMemoryRanges 0x%llx 0x%llx 0x%llx \n",
1994 ioStream, (unsigned long long)device, (unsigned long long)memoryRangeCount,
1995 (unsigned long long)pMemoryRanges);
1996 }
1997 VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
1998 vkInvalidateMappedMemoryRanges_VkResult_return = vk->vkInvalidateMappedMemoryRanges(
1999 unboxed_device, memoryRangeCount, pMemoryRanges);
2000 if ((vkInvalidateMappedMemoryRanges_VkResult_return) == VK_ERROR_DEVICE_LOST)
2001 m_state->on_DeviceLost();
2002 m_state->on_CheckOutOfMemory(vkInvalidateMappedMemoryRanges_VkResult_return, opcode,
2003 context);
2004 vkStream->unsetHandleMapping();
2005 vkStream->write(&vkInvalidateMappedMemoryRanges_VkResult_return, sizeof(VkResult));
2006 if (!m_state->usingDirectMapping()) {
2007 for (uint32_t i = 0; i < memoryRangeCount; ++i) {
2008 auto range = pMemoryRanges[i];
2009 auto memory = range.memory;
2010 auto size = range.size;
2011 auto offset = range.offset;
2012 auto hostPtr = m_state->getMappedHostPointer(memory);
2013 auto actualSize =
2014 size == VK_WHOLE_SIZE ? m_state->getDeviceMemorySize(memory) : size;
2015 uint64_t writeStream = 0;
2016 if (!hostPtr) {
2017 vkStream->write(&writeStream, sizeof(uint64_t));
2018 continue;
2019 };
2020 uint8_t* targetRange = hostPtr + offset;
2021 writeStream = actualSize;
2022 vkStream->write(&writeStream, sizeof(uint64_t));
2023 vkStream->write(targetRange, actualSize);
2024 }
2025 }
2026 vkStream->commitWrite();
2027 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2028 (uintptr_t)snapshotTraceBegin);
2029 size_t snapshotTraceBytes = vkReadStream->endTrace();
2030 if (m_state->snapshotsEnabled()) {
2031 m_state->snapshot()->vkInvalidateMappedMemoryRanges(
2032 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
2033 vkInvalidateMappedMemoryRanges_VkResult_return, device, memoryRangeCount,
2034 pMemoryRanges);
2035 }
2036 vkReadStream->clearPool();
2037 if (m_queueSubmitWithCommandsEnabled)
2038 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2039 break;
2040 }
2041 case OP_vkGetDeviceMemoryCommitment: {
2042 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2043 "VkDecoder vkGetDeviceMemoryCommitment");
2044 VkDevice device;
2045 VkDeviceMemory memory;
2046 VkDeviceSize* pCommittedMemoryInBytes;
2047 // Begin non wrapped dispatchable handle unboxing for device;
2048 uint64_t cgen_var_0;
2049 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2050 *readStreamPtrPtr += 1 * 8;
2051 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2052 auto unboxed_device = unbox_VkDevice(device);
2053 auto vk = dispatch_VkDevice(device);
2054 // End manual dispatchable handle unboxing for device;
2055 uint64_t cgen_var_1;
2056 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2057 *readStreamPtrPtr += 1 * 8;
2058 *(VkDeviceMemory*)&memory =
2059 (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_1));
2060 // Begin manual dispatchable handle unboxing for pCommittedMemoryInBytes;
2061 vkReadStream->unsetHandleMapping();
2062 vkReadStream->alloc((void**)&pCommittedMemoryInBytes, sizeof(VkDeviceSize));
2063 memcpy((VkDeviceSize*)pCommittedMemoryInBytes, *readStreamPtrPtr,
2064 sizeof(VkDeviceSize));
2065 *readStreamPtrPtr += sizeof(VkDeviceSize);
2066 if (m_logCalls) {
2067 fprintf(stderr,
2068 "stream %p: call vkGetDeviceMemoryCommitment 0x%llx 0x%llx 0x%llx \n",
2069 ioStream, (unsigned long long)device, (unsigned long long)memory,
2070 (unsigned long long)pCommittedMemoryInBytes);
2071 }
2072 vk->vkGetDeviceMemoryCommitment(unboxed_device, memory, pCommittedMemoryInBytes);
2073 vkStream->unsetHandleMapping();
2074 vkStream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
2075 vkStream->commitWrite();
2076 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2077 (uintptr_t)snapshotTraceBegin);
2078 size_t snapshotTraceBytes = vkReadStream->endTrace();
2079 if (m_state->snapshotsEnabled()) {
2080 m_state->snapshot()->vkGetDeviceMemoryCommitment(
2081 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, memory,
2082 pCommittedMemoryInBytes);
2083 }
2084 vkReadStream->clearPool();
2085 if (m_queueSubmitWithCommandsEnabled)
2086 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2087 break;
2088 }
2089 case OP_vkBindBufferMemory: {
2090 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2091 "VkDecoder vkBindBufferMemory");
2092 VkDevice device;
2093 VkBuffer buffer;
2094 VkDeviceMemory memory;
2095 VkDeviceSize memoryOffset;
2096 // Begin global wrapped dispatchable handle unboxing for device;
2097 uint64_t cgen_var_0;
2098 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2099 *readStreamPtrPtr += 1 * 8;
2100 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2101 uint64_t cgen_var_1;
2102 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2103 *readStreamPtrPtr += 1 * 8;
2104 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
2105 uint64_t cgen_var_2;
2106 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
2107 *readStreamPtrPtr += 1 * 8;
2108 *(VkDeviceMemory*)&memory =
2109 (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_2));
2110 memcpy((VkDeviceSize*)&memoryOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2111 *readStreamPtrPtr += sizeof(VkDeviceSize);
2112 if (m_logCalls) {
2113 fprintf(stderr,
2114 "stream %p: call vkBindBufferMemory 0x%llx 0x%llx 0x%llx 0x%llx \n",
2115 ioStream, (unsigned long long)device, (unsigned long long)buffer,
2116 (unsigned long long)memory, (unsigned long long)memoryOffset);
2117 }
2118 VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
2119 vkBindBufferMemory_VkResult_return =
2120 m_state->on_vkBindBufferMemory(&m_pool, device, buffer, memory, memoryOffset);
2121 if ((vkBindBufferMemory_VkResult_return) == VK_ERROR_DEVICE_LOST)
2122 m_state->on_DeviceLost();
2123 m_state->on_CheckOutOfMemory(vkBindBufferMemory_VkResult_return, opcode, context);
2124 vkStream->unsetHandleMapping();
2125 vkStream->write(&vkBindBufferMemory_VkResult_return, sizeof(VkResult));
2126 vkStream->commitWrite();
2127 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2128 (uintptr_t)snapshotTraceBegin);
2129 size_t snapshotTraceBytes = vkReadStream->endTrace();
2130 if (m_state->snapshotsEnabled()) {
2131 m_state->snapshot()->vkBindBufferMemory(
2132 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
2133 vkBindBufferMemory_VkResult_return, device, buffer, memory, memoryOffset);
2134 }
2135 vkReadStream->clearPool();
2136 if (m_queueSubmitWithCommandsEnabled)
2137 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2138 break;
2139 }
2140 case OP_vkBindImageMemory: {
2141 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2142 "VkDecoder vkBindImageMemory");
2143 VkDevice device;
2144 VkImage image;
2145 VkDeviceMemory memory;
2146 VkDeviceSize memoryOffset;
2147 // Begin global wrapped dispatchable handle unboxing for device;
2148 uint64_t cgen_var_0;
2149 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2150 *readStreamPtrPtr += 1 * 8;
2151 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2152 uint64_t cgen_var_1;
2153 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2154 *readStreamPtrPtr += 1 * 8;
2155 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
2156 uint64_t cgen_var_2;
2157 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
2158 *readStreamPtrPtr += 1 * 8;
2159 *(VkDeviceMemory*)&memory =
2160 (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_2));
2161 memcpy((VkDeviceSize*)&memoryOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2162 *readStreamPtrPtr += sizeof(VkDeviceSize);
2163 if (m_logCalls) {
2164 fprintf(stderr,
2165 "stream %p: call vkBindImageMemory 0x%llx 0x%llx 0x%llx 0x%llx \n",
2166 ioStream, (unsigned long long)device, (unsigned long long)image,
2167 (unsigned long long)memory, (unsigned long long)memoryOffset);
2168 }
2169 VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
2170 vkBindImageMemory_VkResult_return =
2171 m_state->on_vkBindImageMemory(&m_pool, device, image, memory, memoryOffset);
2172 if ((vkBindImageMemory_VkResult_return) == VK_ERROR_DEVICE_LOST)
2173 m_state->on_DeviceLost();
2174 m_state->on_CheckOutOfMemory(vkBindImageMemory_VkResult_return, opcode, context);
2175 vkStream->unsetHandleMapping();
2176 vkStream->write(&vkBindImageMemory_VkResult_return, sizeof(VkResult));
2177 vkStream->commitWrite();
2178 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2179 (uintptr_t)snapshotTraceBegin);
2180 size_t snapshotTraceBytes = vkReadStream->endTrace();
2181 if (m_state->snapshotsEnabled()) {
2182 m_state->snapshot()->vkBindImageMemory(
2183 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
2184 vkBindImageMemory_VkResult_return, device, image, memory, memoryOffset);
2185 }
2186 vkReadStream->clearPool();
2187 if (m_queueSubmitWithCommandsEnabled)
2188 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2189 break;
2190 }
2191 case OP_vkGetBufferMemoryRequirements: {
2192 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2193 "VkDecoder vkGetBufferMemoryRequirements");
2194 VkDevice device;
2195 VkBuffer buffer;
2196 VkMemoryRequirements* pMemoryRequirements;
2197 // Begin global wrapped dispatchable handle unboxing for device;
2198 uint64_t cgen_var_0;
2199 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2200 *readStreamPtrPtr += 1 * 8;
2201 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2202 uint64_t cgen_var_1;
2203 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2204 *readStreamPtrPtr += 1 * 8;
2205 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
2206 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
2207 vkReadStream->unsetHandleMapping();
2208 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements));
2209 reservedunmarshal_VkMemoryRequirements(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2210 (VkMemoryRequirements*)(pMemoryRequirements),
2211 readStreamPtrPtr);
2212 if (pMemoryRequirements) {
2213 transform_tohost_VkMemoryRequirements(
2214 m_state, (VkMemoryRequirements*)(pMemoryRequirements));
2215 }
2216 if (m_logCalls) {
2217 fprintf(stderr,
2218 "stream %p: call vkGetBufferMemoryRequirements 0x%llx 0x%llx 0x%llx \n",
2219 ioStream, (unsigned long long)device, (unsigned long long)buffer,
2220 (unsigned long long)pMemoryRequirements);
2221 }
2222 m_state->on_vkGetBufferMemoryRequirements(&m_pool, device, buffer,
2223 pMemoryRequirements);
2224 vkStream->unsetHandleMapping();
2225 if (pMemoryRequirements) {
2226 transform_fromhost_VkMemoryRequirements(
2227 m_state, (VkMemoryRequirements*)(pMemoryRequirements));
2228 }
2229 marshal_VkMemoryRequirements(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2230 (VkMemoryRequirements*)(pMemoryRequirements));
2231 vkStream->commitWrite();
2232 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2233 (uintptr_t)snapshotTraceBegin);
2234 size_t snapshotTraceBytes = vkReadStream->endTrace();
2235 if (m_state->snapshotsEnabled()) {
2236 m_state->snapshot()->vkGetBufferMemoryRequirements(
2237 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, buffer,
2238 pMemoryRequirements);
2239 }
2240 vkReadStream->clearPool();
2241 if (m_queueSubmitWithCommandsEnabled)
2242 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2243 break;
2244 }
2245 case OP_vkGetImageMemoryRequirements: {
2246 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2247 "VkDecoder vkGetImageMemoryRequirements");
2248 VkDevice device;
2249 VkImage image;
2250 VkMemoryRequirements* pMemoryRequirements;
2251 // Begin global wrapped dispatchable handle unboxing for device;
2252 uint64_t cgen_var_0;
2253 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2254 *readStreamPtrPtr += 1 * 8;
2255 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2256 uint64_t cgen_var_1;
2257 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2258 *readStreamPtrPtr += 1 * 8;
2259 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
2260 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
2261 vkReadStream->unsetHandleMapping();
2262 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements));
2263 reservedunmarshal_VkMemoryRequirements(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2264 (VkMemoryRequirements*)(pMemoryRequirements),
2265 readStreamPtrPtr);
2266 if (pMemoryRequirements) {
2267 transform_tohost_VkMemoryRequirements(
2268 m_state, (VkMemoryRequirements*)(pMemoryRequirements));
2269 }
2270 if (m_logCalls) {
2271 fprintf(stderr,
2272 "stream %p: call vkGetImageMemoryRequirements 0x%llx 0x%llx 0x%llx \n",
2273 ioStream, (unsigned long long)device, (unsigned long long)image,
2274 (unsigned long long)pMemoryRequirements);
2275 }
2276 m_state->on_vkGetImageMemoryRequirements(&m_pool, device, image,
2277 pMemoryRequirements);
2278 vkStream->unsetHandleMapping();
2279 if (pMemoryRequirements) {
2280 transform_fromhost_VkMemoryRequirements(
2281 m_state, (VkMemoryRequirements*)(pMemoryRequirements));
2282 }
2283 marshal_VkMemoryRequirements(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2284 (VkMemoryRequirements*)(pMemoryRequirements));
2285 vkStream->commitWrite();
2286 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2287 (uintptr_t)snapshotTraceBegin);
2288 size_t snapshotTraceBytes = vkReadStream->endTrace();
2289 if (m_state->snapshotsEnabled()) {
2290 m_state->snapshot()->vkGetImageMemoryRequirements(
2291 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, image,
2292 pMemoryRequirements);
2293 }
2294 vkReadStream->clearPool();
2295 if (m_queueSubmitWithCommandsEnabled)
2296 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2297 break;
2298 }
2299 case OP_vkGetImageSparseMemoryRequirements: {
2300 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2301 "VkDecoder vkGetImageSparseMemoryRequirements");
2302 VkDevice device;
2303 VkImage image;
2304 uint32_t* pSparseMemoryRequirementCount;
2305 VkSparseImageMemoryRequirements* pSparseMemoryRequirements;
2306 // Begin non wrapped dispatchable handle unboxing for device;
2307 uint64_t cgen_var_0;
2308 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2309 *readStreamPtrPtr += 1 * 8;
2310 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2311 auto unboxed_device = unbox_VkDevice(device);
2312 auto vk = dispatch_VkDevice(device);
2313 // End manual dispatchable handle unboxing for device;
2314 uint64_t cgen_var_1;
2315 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2316 *readStreamPtrPtr += 1 * 8;
2317 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
2318 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirementCount;
2319 vkReadStream->unsetHandleMapping();
2320 // WARNING PTR CHECK
2321 memcpy((uint32_t**)&pSparseMemoryRequirementCount, (*readStreamPtrPtr), 8);
2322 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirementCount);
2323 *readStreamPtrPtr += 8;
2324 if (pSparseMemoryRequirementCount) {
2325 vkReadStream->alloc((void**)&pSparseMemoryRequirementCount, sizeof(uint32_t));
2326 memcpy((uint32_t*)pSparseMemoryRequirementCount, *readStreamPtrPtr,
2327 sizeof(uint32_t));
2328 *readStreamPtrPtr += sizeof(uint32_t);
2329 }
2330 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirements;
2331 vkReadStream->unsetHandleMapping();
2332 // WARNING PTR CHECK
2333 memcpy((VkSparseImageMemoryRequirements**)&pSparseMemoryRequirements,
2334 (*readStreamPtrPtr), 8);
2335 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirements);
2336 *readStreamPtrPtr += 8;
2337 if (pSparseMemoryRequirements) {
2338 vkReadStream->alloc((void**)&pSparseMemoryRequirements,
2339 (*(pSparseMemoryRequirementCount)) *
2340 sizeof(VkSparseImageMemoryRequirements));
2341 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
2342 reservedunmarshal_VkSparseImageMemoryRequirements(
2343 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2344 (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i),
2345 readStreamPtrPtr);
2346 }
2347 }
2348 if (pSparseMemoryRequirementCount) {
2349 if (pSparseMemoryRequirements) {
2350 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
2351 ++i) {
2352 transform_tohost_VkSparseImageMemoryRequirements(
2353 m_state,
2354 (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
2355 }
2356 }
2357 }
2358 if (m_logCalls) {
2359 fprintf(stderr,
2360 "stream %p: call vkGetImageSparseMemoryRequirements 0x%llx 0x%llx "
2361 "0x%llx 0x%llx \n",
2362 ioStream, (unsigned long long)device, (unsigned long long)image,
2363 (unsigned long long)pSparseMemoryRequirementCount,
2364 (unsigned long long)pSparseMemoryRequirements);
2365 }
2366 vk->vkGetImageSparseMemoryRequirements(unboxed_device, image,
2367 pSparseMemoryRequirementCount,
2368 pSparseMemoryRequirements);
2369 vkStream->unsetHandleMapping();
2370 // WARNING PTR CHECK
2371 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
2372 vkStream->putBe64(cgen_var_4);
2373 if (pSparseMemoryRequirementCount) {
2374 vkStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
2375 }
2376 if (pSparseMemoryRequirementCount) {
2377 if (pSparseMemoryRequirements) {
2378 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
2379 ++i) {
2380 transform_fromhost_VkSparseImageMemoryRequirements(
2381 m_state,
2382 (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
2383 }
2384 }
2385 }
2386 // WARNING PTR CHECK
2387 uint64_t cgen_var_5 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
2388 vkStream->putBe64(cgen_var_5);
2389 if (pSparseMemoryRequirements) {
2390 if (pSparseMemoryRequirementCount) {
2391 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
2392 ++i) {
2393 marshal_VkSparseImageMemoryRequirements(
2394 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2395 (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
2396 }
2397 }
2398 }
2399 vkStream->commitWrite();
2400 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2401 (uintptr_t)snapshotTraceBegin);
2402 size_t snapshotTraceBytes = vkReadStream->endTrace();
2403 if (m_state->snapshotsEnabled()) {
2404 m_state->snapshot()->vkGetImageSparseMemoryRequirements(
2405 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, image,
2406 pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2407 }
2408 vkReadStream->clearPool();
2409 if (m_queueSubmitWithCommandsEnabled)
2410 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2411 break;
2412 }
2413 case OP_vkGetPhysicalDeviceSparseImageFormatProperties: {
2414 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2415 "VkDecoder vkGetPhysicalDeviceSparseImageFormatProperties");
2416 VkPhysicalDevice physicalDevice;
2417 VkFormat format;
2418 VkImageType type;
2419 VkSampleCountFlagBits samples;
2420 VkImageUsageFlags usage;
2421 VkImageTiling tiling;
2422 uint32_t* pPropertyCount;
2423 VkSparseImageFormatProperties* pProperties;
2424 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
2425 uint64_t cgen_var_0;
2426 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2427 *readStreamPtrPtr += 1 * 8;
2428 *(VkPhysicalDevice*)&physicalDevice =
2429 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
2430 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
2431 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
2432 // End manual dispatchable handle unboxing for physicalDevice;
2433 memcpy((VkFormat*)&format, *readStreamPtrPtr, sizeof(VkFormat));
2434 *readStreamPtrPtr += sizeof(VkFormat);
2435 memcpy((VkImageType*)&type, *readStreamPtrPtr, sizeof(VkImageType));
2436 *readStreamPtrPtr += sizeof(VkImageType);
2437 memcpy((VkSampleCountFlagBits*)&samples, *readStreamPtrPtr,
2438 sizeof(VkSampleCountFlagBits));
2439 *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
2440 memcpy((VkImageUsageFlags*)&usage, *readStreamPtrPtr, sizeof(VkImageUsageFlags));
2441 *readStreamPtrPtr += sizeof(VkImageUsageFlags);
2442 memcpy((VkImageTiling*)&tiling, *readStreamPtrPtr, sizeof(VkImageTiling));
2443 *readStreamPtrPtr += sizeof(VkImageTiling);
2444 // Begin manual dispatchable handle unboxing for pPropertyCount;
2445 vkReadStream->unsetHandleMapping();
2446 // WARNING PTR CHECK
2447 memcpy((uint32_t**)&pPropertyCount, (*readStreamPtrPtr), 8);
2448 android::base::Stream::fromBe64((uint8_t*)&pPropertyCount);
2449 *readStreamPtrPtr += 8;
2450 if (pPropertyCount) {
2451 vkReadStream->alloc((void**)&pPropertyCount, sizeof(uint32_t));
2452 memcpy((uint32_t*)pPropertyCount, *readStreamPtrPtr, sizeof(uint32_t));
2453 *readStreamPtrPtr += sizeof(uint32_t);
2454 }
2455 // Begin manual dispatchable handle unboxing for pProperties;
2456 vkReadStream->unsetHandleMapping();
2457 // WARNING PTR CHECK
2458 memcpy((VkSparseImageFormatProperties**)&pProperties, (*readStreamPtrPtr), 8);
2459 android::base::Stream::fromBe64((uint8_t*)&pProperties);
2460 *readStreamPtrPtr += 8;
2461 if (pProperties) {
2462 vkReadStream->alloc(
2463 (void**)&pProperties,
2464 (*(pPropertyCount)) * sizeof(VkSparseImageFormatProperties));
2465 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
2466 reservedunmarshal_VkSparseImageFormatProperties(
2467 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2468 (VkSparseImageFormatProperties*)(pProperties + i), readStreamPtrPtr);
2469 }
2470 }
2471 if (pPropertyCount) {
2472 if (pProperties) {
2473 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
2474 transform_tohost_VkSparseImageFormatProperties(
2475 m_state, (VkSparseImageFormatProperties*)(pProperties + i));
2476 }
2477 }
2478 }
2479 if (m_logCalls) {
2480 fprintf(stderr,
2481 "stream %p: call vkGetPhysicalDeviceSparseImageFormatProperties 0x%llx "
2482 "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
2483 ioStream, (unsigned long long)physicalDevice,
2484 (unsigned long long)format, (unsigned long long)type,
2485 (unsigned long long)samples, (unsigned long long)usage,
2486 (unsigned long long)tiling, (unsigned long long)pPropertyCount,
2487 (unsigned long long)pProperties);
2488 }
2489 vk->vkGetPhysicalDeviceSparseImageFormatProperties(unboxed_physicalDevice, format,
2490 type, samples, usage, tiling,
2491 pPropertyCount, pProperties);
2492 vkStream->unsetHandleMapping();
2493 // WARNING PTR CHECK
2494 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pPropertyCount;
2495 vkStream->putBe64(cgen_var_3);
2496 if (pPropertyCount) {
2497 vkStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
2498 }
2499 if (pPropertyCount) {
2500 if (pProperties) {
2501 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
2502 transform_fromhost_VkSparseImageFormatProperties(
2503 m_state, (VkSparseImageFormatProperties*)(pProperties + i));
2504 }
2505 }
2506 }
2507 // WARNING PTR CHECK
2508 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pProperties;
2509 vkStream->putBe64(cgen_var_4);
2510 if (pProperties) {
2511 if (pPropertyCount) {
2512 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
2513 marshal_VkSparseImageFormatProperties(
2514 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2515 (VkSparseImageFormatProperties*)(pProperties + i));
2516 }
2517 }
2518 }
2519 vkStream->commitWrite();
2520 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2521 (uintptr_t)snapshotTraceBegin);
2522 size_t snapshotTraceBytes = vkReadStream->endTrace();
2523 if (m_state->snapshotsEnabled()) {
2524 m_state->snapshot()->vkGetPhysicalDeviceSparseImageFormatProperties(
2525 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice, format,
2526 type, samples, usage, tiling, pPropertyCount, pProperties);
2527 }
2528 vkReadStream->clearPool();
2529 if (m_queueSubmitWithCommandsEnabled)
2530 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2531 break;
2532 }
2533 case OP_vkQueueBindSparse: {
2534 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2535 "VkDecoder vkQueueBindSparse");
2536 VkQueue queue;
2537 uint32_t bindInfoCount;
2538 const VkBindSparseInfo* pBindInfo;
2539 VkFence fence;
2540 // Begin global wrapped dispatchable handle unboxing for queue;
2541 uint64_t cgen_var_0;
2542 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2543 *readStreamPtrPtr += 1 * 8;
2544 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
2545 memcpy((uint32_t*)&bindInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
2546 *readStreamPtrPtr += sizeof(uint32_t);
2547 vkReadStream->alloc((void**)&pBindInfo,
2548 ((bindInfoCount)) * sizeof(const VkBindSparseInfo));
2549 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
2550 reservedunmarshal_VkBindSparseInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2551 (VkBindSparseInfo*)(pBindInfo + i),
2552 readStreamPtrPtr);
2553 }
2554 uint64_t cgen_var_1;
2555 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2556 *readStreamPtrPtr += 1 * 8;
2557 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
2558 if (pBindInfo) {
2559 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
2560 transform_tohost_VkBindSparseInfo(m_state,
2561 (VkBindSparseInfo*)(pBindInfo + i));
2562 }
2563 }
2564 if (m_logCalls) {
2565 fprintf(stderr,
2566 "stream %p: call vkQueueBindSparse 0x%llx 0x%llx 0x%llx 0x%llx \n",
2567 ioStream, (unsigned long long)queue, (unsigned long long)bindInfoCount,
2568 (unsigned long long)pBindInfo, (unsigned long long)fence);
2569 }
2570 VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
2571 vkQueueBindSparse_VkResult_return =
2572 m_state->on_vkQueueBindSparse(&m_pool, queue, bindInfoCount, pBindInfo, fence);
2573 if ((vkQueueBindSparse_VkResult_return) == VK_ERROR_DEVICE_LOST)
2574 m_state->on_DeviceLost();
2575 m_state->on_CheckOutOfMemory(vkQueueBindSparse_VkResult_return, opcode, context);
2576 vkStream->unsetHandleMapping();
2577 vkStream->write(&vkQueueBindSparse_VkResult_return, sizeof(VkResult));
2578 vkStream->commitWrite();
2579 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2580 (uintptr_t)snapshotTraceBegin);
2581 size_t snapshotTraceBytes = vkReadStream->endTrace();
2582 if (m_state->snapshotsEnabled()) {
2583 m_state->snapshot()->vkQueueBindSparse(
2584 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
2585 vkQueueBindSparse_VkResult_return, queue, bindInfoCount, pBindInfo, fence);
2586 }
2587 vkReadStream->clearPool();
2588 if (m_queueSubmitWithCommandsEnabled)
2589 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2590 break;
2591 }
2592 case OP_vkCreateFence: {
2593 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCreateFence");
2594 VkDevice device;
2595 const VkFenceCreateInfo* pCreateInfo;
2596 const VkAllocationCallbacks* pAllocator;
2597 VkFence* pFence;
2598 // Begin global wrapped dispatchable handle unboxing for device;
2599 uint64_t cgen_var_0;
2600 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2601 *readStreamPtrPtr += 1 * 8;
2602 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2603 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkFenceCreateInfo));
2604 reservedunmarshal_VkFenceCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2605 (VkFenceCreateInfo*)(pCreateInfo),
2606 readStreamPtrPtr);
2607 // WARNING PTR CHECK
2608 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
2609 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
2610 *readStreamPtrPtr += 8;
2611 if (pAllocator) {
2612 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
2613 reservedunmarshal_VkAllocationCallbacks(
2614 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2615 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
2616 }
2617 // Begin manual dispatchable handle unboxing for pFence;
2618 vkReadStream->unsetHandleMapping();
2619 vkReadStream->alloc((void**)&pFence, sizeof(VkFence));
2620 uint64_t cgen_var_2;
2621 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
2622 *readStreamPtrPtr += 8;
2623 *(VkFence*)pFence = (VkFence)(VkFence)((VkFence)(*&cgen_var_2));
2624 if (pCreateInfo) {
2625 transform_tohost_VkFenceCreateInfo(m_state, (VkFenceCreateInfo*)(pCreateInfo));
2626 }
2627 if (pAllocator) {
2628 transform_tohost_VkAllocationCallbacks(m_state,
2629 (VkAllocationCallbacks*)(pAllocator));
2630 }
2631 if (m_logCalls) {
2632 fprintf(stderr, "stream %p: call vkCreateFence 0x%llx 0x%llx 0x%llx 0x%llx \n",
2633 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
2634 (unsigned long long)pAllocator, (unsigned long long)pFence);
2635 }
2636 VkResult vkCreateFence_VkResult_return = (VkResult)0;
2637 vkCreateFence_VkResult_return =
2638 m_state->on_vkCreateFence(&m_pool, device, pCreateInfo, pAllocator, pFence);
2639 if ((vkCreateFence_VkResult_return) == VK_ERROR_DEVICE_LOST)
2640 m_state->on_DeviceLost();
2641 m_state->on_CheckOutOfMemory(vkCreateFence_VkResult_return, opcode, context);
2642 vkStream->unsetHandleMapping();
2643 // Begin manual non dispatchable handle create for pFence;
2644 vkStream->unsetHandleMapping();
2645 uint64_t cgen_var_3;
2646 static_assert(8 == sizeof(VkFence),
2647 "handle map overwrite requires VkFence to be 8 bytes long");
2648 vkStream->handleMapping()->mapHandles_VkFence((VkFence*)pFence, 1);
2649 vkStream->write((VkFence*)pFence, 8 * 1);
2650 // Begin manual non dispatchable handle create for pFence;
2651 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
2652 vkStream->write(&vkCreateFence_VkResult_return, sizeof(VkResult));
2653 vkStream->commitWrite();
2654 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2655 (uintptr_t)snapshotTraceBegin);
2656 size_t snapshotTraceBytes = vkReadStream->endTrace();
2657 if (m_state->snapshotsEnabled()) {
2658 m_state->snapshot()->vkCreateFence(snapshotTraceBegin, snapshotTraceBytes,
2659 &m_pool, vkCreateFence_VkResult_return,
2660 device, pCreateInfo, pAllocator, pFence);
2661 }
2662 vkReadStream->clearPool();
2663 if (m_queueSubmitWithCommandsEnabled)
2664 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2665 break;
2666 }
2667 case OP_vkDestroyFence: {
2668 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkDestroyFence");
2669 VkDevice device;
2670 VkFence fence;
2671 const VkAllocationCallbacks* pAllocator;
2672 // Begin global wrapped dispatchable handle unboxing for device;
2673 uint64_t cgen_var_0;
2674 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2675 *readStreamPtrPtr += 1 * 8;
2676 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2677 // Begin manual non dispatchable handle destroy unboxing for fence;
2678 VkFence boxed_fence_preserve;
2679 uint64_t cgen_var_1;
2680 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2681 *readStreamPtrPtr += 1 * 8;
2682 *(VkFence*)&fence = (VkFence)(VkFence)((VkFence)(*&cgen_var_1));
2683 boxed_fence_preserve = fence;
2684 fence = try_unbox_VkFence(fence);
2685 // WARNING PTR CHECK
2686 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
2687 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
2688 *readStreamPtrPtr += 8;
2689 if (pAllocator) {
2690 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
2691 reservedunmarshal_VkAllocationCallbacks(
2692 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2693 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
2694 }
2695 if (pAllocator) {
2696 transform_tohost_VkAllocationCallbacks(m_state,
2697 (VkAllocationCallbacks*)(pAllocator));
2698 }
2699 if (m_logCalls) {
2700 fprintf(stderr, "stream %p: call vkDestroyFence 0x%llx 0x%llx 0x%llx \n",
2701 ioStream, (unsigned long long)device, (unsigned long long)fence,
2702 (unsigned long long)pAllocator);
2703 }
2704 m_state->on_vkDestroyFence(&m_pool, device, fence, pAllocator);
2705 vkStream->unsetHandleMapping();
2706 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2707 (uintptr_t)snapshotTraceBegin);
2708 size_t snapshotTraceBytes = vkReadStream->endTrace();
2709 if (m_state->snapshotsEnabled()) {
2710 m_state->snapshot()->vkDestroyFence(snapshotTraceBegin, snapshotTraceBytes,
2711 &m_pool, device, boxed_fence_preserve,
2712 pAllocator);
2713 }
2714 delete_VkFence(boxed_fence_preserve);
2715 vkReadStream->clearPool();
2716 if (m_queueSubmitWithCommandsEnabled)
2717 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2718 break;
2719 }
2720 case OP_vkResetFences: {
2721 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkResetFences");
2722 VkDevice device;
2723 uint32_t fenceCount;
2724 const VkFence* pFences;
2725 // Begin global wrapped dispatchable handle unboxing for device;
2726 uint64_t cgen_var_0;
2727 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2728 *readStreamPtrPtr += 1 * 8;
2729 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2730 memcpy((uint32_t*)&fenceCount, *readStreamPtrPtr, sizeof(uint32_t));
2731 *readStreamPtrPtr += sizeof(uint32_t);
2732 vkReadStream->alloc((void**)&pFences, ((fenceCount)) * sizeof(const VkFence));
2733 if (((fenceCount))) {
2734 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
2735 *readStreamPtrPtr += 8 * ((fenceCount));
2736 for (uint32_t k = 0; k < ((fenceCount)); ++k) {
2737 uint64_t tmpval;
2738 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
2739 *(((VkFence*)pFences) + k) =
2740 tmpval ? (VkFence)unbox_VkFence((VkFence)tmpval) : VK_NULL_HANDLE;
2741 }
2742 }
2743 if (m_logCalls) {
2744 fprintf(stderr, "stream %p: call vkResetFences 0x%llx 0x%llx 0x%llx \n",
2745 ioStream, (unsigned long long)device, (unsigned long long)fenceCount,
2746 (unsigned long long)pFences);
2747 }
2748 VkResult vkResetFences_VkResult_return = (VkResult)0;
2749 vkResetFences_VkResult_return =
2750 m_state->on_vkResetFences(&m_pool, device, fenceCount, pFences);
2751 if ((vkResetFences_VkResult_return) == VK_ERROR_DEVICE_LOST)
2752 m_state->on_DeviceLost();
2753 m_state->on_CheckOutOfMemory(vkResetFences_VkResult_return, opcode, context);
2754 vkStream->unsetHandleMapping();
2755 vkStream->write(&vkResetFences_VkResult_return, sizeof(VkResult));
2756 vkStream->commitWrite();
2757 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2758 (uintptr_t)snapshotTraceBegin);
2759 size_t snapshotTraceBytes = vkReadStream->endTrace();
2760 if (m_state->snapshotsEnabled()) {
2761 m_state->snapshot()->vkResetFences(snapshotTraceBegin, snapshotTraceBytes,
2762 &m_pool, vkResetFences_VkResult_return,
2763 device, fenceCount, pFences);
2764 }
2765 vkReadStream->clearPool();
2766 if (m_queueSubmitWithCommandsEnabled)
2767 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2768 break;
2769 }
2770 case OP_vkGetFenceStatus: {
2771 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2772 "VkDecoder vkGetFenceStatus");
2773 VkDevice device;
2774 VkFence fence;
2775 // Begin non wrapped dispatchable handle unboxing for device;
2776 uint64_t cgen_var_0;
2777 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2778 *readStreamPtrPtr += 1 * 8;
2779 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2780 auto unboxed_device = unbox_VkDevice(device);
2781 auto vk = dispatch_VkDevice(device);
2782 // End manual dispatchable handle unboxing for device;
2783 uint64_t cgen_var_1;
2784 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2785 *readStreamPtrPtr += 1 * 8;
2786 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
2787 if (m_logCalls) {
2788 fprintf(stderr, "stream %p: call vkGetFenceStatus 0x%llx 0x%llx \n", ioStream,
2789 (unsigned long long)device, (unsigned long long)fence);
2790 }
2791 VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
2792 vkGetFenceStatus_VkResult_return = vk->vkGetFenceStatus(unboxed_device, fence);
2793 if ((vkGetFenceStatus_VkResult_return) == VK_ERROR_DEVICE_LOST)
2794 m_state->on_DeviceLost();
2795 m_state->on_CheckOutOfMemory(vkGetFenceStatus_VkResult_return, opcode, context);
2796 vkStream->unsetHandleMapping();
2797 vkStream->write(&vkGetFenceStatus_VkResult_return, sizeof(VkResult));
2798 vkStream->commitWrite();
2799 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2800 (uintptr_t)snapshotTraceBegin);
2801 size_t snapshotTraceBytes = vkReadStream->endTrace();
2802 if (m_state->snapshotsEnabled()) {
2803 m_state->snapshot()->vkGetFenceStatus(snapshotTraceBegin, snapshotTraceBytes,
2804 &m_pool, vkGetFenceStatus_VkResult_return,
2805 device, fence);
2806 }
2807 vkReadStream->clearPool();
2808 if (m_queueSubmitWithCommandsEnabled)
2809 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2810 break;
2811 }
2812 case OP_vkWaitForFences: {
2813 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2814 "VkDecoder vkWaitForFences");
2815 VkDevice device;
2816 uint32_t fenceCount;
2817 const VkFence* pFences;
2818 VkBool32 waitAll;
2819 uint64_t timeout;
2820 // Begin non wrapped dispatchable handle unboxing for device;
2821 uint64_t cgen_var_0;
2822 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2823 *readStreamPtrPtr += 1 * 8;
2824 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2825 auto unboxed_device = unbox_VkDevice(device);
2826 auto vk = dispatch_VkDevice(device);
2827 // End manual dispatchable handle unboxing for device;
2828 memcpy((uint32_t*)&fenceCount, *readStreamPtrPtr, sizeof(uint32_t));
2829 *readStreamPtrPtr += sizeof(uint32_t);
2830 vkReadStream->alloc((void**)&pFences, ((fenceCount)) * sizeof(const VkFence));
2831 if (((fenceCount))) {
2832 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
2833 *readStreamPtrPtr += 8 * ((fenceCount));
2834 for (uint32_t k = 0; k < ((fenceCount)); ++k) {
2835 uint64_t tmpval;
2836 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
2837 *(((VkFence*)pFences) + k) =
2838 tmpval ? (VkFence)unbox_VkFence((VkFence)tmpval) : VK_NULL_HANDLE;
2839 }
2840 }
2841 memcpy((VkBool32*)&waitAll, *readStreamPtrPtr, sizeof(VkBool32));
2842 *readStreamPtrPtr += sizeof(VkBool32);
2843 memcpy((uint64_t*)&timeout, *readStreamPtrPtr, sizeof(uint64_t));
2844 *readStreamPtrPtr += sizeof(uint64_t);
2845 if (m_logCalls) {
2846 fprintf(stderr,
2847 "stream %p: call vkWaitForFences 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
2848 ioStream, (unsigned long long)device, (unsigned long long)fenceCount,
2849 (unsigned long long)pFences, (unsigned long long)waitAll,
2850 (unsigned long long)timeout);
2851 }
2852 if (m_queueSubmitWithCommandsEnabled)
2853 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2854 VkResult vkWaitForFences_VkResult_return = (VkResult)0;
2855 vkWaitForFences_VkResult_return =
2856 vk->vkWaitForFences(unboxed_device, fenceCount, pFences, waitAll, timeout);
2857 if ((vkWaitForFences_VkResult_return) == VK_ERROR_DEVICE_LOST)
2858 m_state->on_DeviceLost();
2859 m_state->on_CheckOutOfMemory(vkWaitForFences_VkResult_return, opcode, context);
2860 vkStream->unsetHandleMapping();
2861 vkStream->write(&vkWaitForFences_VkResult_return, sizeof(VkResult));
2862 vkStream->commitWrite();
2863 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2864 (uintptr_t)snapshotTraceBegin);
2865 size_t snapshotTraceBytes = vkReadStream->endTrace();
2866 if (m_state->snapshotsEnabled()) {
2867 m_state->snapshot()->vkWaitForFences(snapshotTraceBegin, snapshotTraceBytes,
2868 &m_pool, vkWaitForFences_VkResult_return,
2869 device, fenceCount, pFences, waitAll,
2870 timeout);
2871 }
2872 vkReadStream->clearPool();
2873 break;
2874 }
2875 case OP_vkCreateSemaphore: {
2876 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2877 "VkDecoder vkCreateSemaphore");
2878 VkDevice device;
2879 const VkSemaphoreCreateInfo* pCreateInfo;
2880 const VkAllocationCallbacks* pAllocator;
2881 VkSemaphore* pSemaphore;
2882 // Begin global wrapped dispatchable handle unboxing for device;
2883 uint64_t cgen_var_0;
2884 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2885 *readStreamPtrPtr += 1 * 8;
2886 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2887 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkSemaphoreCreateInfo));
2888 reservedunmarshal_VkSemaphoreCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2889 (VkSemaphoreCreateInfo*)(pCreateInfo),
2890 readStreamPtrPtr);
2891 // WARNING PTR CHECK
2892 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
2893 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
2894 *readStreamPtrPtr += 8;
2895 if (pAllocator) {
2896 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
2897 reservedunmarshal_VkAllocationCallbacks(
2898 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2899 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
2900 }
2901 // Begin manual dispatchable handle unboxing for pSemaphore;
2902 vkReadStream->unsetHandleMapping();
2903 vkReadStream->alloc((void**)&pSemaphore, sizeof(VkSemaphore));
2904 uint64_t cgen_var_2;
2905 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
2906 *readStreamPtrPtr += 8;
2907 *(VkSemaphore*)pSemaphore = (VkSemaphore)(VkSemaphore)((VkSemaphore)(*&cgen_var_2));
2908 if (pCreateInfo) {
2909 transform_tohost_VkSemaphoreCreateInfo(m_state,
2910 (VkSemaphoreCreateInfo*)(pCreateInfo));
2911 }
2912 if (pAllocator) {
2913 transform_tohost_VkAllocationCallbacks(m_state,
2914 (VkAllocationCallbacks*)(pAllocator));
2915 }
2916 if (m_logCalls) {
2917 fprintf(stderr,
2918 "stream %p: call vkCreateSemaphore 0x%llx 0x%llx 0x%llx 0x%llx \n",
2919 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
2920 (unsigned long long)pAllocator, (unsigned long long)pSemaphore);
2921 }
2922 VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
2923 vkCreateSemaphore_VkResult_return = m_state->on_vkCreateSemaphore(
2924 &m_pool, device, pCreateInfo, pAllocator, pSemaphore);
2925 if ((vkCreateSemaphore_VkResult_return) == VK_ERROR_DEVICE_LOST)
2926 m_state->on_DeviceLost();
2927 m_state->on_CheckOutOfMemory(vkCreateSemaphore_VkResult_return, opcode, context);
2928 vkStream->unsetHandleMapping();
2929 // Begin manual non dispatchable handle create for pSemaphore;
2930 vkStream->unsetHandleMapping();
2931 uint64_t cgen_var_3;
2932 static_assert(8 == sizeof(VkSemaphore),
2933 "handle map overwrite requires VkSemaphore to be 8 bytes long");
2934 vkStream->handleMapping()->mapHandles_VkSemaphore((VkSemaphore*)pSemaphore, 1);
2935 vkStream->write((VkSemaphore*)pSemaphore, 8 * 1);
2936 // Begin manual non dispatchable handle create for pSemaphore;
2937 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
2938 vkStream->write(&vkCreateSemaphore_VkResult_return, sizeof(VkResult));
2939 vkStream->commitWrite();
2940 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2941 (uintptr_t)snapshotTraceBegin);
2942 size_t snapshotTraceBytes = vkReadStream->endTrace();
2943 if (m_state->snapshotsEnabled()) {
2944 m_state->snapshot()->vkCreateSemaphore(
2945 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
2946 vkCreateSemaphore_VkResult_return, device, pCreateInfo, pAllocator,
2947 pSemaphore);
2948 }
2949 vkReadStream->clearPool();
2950 if (m_queueSubmitWithCommandsEnabled)
2951 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
2952 break;
2953 }
2954 case OP_vkDestroySemaphore: {
2955 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2956 "VkDecoder vkDestroySemaphore");
2957 VkDevice device;
2958 VkSemaphore semaphore;
2959 const VkAllocationCallbacks* pAllocator;
2960 // Begin global wrapped dispatchable handle unboxing for device;
2961 uint64_t cgen_var_0;
2962 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2963 *readStreamPtrPtr += 1 * 8;
2964 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
2965 // Begin manual non dispatchable handle destroy unboxing for semaphore;
2966 VkSemaphore boxed_semaphore_preserve;
2967 uint64_t cgen_var_1;
2968 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2969 *readStreamPtrPtr += 1 * 8;
2970 *(VkSemaphore*)&semaphore = (VkSemaphore)(VkSemaphore)((VkSemaphore)(*&cgen_var_1));
2971 boxed_semaphore_preserve = semaphore;
2972 semaphore = try_unbox_VkSemaphore(semaphore);
2973 // WARNING PTR CHECK
2974 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
2975 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
2976 *readStreamPtrPtr += 8;
2977 if (pAllocator) {
2978 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
2979 reservedunmarshal_VkAllocationCallbacks(
2980 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2981 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
2982 }
2983 if (pAllocator) {
2984 transform_tohost_VkAllocationCallbacks(m_state,
2985 (VkAllocationCallbacks*)(pAllocator));
2986 }
2987 if (m_logCalls) {
2988 fprintf(stderr, "stream %p: call vkDestroySemaphore 0x%llx 0x%llx 0x%llx \n",
2989 ioStream, (unsigned long long)device, (unsigned long long)semaphore,
2990 (unsigned long long)pAllocator);
2991 }
2992 m_state->on_vkDestroySemaphore(&m_pool, device, semaphore, pAllocator);
2993 vkStream->unsetHandleMapping();
2994 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
2995 (uintptr_t)snapshotTraceBegin);
2996 size_t snapshotTraceBytes = vkReadStream->endTrace();
2997 if (m_state->snapshotsEnabled()) {
2998 m_state->snapshot()->vkDestroySemaphore(snapshotTraceBegin, snapshotTraceBytes,
2999 &m_pool, device,
3000 boxed_semaphore_preserve, pAllocator);
3001 }
3002 delete_VkSemaphore(boxed_semaphore_preserve);
3003 vkReadStream->clearPool();
3004 if (m_queueSubmitWithCommandsEnabled)
3005 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3006 break;
3007 }
3008 case OP_vkCreateEvent: {
3009 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCreateEvent");
3010 VkDevice device;
3011 const VkEventCreateInfo* pCreateInfo;
3012 const VkAllocationCallbacks* pAllocator;
3013 VkEvent* pEvent;
3014 // Begin non wrapped dispatchable handle unboxing for device;
3015 uint64_t cgen_var_0;
3016 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3017 *readStreamPtrPtr += 1 * 8;
3018 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3019 auto unboxed_device = unbox_VkDevice(device);
3020 auto vk = dispatch_VkDevice(device);
3021 // End manual dispatchable handle unboxing for device;
3022 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkEventCreateInfo));
3023 reservedunmarshal_VkEventCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3024 (VkEventCreateInfo*)(pCreateInfo),
3025 readStreamPtrPtr);
3026 // WARNING PTR CHECK
3027 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3028 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3029 *readStreamPtrPtr += 8;
3030 if (pAllocator) {
3031 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3032 reservedunmarshal_VkAllocationCallbacks(
3033 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3034 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3035 }
3036 // Begin manual dispatchable handle unboxing for pEvent;
3037 vkReadStream->unsetHandleMapping();
3038 vkReadStream->alloc((void**)&pEvent, sizeof(VkEvent));
3039 uint64_t cgen_var_2;
3040 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
3041 *readStreamPtrPtr += 8;
3042 *(VkEvent*)pEvent = (VkEvent)(VkEvent)((VkEvent)(*&cgen_var_2));
3043 if (pCreateInfo) {
3044 transform_tohost_VkEventCreateInfo(m_state, (VkEventCreateInfo*)(pCreateInfo));
3045 }
3046 if (pAllocator) {
3047 transform_tohost_VkAllocationCallbacks(m_state,
3048 (VkAllocationCallbacks*)(pAllocator));
3049 }
3050 if (m_logCalls) {
3051 fprintf(stderr, "stream %p: call vkCreateEvent 0x%llx 0x%llx 0x%llx 0x%llx \n",
3052 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
3053 (unsigned long long)pAllocator, (unsigned long long)pEvent);
3054 }
3055 VkResult vkCreateEvent_VkResult_return = (VkResult)0;
3056 vkCreateEvent_VkResult_return =
3057 vk->vkCreateEvent(unboxed_device, pCreateInfo, pAllocator, pEvent);
3058 if ((vkCreateEvent_VkResult_return) == VK_ERROR_DEVICE_LOST)
3059 m_state->on_DeviceLost();
3060 m_state->on_CheckOutOfMemory(vkCreateEvent_VkResult_return, opcode, context);
3061 vkStream->unsetHandleMapping();
3062 // Begin auto non dispatchable handle create for pEvent;
3063 if (vkCreateEvent_VkResult_return == VK_SUCCESS)
3064 vkStream->setHandleMapping(&m_boxedHandleCreateMapping);
3065 uint64_t cgen_var_3;
3066 static_assert(8 == sizeof(VkEvent),
3067 "handle map overwrite requires VkEvent to be 8 bytes long");
3068 vkStream->handleMapping()->mapHandles_VkEvent((VkEvent*)pEvent, 1);
3069 vkStream->write((VkEvent*)pEvent, 8 * 1);
3070 // Begin auto non dispatchable handle create for pEvent;
3071 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
3072 vkStream->write(&vkCreateEvent_VkResult_return, sizeof(VkResult));
3073 vkStream->commitWrite();
3074 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3075 (uintptr_t)snapshotTraceBegin);
3076 size_t snapshotTraceBytes = vkReadStream->endTrace();
3077 if (m_state->snapshotsEnabled()) {
3078 m_state->snapshot()->vkCreateEvent(snapshotTraceBegin, snapshotTraceBytes,
3079 &m_pool, vkCreateEvent_VkResult_return,
3080 device, pCreateInfo, pAllocator, pEvent);
3081 }
3082 vkReadStream->clearPool();
3083 if (m_queueSubmitWithCommandsEnabled)
3084 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3085 break;
3086 }
3087 case OP_vkDestroyEvent: {
3088 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkDestroyEvent");
3089 VkDevice device;
3090 VkEvent event;
3091 const VkAllocationCallbacks* pAllocator;
3092 // Begin non wrapped dispatchable handle unboxing for device;
3093 uint64_t cgen_var_0;
3094 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3095 *readStreamPtrPtr += 1 * 8;
3096 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3097 auto unboxed_device = unbox_VkDevice(device);
3098 auto vk = dispatch_VkDevice(device);
3099 // End manual dispatchable handle unboxing for device;
3100 // Begin manual non dispatchable handle destroy unboxing for event;
3101 VkEvent boxed_event_preserve;
3102 uint64_t cgen_var_1;
3103 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3104 *readStreamPtrPtr += 1 * 8;
3105 *(VkEvent*)&event = (VkEvent)(VkEvent)((VkEvent)(*&cgen_var_1));
3106 boxed_event_preserve = event;
3107 event = try_unbox_VkEvent(event);
3108 // WARNING PTR CHECK
3109 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3110 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3111 *readStreamPtrPtr += 8;
3112 if (pAllocator) {
3113 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3114 reservedunmarshal_VkAllocationCallbacks(
3115 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3116 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3117 }
3118 if (pAllocator) {
3119 transform_tohost_VkAllocationCallbacks(m_state,
3120 (VkAllocationCallbacks*)(pAllocator));
3121 }
3122 if (m_logCalls) {
3123 fprintf(stderr, "stream %p: call vkDestroyEvent 0x%llx 0x%llx 0x%llx \n",
3124 ioStream, (unsigned long long)device, (unsigned long long)event,
3125 (unsigned long long)pAllocator);
3126 }
3127 vk->vkDestroyEvent(unboxed_device, event, pAllocator);
3128 vkStream->unsetHandleMapping();
3129 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3130 (uintptr_t)snapshotTraceBegin);
3131 size_t snapshotTraceBytes = vkReadStream->endTrace();
3132 if (m_state->snapshotsEnabled()) {
3133 m_state->snapshot()->vkDestroyEvent(snapshotTraceBegin, snapshotTraceBytes,
3134 &m_pool, device, boxed_event_preserve,
3135 pAllocator);
3136 }
3137 delete_VkEvent(boxed_event_preserve);
3138 vkReadStream->clearPool();
3139 if (m_queueSubmitWithCommandsEnabled)
3140 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3141 break;
3142 }
3143 case OP_vkGetEventStatus: {
3144 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3145 "VkDecoder vkGetEventStatus");
3146 VkDevice device;
3147 VkEvent event;
3148 // Begin non wrapped dispatchable handle unboxing for device;
3149 uint64_t cgen_var_0;
3150 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3151 *readStreamPtrPtr += 1 * 8;
3152 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3153 auto unboxed_device = unbox_VkDevice(device);
3154 auto vk = dispatch_VkDevice(device);
3155 // End manual dispatchable handle unboxing for device;
3156 uint64_t cgen_var_1;
3157 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3158 *readStreamPtrPtr += 1 * 8;
3159 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
3160 if (m_logCalls) {
3161 fprintf(stderr, "stream %p: call vkGetEventStatus 0x%llx 0x%llx \n", ioStream,
3162 (unsigned long long)device, (unsigned long long)event);
3163 }
3164 VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
3165 vkGetEventStatus_VkResult_return = vk->vkGetEventStatus(unboxed_device, event);
3166 if ((vkGetEventStatus_VkResult_return) == VK_ERROR_DEVICE_LOST)
3167 m_state->on_DeviceLost();
3168 m_state->on_CheckOutOfMemory(vkGetEventStatus_VkResult_return, opcode, context);
3169 vkStream->unsetHandleMapping();
3170 vkStream->write(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
3171 vkStream->commitWrite();
3172 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3173 (uintptr_t)snapshotTraceBegin);
3174 size_t snapshotTraceBytes = vkReadStream->endTrace();
3175 if (m_state->snapshotsEnabled()) {
3176 m_state->snapshot()->vkGetEventStatus(snapshotTraceBegin, snapshotTraceBytes,
3177 &m_pool, vkGetEventStatus_VkResult_return,
3178 device, event);
3179 }
3180 vkReadStream->clearPool();
3181 if (m_queueSubmitWithCommandsEnabled)
3182 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3183 break;
3184 }
3185 case OP_vkSetEvent: {
3186 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkSetEvent");
3187 VkDevice device;
3188 VkEvent event;
3189 // Begin non wrapped dispatchable handle unboxing for device;
3190 uint64_t cgen_var_0;
3191 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3192 *readStreamPtrPtr += 1 * 8;
3193 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3194 auto unboxed_device = unbox_VkDevice(device);
3195 auto vk = dispatch_VkDevice(device);
3196 // End manual dispatchable handle unboxing for device;
3197 uint64_t cgen_var_1;
3198 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3199 *readStreamPtrPtr += 1 * 8;
3200 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
3201 if (m_logCalls) {
3202 fprintf(stderr, "stream %p: call vkSetEvent 0x%llx 0x%llx \n", ioStream,
3203 (unsigned long long)device, (unsigned long long)event);
3204 }
3205 VkResult vkSetEvent_VkResult_return = (VkResult)0;
3206 vkSetEvent_VkResult_return = vk->vkSetEvent(unboxed_device, event);
3207 if ((vkSetEvent_VkResult_return) == VK_ERROR_DEVICE_LOST) m_state->on_DeviceLost();
3208 m_state->on_CheckOutOfMemory(vkSetEvent_VkResult_return, opcode, context);
3209 vkStream->unsetHandleMapping();
3210 vkStream->write(&vkSetEvent_VkResult_return, sizeof(VkResult));
3211 vkStream->commitWrite();
3212 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3213 (uintptr_t)snapshotTraceBegin);
3214 size_t snapshotTraceBytes = vkReadStream->endTrace();
3215 if (m_state->snapshotsEnabled()) {
3216 m_state->snapshot()->vkSetEvent(snapshotTraceBegin, snapshotTraceBytes, &m_pool,
3217 vkSetEvent_VkResult_return, device, event);
3218 }
3219 vkReadStream->clearPool();
3220 if (m_queueSubmitWithCommandsEnabled)
3221 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3222 break;
3223 }
3224 case OP_vkResetEvent: {
3225 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkResetEvent");
3226 VkDevice device;
3227 VkEvent event;
3228 // Begin non wrapped dispatchable handle unboxing for device;
3229 uint64_t cgen_var_0;
3230 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3231 *readStreamPtrPtr += 1 * 8;
3232 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3233 auto unboxed_device = unbox_VkDevice(device);
3234 auto vk = dispatch_VkDevice(device);
3235 // End manual dispatchable handle unboxing for device;
3236 uint64_t cgen_var_1;
3237 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3238 *readStreamPtrPtr += 1 * 8;
3239 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
3240 if (m_logCalls) {
3241 fprintf(stderr, "stream %p: call vkResetEvent 0x%llx 0x%llx \n", ioStream,
3242 (unsigned long long)device, (unsigned long long)event);
3243 }
3244 VkResult vkResetEvent_VkResult_return = (VkResult)0;
3245 vkResetEvent_VkResult_return = vk->vkResetEvent(unboxed_device, event);
3246 if ((vkResetEvent_VkResult_return) == VK_ERROR_DEVICE_LOST)
3247 m_state->on_DeviceLost();
3248 m_state->on_CheckOutOfMemory(vkResetEvent_VkResult_return, opcode, context);
3249 vkStream->unsetHandleMapping();
3250 vkStream->write(&vkResetEvent_VkResult_return, sizeof(VkResult));
3251 vkStream->commitWrite();
3252 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3253 (uintptr_t)snapshotTraceBegin);
3254 size_t snapshotTraceBytes = vkReadStream->endTrace();
3255 if (m_state->snapshotsEnabled()) {
3256 m_state->snapshot()->vkResetEvent(snapshotTraceBegin, snapshotTraceBytes,
3257 &m_pool, vkResetEvent_VkResult_return, device,
3258 event);
3259 }
3260 vkReadStream->clearPool();
3261 if (m_queueSubmitWithCommandsEnabled)
3262 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3263 break;
3264 }
3265 case OP_vkCreateQueryPool: {
3266 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3267 "VkDecoder vkCreateQueryPool");
3268 VkDevice device;
3269 const VkQueryPoolCreateInfo* pCreateInfo;
3270 const VkAllocationCallbacks* pAllocator;
3271 VkQueryPool* pQueryPool;
3272 // Begin non wrapped dispatchable handle unboxing for device;
3273 uint64_t cgen_var_0;
3274 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3275 *readStreamPtrPtr += 1 * 8;
3276 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3277 auto unboxed_device = unbox_VkDevice(device);
3278 auto vk = dispatch_VkDevice(device);
3279 // End manual dispatchable handle unboxing for device;
3280 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkQueryPoolCreateInfo));
3281 reservedunmarshal_VkQueryPoolCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3282 (VkQueryPoolCreateInfo*)(pCreateInfo),
3283 readStreamPtrPtr);
3284 // WARNING PTR CHECK
3285 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3286 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3287 *readStreamPtrPtr += 8;
3288 if (pAllocator) {
3289 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3290 reservedunmarshal_VkAllocationCallbacks(
3291 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3292 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3293 }
3294 // Begin manual dispatchable handle unboxing for pQueryPool;
3295 vkReadStream->unsetHandleMapping();
3296 vkReadStream->alloc((void**)&pQueryPool, sizeof(VkQueryPool));
3297 uint64_t cgen_var_2;
3298 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
3299 *readStreamPtrPtr += 8;
3300 *(VkQueryPool*)pQueryPool = (VkQueryPool)(VkQueryPool)((VkQueryPool)(*&cgen_var_2));
3301 if (pCreateInfo) {
3302 transform_tohost_VkQueryPoolCreateInfo(m_state,
3303 (VkQueryPoolCreateInfo*)(pCreateInfo));
3304 }
3305 if (pAllocator) {
3306 transform_tohost_VkAllocationCallbacks(m_state,
3307 (VkAllocationCallbacks*)(pAllocator));
3308 }
3309 if (m_logCalls) {
3310 fprintf(stderr,
3311 "stream %p: call vkCreateQueryPool 0x%llx 0x%llx 0x%llx 0x%llx \n",
3312 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
3313 (unsigned long long)pAllocator, (unsigned long long)pQueryPool);
3314 }
3315 VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
3316 vkCreateQueryPool_VkResult_return =
3317 vk->vkCreateQueryPool(unboxed_device, pCreateInfo, pAllocator, pQueryPool);
3318 if ((vkCreateQueryPool_VkResult_return) == VK_ERROR_DEVICE_LOST)
3319 m_state->on_DeviceLost();
3320 m_state->on_CheckOutOfMemory(vkCreateQueryPool_VkResult_return, opcode, context);
3321 vkStream->unsetHandleMapping();
3322 // Begin auto non dispatchable handle create for pQueryPool;
3323 if (vkCreateQueryPool_VkResult_return == VK_SUCCESS)
3324 vkStream->setHandleMapping(&m_boxedHandleCreateMapping);
3325 uint64_t cgen_var_3;
3326 static_assert(8 == sizeof(VkQueryPool),
3327 "handle map overwrite requires VkQueryPool to be 8 bytes long");
3328 vkStream->handleMapping()->mapHandles_VkQueryPool((VkQueryPool*)pQueryPool, 1);
3329 vkStream->write((VkQueryPool*)pQueryPool, 8 * 1);
3330 // Begin auto non dispatchable handle create for pQueryPool;
3331 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
3332 vkStream->write(&vkCreateQueryPool_VkResult_return, sizeof(VkResult));
3333 vkStream->commitWrite();
3334 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3335 (uintptr_t)snapshotTraceBegin);
3336 size_t snapshotTraceBytes = vkReadStream->endTrace();
3337 if (m_state->snapshotsEnabled()) {
3338 m_state->snapshot()->vkCreateQueryPool(
3339 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
3340 vkCreateQueryPool_VkResult_return, device, pCreateInfo, pAllocator,
3341 pQueryPool);
3342 }
3343 vkReadStream->clearPool();
3344 if (m_queueSubmitWithCommandsEnabled)
3345 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3346 break;
3347 }
3348 case OP_vkDestroyQueryPool: {
3349 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3350 "VkDecoder vkDestroyQueryPool");
3351 VkDevice device;
3352 VkQueryPool queryPool;
3353 const VkAllocationCallbacks* pAllocator;
3354 // Begin non wrapped dispatchable handle unboxing for device;
3355 uint64_t cgen_var_0;
3356 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3357 *readStreamPtrPtr += 1 * 8;
3358 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3359 auto unboxed_device = unbox_VkDevice(device);
3360 auto vk = dispatch_VkDevice(device);
3361 // End manual dispatchable handle unboxing for device;
3362 // Begin manual non dispatchable handle destroy unboxing for queryPool;
3363 VkQueryPool boxed_queryPool_preserve;
3364 uint64_t cgen_var_1;
3365 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3366 *readStreamPtrPtr += 1 * 8;
3367 *(VkQueryPool*)&queryPool = (VkQueryPool)(VkQueryPool)((VkQueryPool)(*&cgen_var_1));
3368 boxed_queryPool_preserve = queryPool;
3369 queryPool = try_unbox_VkQueryPool(queryPool);
3370 // WARNING PTR CHECK
3371 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3372 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3373 *readStreamPtrPtr += 8;
3374 if (pAllocator) {
3375 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3376 reservedunmarshal_VkAllocationCallbacks(
3377 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3378 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3379 }
3380 if (pAllocator) {
3381 transform_tohost_VkAllocationCallbacks(m_state,
3382 (VkAllocationCallbacks*)(pAllocator));
3383 }
3384 if (m_logCalls) {
3385 fprintf(stderr, "stream %p: call vkDestroyQueryPool 0x%llx 0x%llx 0x%llx \n",
3386 ioStream, (unsigned long long)device, (unsigned long long)queryPool,
3387 (unsigned long long)pAllocator);
3388 }
3389 vk->vkDestroyQueryPool(unboxed_device, queryPool, pAllocator);
3390 vkStream->unsetHandleMapping();
3391 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3392 (uintptr_t)snapshotTraceBegin);
3393 size_t snapshotTraceBytes = vkReadStream->endTrace();
3394 if (m_state->snapshotsEnabled()) {
3395 m_state->snapshot()->vkDestroyQueryPool(snapshotTraceBegin, snapshotTraceBytes,
3396 &m_pool, device,
3397 boxed_queryPool_preserve, pAllocator);
3398 }
3399 delete_VkQueryPool(boxed_queryPool_preserve);
3400 vkReadStream->clearPool();
3401 if (m_queueSubmitWithCommandsEnabled)
3402 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3403 break;
3404 }
3405 case OP_vkGetQueryPoolResults: {
3406 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3407 "VkDecoder vkGetQueryPoolResults");
3408 VkDevice device;
3409 VkQueryPool queryPool;
3410 uint32_t firstQuery;
3411 uint32_t queryCount;
3412 size_t dataSize;
3413 void* pData;
3414 VkDeviceSize stride;
3415 VkQueryResultFlags flags;
3416 // Begin non wrapped dispatchable handle unboxing for device;
3417 uint64_t cgen_var_0;
3418 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3419 *readStreamPtrPtr += 1 * 8;
3420 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3421 auto unboxed_device = unbox_VkDevice(device);
3422 auto vk = dispatch_VkDevice(device);
3423 // End manual dispatchable handle unboxing for device;
3424 uint64_t cgen_var_1;
3425 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3426 *readStreamPtrPtr += 1 * 8;
3427 *(VkQueryPool*)&queryPool =
3428 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
3429 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
3430 *readStreamPtrPtr += sizeof(uint32_t);
3431 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
3432 *readStreamPtrPtr += sizeof(uint32_t);
3433 memcpy((size_t*)&dataSize, (*readStreamPtrPtr), 8);
3434 android::base::Stream::fromBe64((uint8_t*)&dataSize);
3435 *readStreamPtrPtr += 8;
3436 // Begin manual dispatchable handle unboxing for pData;
3437 vkReadStream->unsetHandleMapping();
3438 vkReadStream->alloc((void**)&pData, ((dataSize)) * sizeof(uint8_t));
3439 memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(uint8_t));
3440 *readStreamPtrPtr += ((dataSize)) * sizeof(uint8_t);
3441 memcpy((VkDeviceSize*)&stride, *readStreamPtrPtr, sizeof(VkDeviceSize));
3442 *readStreamPtrPtr += sizeof(VkDeviceSize);
3443 memcpy((VkQueryResultFlags*)&flags, *readStreamPtrPtr, sizeof(VkQueryResultFlags));
3444 *readStreamPtrPtr += sizeof(VkQueryResultFlags);
3445 if (m_logCalls) {
3446 fprintf(stderr,
3447 "stream %p: call vkGetQueryPoolResults 0x%llx 0x%llx 0x%llx 0x%llx "
3448 "0x%llx 0x%llx 0x%llx 0x%llx \n",
3449 ioStream, (unsigned long long)device, (unsigned long long)queryPool,
3450 (unsigned long long)firstQuery, (unsigned long long)queryCount,
3451 (unsigned long long)dataSize, (unsigned long long)pData,
3452 (unsigned long long)stride, (unsigned long long)flags);
3453 }
3454 VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
3455 vkGetQueryPoolResults_VkResult_return =
3456 vk->vkGetQueryPoolResults(unboxed_device, queryPool, firstQuery, queryCount,
3457 dataSize, pData, stride, flags);
3458 if ((vkGetQueryPoolResults_VkResult_return) == VK_ERROR_DEVICE_LOST)
3459 m_state->on_DeviceLost();
3460 m_state->on_CheckOutOfMemory(vkGetQueryPoolResults_VkResult_return, opcode,
3461 context);
3462 vkStream->unsetHandleMapping();
3463 vkStream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
3464 vkStream->write(&vkGetQueryPoolResults_VkResult_return, sizeof(VkResult));
3465 vkStream->commitWrite();
3466 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3467 (uintptr_t)snapshotTraceBegin);
3468 size_t snapshotTraceBytes = vkReadStream->endTrace();
3469 if (m_state->snapshotsEnabled()) {
3470 m_state->snapshot()->vkGetQueryPoolResults(
3471 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
3472 vkGetQueryPoolResults_VkResult_return, device, queryPool, firstQuery,
3473 queryCount, dataSize, pData, stride, flags);
3474 }
3475 vkReadStream->clearPool();
3476 if (m_queueSubmitWithCommandsEnabled)
3477 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3478 break;
3479 }
3480 case OP_vkCreateBuffer: {
3481 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCreateBuffer");
3482 VkDevice device;
3483 const VkBufferCreateInfo* pCreateInfo;
3484 const VkAllocationCallbacks* pAllocator;
3485 VkBuffer* pBuffer;
3486 // Begin global wrapped dispatchable handle unboxing for device;
3487 uint64_t cgen_var_0;
3488 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3489 *readStreamPtrPtr += 1 * 8;
3490 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3491 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkBufferCreateInfo));
3492 reservedunmarshal_VkBufferCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3493 (VkBufferCreateInfo*)(pCreateInfo),
3494 readStreamPtrPtr);
3495 // WARNING PTR CHECK
3496 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3497 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3498 *readStreamPtrPtr += 8;
3499 if (pAllocator) {
3500 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3501 reservedunmarshal_VkAllocationCallbacks(
3502 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3503 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3504 }
3505 // Begin manual dispatchable handle unboxing for pBuffer;
3506 vkReadStream->unsetHandleMapping();
3507 vkReadStream->alloc((void**)&pBuffer, sizeof(VkBuffer));
3508 uint64_t cgen_var_2;
3509 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
3510 *readStreamPtrPtr += 8;
3511 *(VkBuffer*)pBuffer = (VkBuffer)(VkBuffer)((VkBuffer)(*&cgen_var_2));
3512 if (pCreateInfo) {
3513 transform_tohost_VkBufferCreateInfo(m_state,
3514 (VkBufferCreateInfo*)(pCreateInfo));
3515 }
3516 if (pAllocator) {
3517 transform_tohost_VkAllocationCallbacks(m_state,
3518 (VkAllocationCallbacks*)(pAllocator));
3519 }
3520 if (m_logCalls) {
3521 fprintf(stderr, "stream %p: call vkCreateBuffer 0x%llx 0x%llx 0x%llx 0x%llx \n",
3522 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
3523 (unsigned long long)pAllocator, (unsigned long long)pBuffer);
3524 }
3525 VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
3526 vkCreateBuffer_VkResult_return =
3527 m_state->on_vkCreateBuffer(&m_pool, device, pCreateInfo, pAllocator, pBuffer);
3528 if ((vkCreateBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
3529 m_state->on_DeviceLost();
3530 m_state->on_CheckOutOfMemory(vkCreateBuffer_VkResult_return, opcode, context);
3531 vkStream->unsetHandleMapping();
3532 // Begin manual non dispatchable handle create for pBuffer;
3533 vkStream->unsetHandleMapping();
3534 uint64_t cgen_var_3;
3535 static_assert(8 == sizeof(VkBuffer),
3536 "handle map overwrite requires VkBuffer to be 8 bytes long");
3537 vkStream->handleMapping()->mapHandles_VkBuffer((VkBuffer*)pBuffer, 1);
3538 vkStream->write((VkBuffer*)pBuffer, 8 * 1);
3539 // Begin manual non dispatchable handle create for pBuffer;
3540 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
3541 vkStream->write(&vkCreateBuffer_VkResult_return, sizeof(VkResult));
3542 vkStream->commitWrite();
3543 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3544 (uintptr_t)snapshotTraceBegin);
3545 size_t snapshotTraceBytes = vkReadStream->endTrace();
3546 if (m_state->snapshotsEnabled()) {
3547 m_state->snapshot()->vkCreateBuffer(snapshotTraceBegin, snapshotTraceBytes,
3548 &m_pool, vkCreateBuffer_VkResult_return,
3549 device, pCreateInfo, pAllocator, pBuffer);
3550 }
3551 vkReadStream->clearPool();
3552 if (m_queueSubmitWithCommandsEnabled)
3553 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3554 break;
3555 }
3556 case OP_vkDestroyBuffer: {
3557 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3558 "VkDecoder vkDestroyBuffer");
3559 VkDevice device;
3560 VkBuffer buffer;
3561 const VkAllocationCallbacks* pAllocator;
3562 // Begin global wrapped dispatchable handle unboxing for device;
3563 uint64_t cgen_var_0;
3564 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3565 *readStreamPtrPtr += 1 * 8;
3566 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3567 // Begin manual non dispatchable handle destroy unboxing for buffer;
3568 VkBuffer boxed_buffer_preserve;
3569 uint64_t cgen_var_1;
3570 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3571 *readStreamPtrPtr += 1 * 8;
3572 *(VkBuffer*)&buffer = (VkBuffer)(VkBuffer)((VkBuffer)(*&cgen_var_1));
3573 boxed_buffer_preserve = buffer;
3574 buffer = try_unbox_VkBuffer(buffer);
3575 // WARNING PTR CHECK
3576 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3577 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3578 *readStreamPtrPtr += 8;
3579 if (pAllocator) {
3580 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3581 reservedunmarshal_VkAllocationCallbacks(
3582 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3583 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3584 }
3585 if (pAllocator) {
3586 transform_tohost_VkAllocationCallbacks(m_state,
3587 (VkAllocationCallbacks*)(pAllocator));
3588 }
3589 if (m_logCalls) {
3590 fprintf(stderr, "stream %p: call vkDestroyBuffer 0x%llx 0x%llx 0x%llx \n",
3591 ioStream, (unsigned long long)device, (unsigned long long)buffer,
3592 (unsigned long long)pAllocator);
3593 }
3594 m_state->on_vkDestroyBuffer(&m_pool, device, buffer, pAllocator);
3595 vkStream->unsetHandleMapping();
3596 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3597 (uintptr_t)snapshotTraceBegin);
3598 size_t snapshotTraceBytes = vkReadStream->endTrace();
3599 if (m_state->snapshotsEnabled()) {
3600 m_state->snapshot()->vkDestroyBuffer(snapshotTraceBegin, snapshotTraceBytes,
3601 &m_pool, device, boxed_buffer_preserve,
3602 pAllocator);
3603 }
3604 delete_VkBuffer(boxed_buffer_preserve);
3605 vkReadStream->clearPool();
3606 if (m_queueSubmitWithCommandsEnabled)
3607 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3608 break;
3609 }
3610 case OP_vkCreateBufferView: {
3611 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3612 "VkDecoder vkCreateBufferView");
3613 VkDevice device;
3614 const VkBufferViewCreateInfo* pCreateInfo;
3615 const VkAllocationCallbacks* pAllocator;
3616 VkBufferView* pView;
3617 // Begin non wrapped dispatchable handle unboxing for device;
3618 uint64_t cgen_var_0;
3619 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3620 *readStreamPtrPtr += 1 * 8;
3621 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3622 auto unboxed_device = unbox_VkDevice(device);
3623 auto vk = dispatch_VkDevice(device);
3624 // End manual dispatchable handle unboxing for device;
3625 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkBufferViewCreateInfo));
3626 reservedunmarshal_VkBufferViewCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3627 (VkBufferViewCreateInfo*)(pCreateInfo),
3628 readStreamPtrPtr);
3629 // WARNING PTR CHECK
3630 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3631 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3632 *readStreamPtrPtr += 8;
3633 if (pAllocator) {
3634 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3635 reservedunmarshal_VkAllocationCallbacks(
3636 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3637 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3638 }
3639 // Begin manual dispatchable handle unboxing for pView;
3640 vkReadStream->unsetHandleMapping();
3641 vkReadStream->alloc((void**)&pView, sizeof(VkBufferView));
3642 uint64_t cgen_var_2;
3643 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
3644 *readStreamPtrPtr += 8;
3645 *(VkBufferView*)pView = (VkBufferView)(VkBufferView)((VkBufferView)(*&cgen_var_2));
3646 if (pCreateInfo) {
3647 transform_tohost_VkBufferViewCreateInfo(m_state,
3648 (VkBufferViewCreateInfo*)(pCreateInfo));
3649 }
3650 if (pAllocator) {
3651 transform_tohost_VkAllocationCallbacks(m_state,
3652 (VkAllocationCallbacks*)(pAllocator));
3653 }
3654 if (m_logCalls) {
3655 fprintf(stderr,
3656 "stream %p: call vkCreateBufferView 0x%llx 0x%llx 0x%llx 0x%llx \n",
3657 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
3658 (unsigned long long)pAllocator, (unsigned long long)pView);
3659 }
3660 VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
3661 vkCreateBufferView_VkResult_return =
3662 vk->vkCreateBufferView(unboxed_device, pCreateInfo, pAllocator, pView);
3663 if ((vkCreateBufferView_VkResult_return) == VK_ERROR_DEVICE_LOST)
3664 m_state->on_DeviceLost();
3665 m_state->on_CheckOutOfMemory(vkCreateBufferView_VkResult_return, opcode, context);
3666 vkStream->unsetHandleMapping();
3667 // Begin auto non dispatchable handle create for pView;
3668 if (vkCreateBufferView_VkResult_return == VK_SUCCESS)
3669 vkStream->setHandleMapping(&m_boxedHandleCreateMapping);
3670 uint64_t cgen_var_3;
3671 static_assert(8 == sizeof(VkBufferView),
3672 "handle map overwrite requires VkBufferView to be 8 bytes long");
3673 vkStream->handleMapping()->mapHandles_VkBufferView((VkBufferView*)pView, 1);
3674 vkStream->write((VkBufferView*)pView, 8 * 1);
3675 // Begin auto non dispatchable handle create for pView;
3676 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
3677 vkStream->write(&vkCreateBufferView_VkResult_return, sizeof(VkResult));
3678 vkStream->commitWrite();
3679 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3680 (uintptr_t)snapshotTraceBegin);
3681 size_t snapshotTraceBytes = vkReadStream->endTrace();
3682 if (m_state->snapshotsEnabled()) {
3683 m_state->snapshot()->vkCreateBufferView(
3684 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
3685 vkCreateBufferView_VkResult_return, device, pCreateInfo, pAllocator, pView);
3686 }
3687 vkReadStream->clearPool();
3688 if (m_queueSubmitWithCommandsEnabled)
3689 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3690 break;
3691 }
3692 case OP_vkDestroyBufferView: {
3693 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3694 "VkDecoder vkDestroyBufferView");
3695 VkDevice device;
3696 VkBufferView bufferView;
3697 const VkAllocationCallbacks* pAllocator;
3698 // Begin non wrapped dispatchable handle unboxing for device;
3699 uint64_t cgen_var_0;
3700 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3701 *readStreamPtrPtr += 1 * 8;
3702 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3703 auto unboxed_device = unbox_VkDevice(device);
3704 auto vk = dispatch_VkDevice(device);
3705 // End manual dispatchable handle unboxing for device;
3706 // Begin manual non dispatchable handle destroy unboxing for bufferView;
3707 VkBufferView boxed_bufferView_preserve;
3708 uint64_t cgen_var_1;
3709 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3710 *readStreamPtrPtr += 1 * 8;
3711 *(VkBufferView*)&bufferView =
3712 (VkBufferView)(VkBufferView)((VkBufferView)(*&cgen_var_1));
3713 boxed_bufferView_preserve = bufferView;
3714 bufferView = try_unbox_VkBufferView(bufferView);
3715 // WARNING PTR CHECK
3716 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3717 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3718 *readStreamPtrPtr += 8;
3719 if (pAllocator) {
3720 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3721 reservedunmarshal_VkAllocationCallbacks(
3722 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3723 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3724 }
3725 if (pAllocator) {
3726 transform_tohost_VkAllocationCallbacks(m_state,
3727 (VkAllocationCallbacks*)(pAllocator));
3728 }
3729 if (m_logCalls) {
3730 fprintf(stderr, "stream %p: call vkDestroyBufferView 0x%llx 0x%llx 0x%llx \n",
3731 ioStream, (unsigned long long)device, (unsigned long long)bufferView,
3732 (unsigned long long)pAllocator);
3733 }
3734 vk->vkDestroyBufferView(unboxed_device, bufferView, pAllocator);
3735 vkStream->unsetHandleMapping();
3736 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3737 (uintptr_t)snapshotTraceBegin);
3738 size_t snapshotTraceBytes = vkReadStream->endTrace();
3739 if (m_state->snapshotsEnabled()) {
3740 m_state->snapshot()->vkDestroyBufferView(snapshotTraceBegin, snapshotTraceBytes,
3741 &m_pool, device,
3742 boxed_bufferView_preserve, pAllocator);
3743 }
3744 delete_VkBufferView(boxed_bufferView_preserve);
3745 vkReadStream->clearPool();
3746 if (m_queueSubmitWithCommandsEnabled)
3747 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3748 break;
3749 }
3750 case OP_vkCreateImage: {
3751 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCreateImage");
3752 VkDevice device;
3753 const VkImageCreateInfo* pCreateInfo;
3754 const VkAllocationCallbacks* pAllocator;
3755 VkImage* pImage;
3756 // Begin global wrapped dispatchable handle unboxing for device;
3757 uint64_t cgen_var_0;
3758 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3759 *readStreamPtrPtr += 1 * 8;
3760 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3761 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkImageCreateInfo));
3762 reservedunmarshal_VkImageCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3763 (VkImageCreateInfo*)(pCreateInfo),
3764 readStreamPtrPtr);
3765 // WARNING PTR CHECK
3766 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3767 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3768 *readStreamPtrPtr += 8;
3769 if (pAllocator) {
3770 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3771 reservedunmarshal_VkAllocationCallbacks(
3772 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3773 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3774 }
3775 // Begin manual dispatchable handle unboxing for pImage;
3776 vkReadStream->unsetHandleMapping();
3777 vkReadStream->alloc((void**)&pImage, sizeof(VkImage));
3778 uint64_t cgen_var_2;
3779 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
3780 *readStreamPtrPtr += 8;
3781 *(VkImage*)pImage = (VkImage)(VkImage)((VkImage)(*&cgen_var_2));
3782 if (pCreateInfo) {
3783 m_state->transformImpl_VkImageCreateInfo_tohost(pCreateInfo, 1);
3784 transform_tohost_VkImageCreateInfo(m_state, (VkImageCreateInfo*)(pCreateInfo));
3785 }
3786 if (pAllocator) {
3787 transform_tohost_VkAllocationCallbacks(m_state,
3788 (VkAllocationCallbacks*)(pAllocator));
3789 }
3790 if (m_logCalls) {
3791 fprintf(stderr, "stream %p: call vkCreateImage 0x%llx 0x%llx 0x%llx 0x%llx \n",
3792 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
3793 (unsigned long long)pAllocator, (unsigned long long)pImage);
3794 }
3795 VkResult vkCreateImage_VkResult_return = (VkResult)0;
3796 vkCreateImage_VkResult_return =
3797 m_state->on_vkCreateImage(&m_pool, device, pCreateInfo, pAllocator, pImage);
3798 if ((vkCreateImage_VkResult_return) == VK_ERROR_DEVICE_LOST)
3799 m_state->on_DeviceLost();
3800 m_state->on_CheckOutOfMemory(vkCreateImage_VkResult_return, opcode, context);
3801 vkStream->unsetHandleMapping();
3802 // Begin manual non dispatchable handle create for pImage;
3803 vkStream->unsetHandleMapping();
3804 uint64_t cgen_var_3;
3805 static_assert(8 == sizeof(VkImage),
3806 "handle map overwrite requires VkImage to be 8 bytes long");
3807 vkStream->handleMapping()->mapHandles_VkImage((VkImage*)pImage, 1);
3808 vkStream->write((VkImage*)pImage, 8 * 1);
3809 // Begin manual non dispatchable handle create for pImage;
3810 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
3811 vkStream->write(&vkCreateImage_VkResult_return, sizeof(VkResult));
3812 vkStream->commitWrite();
3813 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3814 (uintptr_t)snapshotTraceBegin);
3815 size_t snapshotTraceBytes = vkReadStream->endTrace();
3816 if (m_state->snapshotsEnabled()) {
3817 m_state->snapshot()->vkCreateImage(snapshotTraceBegin, snapshotTraceBytes,
3818 &m_pool, vkCreateImage_VkResult_return,
3819 device, pCreateInfo, pAllocator, pImage);
3820 }
3821 vkReadStream->clearPool();
3822 if (m_queueSubmitWithCommandsEnabled)
3823 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3824 break;
3825 }
3826 case OP_vkDestroyImage: {
3827 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkDestroyImage");
3828 VkDevice device;
3829 VkImage image;
3830 const VkAllocationCallbacks* pAllocator;
3831 // Begin global wrapped dispatchable handle unboxing for device;
3832 uint64_t cgen_var_0;
3833 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3834 *readStreamPtrPtr += 1 * 8;
3835 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3836 // Begin manual non dispatchable handle destroy unboxing for image;
3837 VkImage boxed_image_preserve;
3838 uint64_t cgen_var_1;
3839 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3840 *readStreamPtrPtr += 1 * 8;
3841 *(VkImage*)&image = (VkImage)(VkImage)((VkImage)(*&cgen_var_1));
3842 boxed_image_preserve = image;
3843 image = try_unbox_VkImage(image);
3844 // WARNING PTR CHECK
3845 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3846 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3847 *readStreamPtrPtr += 8;
3848 if (pAllocator) {
3849 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3850 reservedunmarshal_VkAllocationCallbacks(
3851 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3852 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3853 }
3854 if (pAllocator) {
3855 transform_tohost_VkAllocationCallbacks(m_state,
3856 (VkAllocationCallbacks*)(pAllocator));
3857 }
3858 if (m_logCalls) {
3859 fprintf(stderr, "stream %p: call vkDestroyImage 0x%llx 0x%llx 0x%llx \n",
3860 ioStream, (unsigned long long)device, (unsigned long long)image,
3861 (unsigned long long)pAllocator);
3862 }
3863 m_state->on_vkDestroyImage(&m_pool, device, image, pAllocator);
3864 vkStream->unsetHandleMapping();
3865 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3866 (uintptr_t)snapshotTraceBegin);
3867 size_t snapshotTraceBytes = vkReadStream->endTrace();
3868 if (m_state->snapshotsEnabled()) {
3869 m_state->snapshot()->vkDestroyImage(snapshotTraceBegin, snapshotTraceBytes,
3870 &m_pool, device, boxed_image_preserve,
3871 pAllocator);
3872 }
3873 delete_VkImage(boxed_image_preserve);
3874 vkReadStream->clearPool();
3875 if (m_queueSubmitWithCommandsEnabled)
3876 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3877 break;
3878 }
3879 case OP_vkGetImageSubresourceLayout: {
3880 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3881 "VkDecoder vkGetImageSubresourceLayout");
3882 VkDevice device;
3883 VkImage image;
3884 const VkImageSubresource* pSubresource;
3885 VkSubresourceLayout* pLayout;
3886 // Begin non wrapped dispatchable handle unboxing for device;
3887 uint64_t cgen_var_0;
3888 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3889 *readStreamPtrPtr += 1 * 8;
3890 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3891 auto unboxed_device = unbox_VkDevice(device);
3892 auto vk = dispatch_VkDevice(device);
3893 // End manual dispatchable handle unboxing for device;
3894 uint64_t cgen_var_1;
3895 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3896 *readStreamPtrPtr += 1 * 8;
3897 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
3898 vkReadStream->alloc((void**)&pSubresource, sizeof(const VkImageSubresource));
3899 reservedunmarshal_VkImageSubresource(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3900 (VkImageSubresource*)(pSubresource),
3901 readStreamPtrPtr);
3902 // Begin manual dispatchable handle unboxing for pLayout;
3903 vkReadStream->unsetHandleMapping();
3904 vkReadStream->alloc((void**)&pLayout, sizeof(VkSubresourceLayout));
3905 reservedunmarshal_VkSubresourceLayout(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3906 (VkSubresourceLayout*)(pLayout),
3907 readStreamPtrPtr);
3908 if (pSubresource) {
3909 transform_tohost_VkImageSubresource(m_state,
3910 (VkImageSubresource*)(pSubresource));
3911 }
3912 if (pLayout) {
3913 transform_tohost_VkSubresourceLayout(m_state, (VkSubresourceLayout*)(pLayout));
3914 }
3915 if (m_logCalls) {
3916 fprintf(stderr,
3917 "stream %p: call vkGetImageSubresourceLayout 0x%llx 0x%llx 0x%llx "
3918 "0x%llx \n",
3919 ioStream, (unsigned long long)device, (unsigned long long)image,
3920 (unsigned long long)pSubresource, (unsigned long long)pLayout);
3921 }
3922 vk->vkGetImageSubresourceLayout(unboxed_device, image, pSubresource, pLayout);
3923 vkStream->unsetHandleMapping();
3924 if (pLayout) {
3925 transform_fromhost_VkSubresourceLayout(m_state,
3926 (VkSubresourceLayout*)(pLayout));
3927 }
3928 marshal_VkSubresourceLayout(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3929 (VkSubresourceLayout*)(pLayout));
3930 vkStream->commitWrite();
3931 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
3932 (uintptr_t)snapshotTraceBegin);
3933 size_t snapshotTraceBytes = vkReadStream->endTrace();
3934 if (m_state->snapshotsEnabled()) {
3935 m_state->snapshot()->vkGetImageSubresourceLayout(
3936 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, image,
3937 pSubresource, pLayout);
3938 }
3939 vkReadStream->clearPool();
3940 if (m_queueSubmitWithCommandsEnabled)
3941 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
3942 break;
3943 }
3944 case OP_vkCreateImageView: {
3945 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3946 "VkDecoder vkCreateImageView");
3947 VkDevice device;
3948 const VkImageViewCreateInfo* pCreateInfo;
3949 const VkAllocationCallbacks* pAllocator;
3950 VkImageView* pView;
3951 // Begin global wrapped dispatchable handle unboxing for device;
3952 uint64_t cgen_var_0;
3953 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3954 *readStreamPtrPtr += 1 * 8;
3955 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
3956 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkImageViewCreateInfo));
3957 reservedunmarshal_VkImageViewCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3958 (VkImageViewCreateInfo*)(pCreateInfo),
3959 readStreamPtrPtr);
3960 // WARNING PTR CHECK
3961 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
3962 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
3963 *readStreamPtrPtr += 8;
3964 if (pAllocator) {
3965 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
3966 reservedunmarshal_VkAllocationCallbacks(
3967 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3968 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
3969 }
3970 // Begin manual dispatchable handle unboxing for pView;
3971 vkReadStream->unsetHandleMapping();
3972 vkReadStream->alloc((void**)&pView, sizeof(VkImageView));
3973 uint64_t cgen_var_2;
3974 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
3975 *readStreamPtrPtr += 8;
3976 *(VkImageView*)pView = (VkImageView)(VkImageView)((VkImageView)(*&cgen_var_2));
3977 if (pCreateInfo) {
3978 transform_tohost_VkImageViewCreateInfo(m_state,
3979 (VkImageViewCreateInfo*)(pCreateInfo));
3980 }
3981 if (pAllocator) {
3982 transform_tohost_VkAllocationCallbacks(m_state,
3983 (VkAllocationCallbacks*)(pAllocator));
3984 }
3985 if (m_logCalls) {
3986 fprintf(stderr,
3987 "stream %p: call vkCreateImageView 0x%llx 0x%llx 0x%llx 0x%llx \n",
3988 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
3989 (unsigned long long)pAllocator, (unsigned long long)pView);
3990 }
3991 VkResult vkCreateImageView_VkResult_return = (VkResult)0;
3992 vkCreateImageView_VkResult_return =
3993 m_state->on_vkCreateImageView(&m_pool, device, pCreateInfo, pAllocator, pView);
3994 if ((vkCreateImageView_VkResult_return) == VK_ERROR_DEVICE_LOST)
3995 m_state->on_DeviceLost();
3996 m_state->on_CheckOutOfMemory(vkCreateImageView_VkResult_return, opcode, context);
3997 vkStream->unsetHandleMapping();
3998 // Begin manual non dispatchable handle create for pView;
3999 vkStream->unsetHandleMapping();
4000 uint64_t cgen_var_3;
4001 static_assert(8 == sizeof(VkImageView),
4002 "handle map overwrite requires VkImageView to be 8 bytes long");
4003 vkStream->handleMapping()->mapHandles_VkImageView((VkImageView*)pView, 1);
4004 vkStream->write((VkImageView*)pView, 8 * 1);
4005 // Begin manual non dispatchable handle create for pView;
4006 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
4007 vkStream->write(&vkCreateImageView_VkResult_return, sizeof(VkResult));
4008 vkStream->commitWrite();
4009 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4010 (uintptr_t)snapshotTraceBegin);
4011 size_t snapshotTraceBytes = vkReadStream->endTrace();
4012 if (m_state->snapshotsEnabled()) {
4013 m_state->snapshot()->vkCreateImageView(
4014 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
4015 vkCreateImageView_VkResult_return, device, pCreateInfo, pAllocator, pView);
4016 }
4017 vkReadStream->clearPool();
4018 if (m_queueSubmitWithCommandsEnabled)
4019 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4020 break;
4021 }
4022 case OP_vkDestroyImageView: {
4023 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4024 "VkDecoder vkDestroyImageView");
4025 VkDevice device;
4026 VkImageView imageView;
4027 const VkAllocationCallbacks* pAllocator;
4028 // Begin global wrapped dispatchable handle unboxing for device;
4029 uint64_t cgen_var_0;
4030 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4031 *readStreamPtrPtr += 1 * 8;
4032 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4033 // Begin manual non dispatchable handle destroy unboxing for imageView;
4034 VkImageView boxed_imageView_preserve;
4035 uint64_t cgen_var_1;
4036 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
4037 *readStreamPtrPtr += 1 * 8;
4038 *(VkImageView*)&imageView = (VkImageView)(VkImageView)((VkImageView)(*&cgen_var_1));
4039 boxed_imageView_preserve = imageView;
4040 imageView = try_unbox_VkImageView(imageView);
4041 // WARNING PTR CHECK
4042 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4043 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4044 *readStreamPtrPtr += 8;
4045 if (pAllocator) {
4046 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4047 reservedunmarshal_VkAllocationCallbacks(
4048 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4049 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4050 }
4051 if (pAllocator) {
4052 transform_tohost_VkAllocationCallbacks(m_state,
4053 (VkAllocationCallbacks*)(pAllocator));
4054 }
4055 if (m_logCalls) {
4056 fprintf(stderr, "stream %p: call vkDestroyImageView 0x%llx 0x%llx 0x%llx \n",
4057 ioStream, (unsigned long long)device, (unsigned long long)imageView,
4058 (unsigned long long)pAllocator);
4059 }
4060 m_state->on_vkDestroyImageView(&m_pool, device, imageView, pAllocator);
4061 vkStream->unsetHandleMapping();
4062 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4063 (uintptr_t)snapshotTraceBegin);
4064 size_t snapshotTraceBytes = vkReadStream->endTrace();
4065 if (m_state->snapshotsEnabled()) {
4066 m_state->snapshot()->vkDestroyImageView(snapshotTraceBegin, snapshotTraceBytes,
4067 &m_pool, device,
4068 boxed_imageView_preserve, pAllocator);
4069 }
4070 delete_VkImageView(boxed_imageView_preserve);
4071 vkReadStream->clearPool();
4072 if (m_queueSubmitWithCommandsEnabled)
4073 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4074 break;
4075 }
4076 case OP_vkCreateShaderModule: {
4077 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4078 "VkDecoder vkCreateShaderModule");
4079 VkDevice device;
4080 const VkShaderModuleCreateInfo* pCreateInfo;
4081 const VkAllocationCallbacks* pAllocator;
4082 VkShaderModule* pShaderModule;
4083 // Begin global wrapped dispatchable handle unboxing for device;
4084 uint64_t cgen_var_0;
4085 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4086 *readStreamPtrPtr += 1 * 8;
4087 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4088 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkShaderModuleCreateInfo));
4089 reservedunmarshal_VkShaderModuleCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4090 (VkShaderModuleCreateInfo*)(pCreateInfo),
4091 readStreamPtrPtr);
4092 // WARNING PTR CHECK
4093 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4094 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4095 *readStreamPtrPtr += 8;
4096 if (pAllocator) {
4097 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4098 reservedunmarshal_VkAllocationCallbacks(
4099 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4100 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4101 }
4102 // Begin manual dispatchable handle unboxing for pShaderModule;
4103 vkReadStream->unsetHandleMapping();
4104 vkReadStream->alloc((void**)&pShaderModule, sizeof(VkShaderModule));
4105 uint64_t cgen_var_2;
4106 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
4107 *readStreamPtrPtr += 8;
4108 *(VkShaderModule*)pShaderModule =
4109 (VkShaderModule)(VkShaderModule)((VkShaderModule)(*&cgen_var_2));
4110 if (pCreateInfo) {
4111 transform_tohost_VkShaderModuleCreateInfo(
4112 m_state, (VkShaderModuleCreateInfo*)(pCreateInfo));
4113 }
4114 if (pAllocator) {
4115 transform_tohost_VkAllocationCallbacks(m_state,
4116 (VkAllocationCallbacks*)(pAllocator));
4117 }
4118 if (m_logCalls) {
4119 fprintf(stderr,
4120 "stream %p: call vkCreateShaderModule 0x%llx 0x%llx 0x%llx 0x%llx \n",
4121 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
4122 (unsigned long long)pAllocator, (unsigned long long)pShaderModule);
4123 }
4124 VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
4125 vkCreateShaderModule_VkResult_return = m_state->on_vkCreateShaderModule(
4126 &m_pool, device, pCreateInfo, pAllocator, pShaderModule);
4127 if ((vkCreateShaderModule_VkResult_return) == VK_ERROR_DEVICE_LOST)
4128 m_state->on_DeviceLost();
4129 m_state->on_CheckOutOfMemory(vkCreateShaderModule_VkResult_return, opcode, context);
4130 vkStream->unsetHandleMapping();
4131 // Begin manual non dispatchable handle create for pShaderModule;
4132 vkStream->unsetHandleMapping();
4133 uint64_t cgen_var_3;
4134 static_assert(8 == sizeof(VkShaderModule),
4135 "handle map overwrite requires VkShaderModule to be 8 bytes long");
4136 vkStream->handleMapping()->mapHandles_VkShaderModule((VkShaderModule*)pShaderModule,
4137 1);
4138 vkStream->write((VkShaderModule*)pShaderModule, 8 * 1);
4139 // Begin manual non dispatchable handle create for pShaderModule;
4140 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
4141 vkStream->write(&vkCreateShaderModule_VkResult_return, sizeof(VkResult));
4142 vkStream->commitWrite();
4143 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4144 (uintptr_t)snapshotTraceBegin);
4145 size_t snapshotTraceBytes = vkReadStream->endTrace();
4146 if (m_state->snapshotsEnabled()) {
4147 m_state->snapshot()->vkCreateShaderModule(
4148 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
4149 vkCreateShaderModule_VkResult_return, device, pCreateInfo, pAllocator,
4150 pShaderModule);
4151 }
4152 vkReadStream->clearPool();
4153 if (m_queueSubmitWithCommandsEnabled)
4154 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4155 break;
4156 }
4157 case OP_vkDestroyShaderModule: {
4158 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4159 "VkDecoder vkDestroyShaderModule");
4160 VkDevice device;
4161 VkShaderModule shaderModule;
4162 const VkAllocationCallbacks* pAllocator;
4163 // Begin non wrapped dispatchable handle unboxing for device;
4164 uint64_t cgen_var_0;
4165 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4166 *readStreamPtrPtr += 1 * 8;
4167 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4168 auto unboxed_device = unbox_VkDevice(device);
4169 auto vk = dispatch_VkDevice(device);
4170 // End manual dispatchable handle unboxing for device;
4171 // Begin manual non dispatchable handle destroy unboxing for shaderModule;
4172 VkShaderModule boxed_shaderModule_preserve;
4173 uint64_t cgen_var_1;
4174 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
4175 *readStreamPtrPtr += 1 * 8;
4176 *(VkShaderModule*)&shaderModule =
4177 (VkShaderModule)(VkShaderModule)((VkShaderModule)(*&cgen_var_1));
4178 boxed_shaderModule_preserve = shaderModule;
4179 shaderModule = try_unbox_VkShaderModule(shaderModule);
4180 // WARNING PTR CHECK
4181 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4182 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4183 *readStreamPtrPtr += 8;
4184 if (pAllocator) {
4185 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4186 reservedunmarshal_VkAllocationCallbacks(
4187 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4188 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4189 }
4190 if (pAllocator) {
4191 transform_tohost_VkAllocationCallbacks(m_state,
4192 (VkAllocationCallbacks*)(pAllocator));
4193 }
4194 if (m_logCalls) {
4195 fprintf(stderr, "stream %p: call vkDestroyShaderModule 0x%llx 0x%llx 0x%llx \n",
4196 ioStream, (unsigned long long)device, (unsigned long long)shaderModule,
4197 (unsigned long long)pAllocator);
4198 }
4199 m_state->on_vkDestroyShaderModule(&m_pool, device, shaderModule, pAllocator);
4200 vkStream->unsetHandleMapping();
4201 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4202 (uintptr_t)snapshotTraceBegin);
4203 size_t snapshotTraceBytes = vkReadStream->endTrace();
4204 if (m_state->snapshotsEnabled()) {
4205 m_state->snapshot()->vkDestroyShaderModule(
4206 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
4207 boxed_shaderModule_preserve, pAllocator);
4208 }
4209 delayed_delete_VkShaderModule(boxed_shaderModule_preserve, unboxed_device, nullptr);
4210 vkReadStream->clearPool();
4211 if (m_queueSubmitWithCommandsEnabled)
4212 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4213 break;
4214 }
4215 case OP_vkCreatePipelineCache: {
4216 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4217 "VkDecoder vkCreatePipelineCache");
4218 VkDevice device;
4219 const VkPipelineCacheCreateInfo* pCreateInfo;
4220 const VkAllocationCallbacks* pAllocator;
4221 VkPipelineCache* pPipelineCache;
4222 // Begin global wrapped dispatchable handle unboxing for device;
4223 uint64_t cgen_var_0;
4224 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4225 *readStreamPtrPtr += 1 * 8;
4226 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4227 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkPipelineCacheCreateInfo));
4228 reservedunmarshal_VkPipelineCacheCreateInfo(
4229 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4230 (VkPipelineCacheCreateInfo*)(pCreateInfo), readStreamPtrPtr);
4231 // WARNING PTR CHECK
4232 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4233 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4234 *readStreamPtrPtr += 8;
4235 if (pAllocator) {
4236 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4237 reservedunmarshal_VkAllocationCallbacks(
4238 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4239 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4240 }
4241 // Begin manual dispatchable handle unboxing for pPipelineCache;
4242 vkReadStream->unsetHandleMapping();
4243 vkReadStream->alloc((void**)&pPipelineCache, sizeof(VkPipelineCache));
4244 uint64_t cgen_var_2;
4245 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
4246 *readStreamPtrPtr += 8;
4247 *(VkPipelineCache*)pPipelineCache =
4248 (VkPipelineCache)(VkPipelineCache)((VkPipelineCache)(*&cgen_var_2));
4249 if (pCreateInfo) {
4250 transform_tohost_VkPipelineCacheCreateInfo(
4251 m_state, (VkPipelineCacheCreateInfo*)(pCreateInfo));
4252 }
4253 if (pAllocator) {
4254 transform_tohost_VkAllocationCallbacks(m_state,
4255 (VkAllocationCallbacks*)(pAllocator));
4256 }
4257 if (m_logCalls) {
4258 fprintf(stderr,
4259 "stream %p: call vkCreatePipelineCache 0x%llx 0x%llx 0x%llx 0x%llx \n",
4260 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
4261 (unsigned long long)pAllocator, (unsigned long long)pPipelineCache);
4262 }
4263 VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
4264 vkCreatePipelineCache_VkResult_return = m_state->on_vkCreatePipelineCache(
4265 &m_pool, device, pCreateInfo, pAllocator, pPipelineCache);
4266 if ((vkCreatePipelineCache_VkResult_return) == VK_ERROR_DEVICE_LOST)
4267 m_state->on_DeviceLost();
4268 m_state->on_CheckOutOfMemory(vkCreatePipelineCache_VkResult_return, opcode,
4269 context);
4270 vkStream->unsetHandleMapping();
4271 // Begin manual non dispatchable handle create for pPipelineCache;
4272 vkStream->unsetHandleMapping();
4273 uint64_t cgen_var_3;
4274 static_assert(8 == sizeof(VkPipelineCache),
4275 "handle map overwrite requires VkPipelineCache to be 8 bytes long");
4276 vkStream->handleMapping()->mapHandles_VkPipelineCache(
4277 (VkPipelineCache*)pPipelineCache, 1);
4278 vkStream->write((VkPipelineCache*)pPipelineCache, 8 * 1);
4279 // Begin manual non dispatchable handle create for pPipelineCache;
4280 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
4281 vkStream->write(&vkCreatePipelineCache_VkResult_return, sizeof(VkResult));
4282 vkStream->commitWrite();
4283 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4284 (uintptr_t)snapshotTraceBegin);
4285 size_t snapshotTraceBytes = vkReadStream->endTrace();
4286 if (m_state->snapshotsEnabled()) {
4287 m_state->snapshot()->vkCreatePipelineCache(
4288 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
4289 vkCreatePipelineCache_VkResult_return, device, pCreateInfo, pAllocator,
4290 pPipelineCache);
4291 }
4292 vkReadStream->clearPool();
4293 if (m_queueSubmitWithCommandsEnabled)
4294 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4295 break;
4296 }
4297 case OP_vkDestroyPipelineCache: {
4298 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4299 "VkDecoder vkDestroyPipelineCache");
4300 VkDevice device;
4301 VkPipelineCache pipelineCache;
4302 const VkAllocationCallbacks* pAllocator;
4303 // Begin global wrapped dispatchable handle unboxing for device;
4304 uint64_t cgen_var_0;
4305 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4306 *readStreamPtrPtr += 1 * 8;
4307 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4308 // Begin manual non dispatchable handle destroy unboxing for pipelineCache;
4309 VkPipelineCache boxed_pipelineCache_preserve;
4310 uint64_t cgen_var_1;
4311 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
4312 *readStreamPtrPtr += 1 * 8;
4313 *(VkPipelineCache*)&pipelineCache =
4314 (VkPipelineCache)(VkPipelineCache)((VkPipelineCache)(*&cgen_var_1));
4315 boxed_pipelineCache_preserve = pipelineCache;
4316 pipelineCache = try_unbox_VkPipelineCache(pipelineCache);
4317 // WARNING PTR CHECK
4318 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4319 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4320 *readStreamPtrPtr += 8;
4321 if (pAllocator) {
4322 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4323 reservedunmarshal_VkAllocationCallbacks(
4324 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4325 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4326 }
4327 if (pAllocator) {
4328 transform_tohost_VkAllocationCallbacks(m_state,
4329 (VkAllocationCallbacks*)(pAllocator));
4330 }
4331 if (m_logCalls) {
4332 fprintf(stderr,
4333 "stream %p: call vkDestroyPipelineCache 0x%llx 0x%llx 0x%llx \n",
4334 ioStream, (unsigned long long)device, (unsigned long long)pipelineCache,
4335 (unsigned long long)pAllocator);
4336 }
4337 m_state->on_vkDestroyPipelineCache(&m_pool, device, pipelineCache, pAllocator);
4338 vkStream->unsetHandleMapping();
4339 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4340 (uintptr_t)snapshotTraceBegin);
4341 size_t snapshotTraceBytes = vkReadStream->endTrace();
4342 if (m_state->snapshotsEnabled()) {
4343 m_state->snapshot()->vkDestroyPipelineCache(
4344 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
4345 boxed_pipelineCache_preserve, pAllocator);
4346 }
4347 delete_VkPipelineCache(boxed_pipelineCache_preserve);
4348 vkReadStream->clearPool();
4349 if (m_queueSubmitWithCommandsEnabled)
4350 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4351 break;
4352 }
4353 case OP_vkGetPipelineCacheData: {
4354 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4355 "VkDecoder vkGetPipelineCacheData");
4356 VkDevice device;
4357 VkPipelineCache pipelineCache;
4358 size_t* pDataSize;
4359 void* pData;
4360 // Begin non wrapped dispatchable handle unboxing for device;
4361 uint64_t cgen_var_0;
4362 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4363 *readStreamPtrPtr += 1 * 8;
4364 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4365 auto unboxed_device = unbox_VkDevice(device);
4366 auto vk = dispatch_VkDevice(device);
4367 // End manual dispatchable handle unboxing for device;
4368 uint64_t cgen_var_1;
4369 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
4370 *readStreamPtrPtr += 1 * 8;
4371 *(VkPipelineCache*)&pipelineCache =
4372 (VkPipelineCache)unbox_VkPipelineCache((VkPipelineCache)(*&cgen_var_1));
4373 // Begin manual dispatchable handle unboxing for pDataSize;
4374 vkReadStream->unsetHandleMapping();
4375 // WARNING PTR CHECK
4376 memcpy((size_t**)&pDataSize, (*readStreamPtrPtr), 8);
4377 android::base::Stream::fromBe64((uint8_t*)&pDataSize);
4378 *readStreamPtrPtr += 8;
4379 if (pDataSize) {
4380 vkReadStream->alloc((void**)&pDataSize, sizeof(size_t));
4381 memcpy((size_t*)&(*pDataSize), (*readStreamPtrPtr), 8);
4382 android::base::Stream::fromBe64((uint8_t*)&(*pDataSize));
4383 *readStreamPtrPtr += 8;
4384 }
4385 // Begin manual dispatchable handle unboxing for pData;
4386 vkReadStream->unsetHandleMapping();
4387 // WARNING PTR CHECK
4388 memcpy((void**)&pData, (*readStreamPtrPtr), 8);
4389 android::base::Stream::fromBe64((uint8_t*)&pData);
4390 *readStreamPtrPtr += 8;
4391 if (pData) {
4392 vkReadStream->alloc((void**)&pData, (*(pDataSize)) * sizeof(uint8_t));
4393 memcpy((void*)pData, *readStreamPtrPtr, (*(pDataSize)) * sizeof(uint8_t));
4394 *readStreamPtrPtr += (*(pDataSize)) * sizeof(uint8_t);
4395 }
4396 if (m_logCalls) {
4397 fprintf(stderr,
4398 "stream %p: call vkGetPipelineCacheData 0x%llx 0x%llx 0x%llx 0x%llx \n",
4399 ioStream, (unsigned long long)device, (unsigned long long)pipelineCache,
4400 (unsigned long long)pDataSize, (unsigned long long)pData);
4401 }
4402 VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
4403 vkGetPipelineCacheData_VkResult_return =
4404 vk->vkGetPipelineCacheData(unboxed_device, pipelineCache, pDataSize, pData);
4405 if ((vkGetPipelineCacheData_VkResult_return) == VK_ERROR_DEVICE_LOST)
4406 m_state->on_DeviceLost();
4407 m_state->on_CheckOutOfMemory(vkGetPipelineCacheData_VkResult_return, opcode,
4408 context);
4409 vkStream->unsetHandleMapping();
4410 // WARNING PTR CHECK
4411 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pDataSize;
4412 vkStream->putBe64(cgen_var_4);
4413 if (pDataSize) {
4414 uint64_t cgen_var_4_0 = (uint64_t)(*pDataSize);
4415 vkStream->putBe64(cgen_var_4_0);
4416 }
4417 // WARNING PTR CHECK
4418 uint64_t cgen_var_5 = (uint64_t)(uintptr_t)pData;
4419 vkStream->putBe64(cgen_var_5);
4420 if (pData) {
4421 vkStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
4422 }
4423 vkStream->write(&vkGetPipelineCacheData_VkResult_return, sizeof(VkResult));
4424 vkStream->commitWrite();
4425 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4426 (uintptr_t)snapshotTraceBegin);
4427 size_t snapshotTraceBytes = vkReadStream->endTrace();
4428 if (m_state->snapshotsEnabled()) {
4429 m_state->snapshot()->vkGetPipelineCacheData(
4430 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
4431 vkGetPipelineCacheData_VkResult_return, device, pipelineCache, pDataSize,
4432 pData);
4433 }
4434 vkReadStream->clearPool();
4435 if (m_queueSubmitWithCommandsEnabled)
4436 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4437 break;
4438 }
4439 case OP_vkMergePipelineCaches: {
4440 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4441 "VkDecoder vkMergePipelineCaches");
4442 VkDevice device;
4443 VkPipelineCache dstCache;
4444 uint32_t srcCacheCount;
4445 const VkPipelineCache* pSrcCaches;
4446 // Begin non wrapped dispatchable handle unboxing for device;
4447 uint64_t cgen_var_0;
4448 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4449 *readStreamPtrPtr += 1 * 8;
4450 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4451 auto unboxed_device = unbox_VkDevice(device);
4452 auto vk = dispatch_VkDevice(device);
4453 // End manual dispatchable handle unboxing for device;
4454 uint64_t cgen_var_1;
4455 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
4456 *readStreamPtrPtr += 1 * 8;
4457 *(VkPipelineCache*)&dstCache =
4458 (VkPipelineCache)unbox_VkPipelineCache((VkPipelineCache)(*&cgen_var_1));
4459 memcpy((uint32_t*)&srcCacheCount, *readStreamPtrPtr, sizeof(uint32_t));
4460 *readStreamPtrPtr += sizeof(uint32_t);
4461 vkReadStream->alloc((void**)&pSrcCaches,
4462 ((srcCacheCount)) * sizeof(const VkPipelineCache));
4463 if (((srcCacheCount))) {
4464 uint8_t* cgen_var_2_ptr = (uint8_t*)(*readStreamPtrPtr);
4465 *readStreamPtrPtr += 8 * ((srcCacheCount));
4466 for (uint32_t k = 0; k < ((srcCacheCount)); ++k) {
4467 uint64_t tmpval;
4468 memcpy(&tmpval, cgen_var_2_ptr + k * 8, sizeof(uint64_t));
4469 *(((VkPipelineCache*)pSrcCaches) + k) =
4470 tmpval ? (VkPipelineCache)unbox_VkPipelineCache((VkPipelineCache)tmpval)
4471 : VK_NULL_HANDLE;
4472 }
4473 }
4474 if (m_logCalls) {
4475 fprintf(stderr,
4476 "stream %p: call vkMergePipelineCaches 0x%llx 0x%llx 0x%llx 0x%llx \n",
4477 ioStream, (unsigned long long)device, (unsigned long long)dstCache,
4478 (unsigned long long)srcCacheCount, (unsigned long long)pSrcCaches);
4479 }
4480 VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
4481 vkMergePipelineCaches_VkResult_return =
4482 vk->vkMergePipelineCaches(unboxed_device, dstCache, srcCacheCount, pSrcCaches);
4483 if ((vkMergePipelineCaches_VkResult_return) == VK_ERROR_DEVICE_LOST)
4484 m_state->on_DeviceLost();
4485 m_state->on_CheckOutOfMemory(vkMergePipelineCaches_VkResult_return, opcode,
4486 context);
4487 vkStream->unsetHandleMapping();
4488 vkStream->write(&vkMergePipelineCaches_VkResult_return, sizeof(VkResult));
4489 vkStream->commitWrite();
4490 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4491 (uintptr_t)snapshotTraceBegin);
4492 size_t snapshotTraceBytes = vkReadStream->endTrace();
4493 if (m_state->snapshotsEnabled()) {
4494 m_state->snapshot()->vkMergePipelineCaches(
4495 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
4496 vkMergePipelineCaches_VkResult_return, device, dstCache, srcCacheCount,
4497 pSrcCaches);
4498 }
4499 vkReadStream->clearPool();
4500 if (m_queueSubmitWithCommandsEnabled)
4501 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4502 break;
4503 }
4504 case OP_vkCreateGraphicsPipelines: {
4505 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4506 "VkDecoder vkCreateGraphicsPipelines");
4507 VkDevice device;
4508 VkPipelineCache pipelineCache;
4509 uint32_t createInfoCount;
4510 const VkGraphicsPipelineCreateInfo* pCreateInfos;
4511 const VkAllocationCallbacks* pAllocator;
4512 VkPipeline* pPipelines;
4513 // Begin global wrapped dispatchable handle unboxing for device;
4514 uint64_t cgen_var_0;
4515 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4516 *readStreamPtrPtr += 1 * 8;
4517 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4518 uint64_t cgen_var_1;
4519 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
4520 *readStreamPtrPtr += 1 * 8;
4521 *(VkPipelineCache*)&pipelineCache =
4522 (VkPipelineCache)unbox_VkPipelineCache((VkPipelineCache)(*&cgen_var_1));
4523 memcpy((uint32_t*)&createInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
4524 *readStreamPtrPtr += sizeof(uint32_t);
4525 vkReadStream->alloc(
4526 (void**)&pCreateInfos,
4527 ((createInfoCount)) * sizeof(const VkGraphicsPipelineCreateInfo));
4528 for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
4529 reservedunmarshal_VkGraphicsPipelineCreateInfo(
4530 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4531 (VkGraphicsPipelineCreateInfo*)(pCreateInfos + i), readStreamPtrPtr);
4532 }
4533 // WARNING PTR CHECK
4534 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4535 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4536 *readStreamPtrPtr += 8;
4537 if (pAllocator) {
4538 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4539 reservedunmarshal_VkAllocationCallbacks(
4540 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4541 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4542 }
4543 // Begin manual dispatchable handle unboxing for pPipelines;
4544 vkReadStream->unsetHandleMapping();
4545 vkReadStream->alloc((void**)&pPipelines, ((createInfoCount)) * sizeof(VkPipeline));
4546 if (((createInfoCount))) {
4547 uint8_t* cgen_var_3_ptr = (uint8_t*)(*readStreamPtrPtr);
4548 *readStreamPtrPtr += 8 * ((createInfoCount));
4549 for (uint32_t k = 0; k < ((createInfoCount)); ++k) {
4550 uint64_t tmpval;
4551 memcpy(&tmpval, cgen_var_3_ptr + k * 8, sizeof(uint64_t));
4552 *(((VkPipeline*)pPipelines) + k) =
4553 tmpval ? (VkPipeline)(VkPipeline)((VkPipeline)tmpval) : VK_NULL_HANDLE;
4554 }
4555 }
4556 if (pCreateInfos) {
4557 for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
4558 transform_tohost_VkGraphicsPipelineCreateInfo(
4559 m_state, (VkGraphicsPipelineCreateInfo*)(pCreateInfos + i));
4560 }
4561 }
4562 if (pAllocator) {
4563 transform_tohost_VkAllocationCallbacks(m_state,
4564 (VkAllocationCallbacks*)(pAllocator));
4565 }
4566 if (m_logCalls) {
4567 fprintf(stderr,
4568 "stream %p: call vkCreateGraphicsPipelines 0x%llx 0x%llx 0x%llx 0x%llx "
4569 "0x%llx 0x%llx \n",
4570 ioStream, (unsigned long long)device, (unsigned long long)pipelineCache,
4571 (unsigned long long)createInfoCount, (unsigned long long)pCreateInfos,
4572 (unsigned long long)pAllocator, (unsigned long long)pPipelines);
4573 }
4574 VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
4575 vkCreateGraphicsPipelines_VkResult_return = m_state->on_vkCreateGraphicsPipelines(
4576 &m_pool, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
4577 pPipelines);
4578 if ((vkCreateGraphicsPipelines_VkResult_return) == VK_ERROR_DEVICE_LOST)
4579 m_state->on_DeviceLost();
4580 m_state->on_CheckOutOfMemory(vkCreateGraphicsPipelines_VkResult_return, opcode,
4581 context);
4582 vkStream->unsetHandleMapping();
4583 // Begin manual non dispatchable handle create for pPipelines;
4584 vkStream->unsetHandleMapping();
4585 if (((createInfoCount))) {
4586 uint64_t* cgen_var_4;
4587 vkStream->alloc((void**)&cgen_var_4, ((createInfoCount)) * 8);
4588 static_assert(8 == sizeof(VkPipeline),
4589 "handle map overwrite requires VkPipeline to be 8 bytes long");
4590 vkStream->handleMapping()->mapHandles_VkPipeline((VkPipeline*)pPipelines,
4591 ((createInfoCount)));
4592 vkStream->write((VkPipeline*)pPipelines, 8 * ((createInfoCount)));
4593 }
4594 // Begin manual non dispatchable handle create for pPipelines;
4595 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
4596 vkStream->write(&vkCreateGraphicsPipelines_VkResult_return, sizeof(VkResult));
4597 vkStream->commitWrite();
4598 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4599 (uintptr_t)snapshotTraceBegin);
4600 size_t snapshotTraceBytes = vkReadStream->endTrace();
4601 if (m_state->snapshotsEnabled()) {
4602 m_state->snapshot()->vkCreateGraphicsPipelines(
4603 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
4604 vkCreateGraphicsPipelines_VkResult_return, device, pipelineCache,
4605 createInfoCount, pCreateInfos, pAllocator, pPipelines);
4606 }
4607 vkReadStream->clearPool();
4608 if (m_queueSubmitWithCommandsEnabled)
4609 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4610 break;
4611 }
4612 case OP_vkCreateComputePipelines: {
4613 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4614 "VkDecoder vkCreateComputePipelines");
4615 VkDevice device;
4616 VkPipelineCache pipelineCache;
4617 uint32_t createInfoCount;
4618 const VkComputePipelineCreateInfo* pCreateInfos;
4619 const VkAllocationCallbacks* pAllocator;
4620 VkPipeline* pPipelines;
4621 // Begin global wrapped dispatchable handle unboxing for device;
4622 uint64_t cgen_var_0;
4623 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4624 *readStreamPtrPtr += 1 * 8;
4625 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4626 uint64_t cgen_var_1;
4627 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
4628 *readStreamPtrPtr += 1 * 8;
4629 *(VkPipelineCache*)&pipelineCache =
4630 (VkPipelineCache)unbox_VkPipelineCache((VkPipelineCache)(*&cgen_var_1));
4631 memcpy((uint32_t*)&createInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
4632 *readStreamPtrPtr += sizeof(uint32_t);
4633 vkReadStream->alloc(
4634 (void**)&pCreateInfos,
4635 ((createInfoCount)) * sizeof(const VkComputePipelineCreateInfo));
4636 for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
4637 reservedunmarshal_VkComputePipelineCreateInfo(
4638 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4639 (VkComputePipelineCreateInfo*)(pCreateInfos + i), readStreamPtrPtr);
4640 }
4641 // WARNING PTR CHECK
4642 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4643 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4644 *readStreamPtrPtr += 8;
4645 if (pAllocator) {
4646 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4647 reservedunmarshal_VkAllocationCallbacks(
4648 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4649 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4650 }
4651 // Begin manual dispatchable handle unboxing for pPipelines;
4652 vkReadStream->unsetHandleMapping();
4653 vkReadStream->alloc((void**)&pPipelines, ((createInfoCount)) * sizeof(VkPipeline));
4654 if (((createInfoCount))) {
4655 uint8_t* cgen_var_3_ptr = (uint8_t*)(*readStreamPtrPtr);
4656 *readStreamPtrPtr += 8 * ((createInfoCount));
4657 for (uint32_t k = 0; k < ((createInfoCount)); ++k) {
4658 uint64_t tmpval;
4659 memcpy(&tmpval, cgen_var_3_ptr + k * 8, sizeof(uint64_t));
4660 *(((VkPipeline*)pPipelines) + k) =
4661 tmpval ? (VkPipeline)(VkPipeline)((VkPipeline)tmpval) : VK_NULL_HANDLE;
4662 }
4663 }
4664 if (pCreateInfos) {
4665 for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
4666 transform_tohost_VkComputePipelineCreateInfo(
4667 m_state, (VkComputePipelineCreateInfo*)(pCreateInfos + i));
4668 }
4669 }
4670 if (pAllocator) {
4671 transform_tohost_VkAllocationCallbacks(m_state,
4672 (VkAllocationCallbacks*)(pAllocator));
4673 }
4674 if (m_logCalls) {
4675 fprintf(stderr,
4676 "stream %p: call vkCreateComputePipelines 0x%llx 0x%llx 0x%llx 0x%llx "
4677 "0x%llx 0x%llx \n",
4678 ioStream, (unsigned long long)device, (unsigned long long)pipelineCache,
4679 (unsigned long long)createInfoCount, (unsigned long long)pCreateInfos,
4680 (unsigned long long)pAllocator, (unsigned long long)pPipelines);
4681 }
4682 VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
4683 vkCreateComputePipelines_VkResult_return = m_state->on_vkCreateComputePipelines(
4684 &m_pool, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
4685 pPipelines);
4686 if ((vkCreateComputePipelines_VkResult_return) == VK_ERROR_DEVICE_LOST)
4687 m_state->on_DeviceLost();
4688 m_state->on_CheckOutOfMemory(vkCreateComputePipelines_VkResult_return, opcode,
4689 context);
4690 vkStream->unsetHandleMapping();
4691 // Begin manual non dispatchable handle create for pPipelines;
4692 vkStream->unsetHandleMapping();
4693 if (((createInfoCount))) {
4694 uint64_t* cgen_var_4;
4695 vkStream->alloc((void**)&cgen_var_4, ((createInfoCount)) * 8);
4696 static_assert(8 == sizeof(VkPipeline),
4697 "handle map overwrite requires VkPipeline to be 8 bytes long");
4698 vkStream->handleMapping()->mapHandles_VkPipeline((VkPipeline*)pPipelines,
4699 ((createInfoCount)));
4700 vkStream->write((VkPipeline*)pPipelines, 8 * ((createInfoCount)));
4701 }
4702 // Begin manual non dispatchable handle create for pPipelines;
4703 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
4704 vkStream->write(&vkCreateComputePipelines_VkResult_return, sizeof(VkResult));
4705 vkStream->commitWrite();
4706 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4707 (uintptr_t)snapshotTraceBegin);
4708 size_t snapshotTraceBytes = vkReadStream->endTrace();
4709 if (m_state->snapshotsEnabled()) {
4710 m_state->snapshot()->vkCreateComputePipelines(
4711 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
4712 vkCreateComputePipelines_VkResult_return, device, pipelineCache,
4713 createInfoCount, pCreateInfos, pAllocator, pPipelines);
4714 }
4715 vkReadStream->clearPool();
4716 if (m_queueSubmitWithCommandsEnabled)
4717 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4718 break;
4719 }
4720 case OP_vkDestroyPipeline: {
4721 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4722 "VkDecoder vkDestroyPipeline");
4723 VkDevice device;
4724 VkPipeline pipeline;
4725 const VkAllocationCallbacks* pAllocator;
4726 // Begin global wrapped dispatchable handle unboxing for device;
4727 uint64_t cgen_var_0;
4728 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4729 *readStreamPtrPtr += 1 * 8;
4730 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4731 // Begin manual non dispatchable handle destroy unboxing for pipeline;
4732 VkPipeline boxed_pipeline_preserve;
4733 uint64_t cgen_var_1;
4734 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
4735 *readStreamPtrPtr += 1 * 8;
4736 *(VkPipeline*)&pipeline = (VkPipeline)(VkPipeline)((VkPipeline)(*&cgen_var_1));
4737 boxed_pipeline_preserve = pipeline;
4738 pipeline = try_unbox_VkPipeline(pipeline);
4739 // WARNING PTR CHECK
4740 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4741 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4742 *readStreamPtrPtr += 8;
4743 if (pAllocator) {
4744 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4745 reservedunmarshal_VkAllocationCallbacks(
4746 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4747 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4748 }
4749 if (pAllocator) {
4750 transform_tohost_VkAllocationCallbacks(m_state,
4751 (VkAllocationCallbacks*)(pAllocator));
4752 }
4753 if (m_logCalls) {
4754 fprintf(stderr, "stream %p: call vkDestroyPipeline 0x%llx 0x%llx 0x%llx \n",
4755 ioStream, (unsigned long long)device, (unsigned long long)pipeline,
4756 (unsigned long long)pAllocator);
4757 }
4758 m_state->on_vkDestroyPipeline(&m_pool, device, pipeline, pAllocator);
4759 vkStream->unsetHandleMapping();
4760 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4761 (uintptr_t)snapshotTraceBegin);
4762 size_t snapshotTraceBytes = vkReadStream->endTrace();
4763 if (m_state->snapshotsEnabled()) {
4764 m_state->snapshot()->vkDestroyPipeline(snapshotTraceBegin, snapshotTraceBytes,
4765 &m_pool, device, boxed_pipeline_preserve,
4766 pAllocator);
4767 }
4768 delete_VkPipeline(boxed_pipeline_preserve);
4769 vkReadStream->clearPool();
4770 if (m_queueSubmitWithCommandsEnabled)
4771 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4772 break;
4773 }
4774 case OP_vkCreatePipelineLayout: {
4775 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4776 "VkDecoder vkCreatePipelineLayout");
4777 VkDevice device;
4778 const VkPipelineLayoutCreateInfo* pCreateInfo;
4779 const VkAllocationCallbacks* pAllocator;
4780 VkPipelineLayout* pPipelineLayout;
4781 // Begin non wrapped dispatchable handle unboxing for device;
4782 uint64_t cgen_var_0;
4783 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4784 *readStreamPtrPtr += 1 * 8;
4785 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4786 auto unboxed_device = unbox_VkDevice(device);
4787 auto vk = dispatch_VkDevice(device);
4788 // End manual dispatchable handle unboxing for device;
4789 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkPipelineLayoutCreateInfo));
4790 reservedunmarshal_VkPipelineLayoutCreateInfo(
4791 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4792 (VkPipelineLayoutCreateInfo*)(pCreateInfo), readStreamPtrPtr);
4793 // WARNING PTR CHECK
4794 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4795 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4796 *readStreamPtrPtr += 8;
4797 if (pAllocator) {
4798 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4799 reservedunmarshal_VkAllocationCallbacks(
4800 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4801 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4802 }
4803 // Begin manual dispatchable handle unboxing for pPipelineLayout;
4804 vkReadStream->unsetHandleMapping();
4805 vkReadStream->alloc((void**)&pPipelineLayout, sizeof(VkPipelineLayout));
4806 uint64_t cgen_var_2;
4807 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
4808 *readStreamPtrPtr += 8;
4809 *(VkPipelineLayout*)pPipelineLayout =
4810 (VkPipelineLayout)(VkPipelineLayout)((VkPipelineLayout)(*&cgen_var_2));
4811 if (pCreateInfo) {
4812 transform_tohost_VkPipelineLayoutCreateInfo(
4813 m_state, (VkPipelineLayoutCreateInfo*)(pCreateInfo));
4814 }
4815 if (pAllocator) {
4816 transform_tohost_VkAllocationCallbacks(m_state,
4817 (VkAllocationCallbacks*)(pAllocator));
4818 }
4819 if (m_logCalls) {
4820 fprintf(stderr,
4821 "stream %p: call vkCreatePipelineLayout 0x%llx 0x%llx 0x%llx 0x%llx \n",
4822 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
4823 (unsigned long long)pAllocator, (unsigned long long)pPipelineLayout);
4824 }
4825 m_state->lock();
4826 VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
4827 vkCreatePipelineLayout_VkResult_return = vk->vkCreatePipelineLayout(
4828 unboxed_device, pCreateInfo, pAllocator, pPipelineLayout);
4829 if ((vkCreatePipelineLayout_VkResult_return) == VK_ERROR_DEVICE_LOST)
4830 m_state->on_DeviceLost();
4831 m_state->on_CheckOutOfMemory(vkCreatePipelineLayout_VkResult_return, opcode,
4832 context);
4833 m_state->unlock();
4834 vkStream->unsetHandleMapping();
4835 // Begin auto non dispatchable handle create for pPipelineLayout;
4836 if (vkCreatePipelineLayout_VkResult_return == VK_SUCCESS)
4837 vkStream->setHandleMapping(&m_boxedHandleCreateMapping);
4838 uint64_t cgen_var_3;
4839 static_assert(8 == sizeof(VkPipelineLayout),
4840 "handle map overwrite requires VkPipelineLayout to be 8 bytes long");
4841 vkStream->handleMapping()->mapHandles_VkPipelineLayout(
4842 (VkPipelineLayout*)pPipelineLayout, 1);
4843 vkStream->write((VkPipelineLayout*)pPipelineLayout, 8 * 1);
4844 // Begin auto non dispatchable handle create for pPipelineLayout;
4845 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
4846 vkStream->write(&vkCreatePipelineLayout_VkResult_return, sizeof(VkResult));
4847 vkStream->commitWrite();
4848 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4849 (uintptr_t)snapshotTraceBegin);
4850 size_t snapshotTraceBytes = vkReadStream->endTrace();
4851 if (m_state->snapshotsEnabled()) {
4852 m_state->snapshot()->vkCreatePipelineLayout(
4853 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
4854 vkCreatePipelineLayout_VkResult_return, device, pCreateInfo, pAllocator,
4855 pPipelineLayout);
4856 }
4857 vkReadStream->clearPool();
4858 if (m_queueSubmitWithCommandsEnabled)
4859 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4860 break;
4861 }
4862 case OP_vkDestroyPipelineLayout: {
4863 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4864 "VkDecoder vkDestroyPipelineLayout");
4865 VkDevice device;
4866 VkPipelineLayout pipelineLayout;
4867 const VkAllocationCallbacks* pAllocator;
4868 // Begin non wrapped dispatchable handle unboxing for device;
4869 uint64_t cgen_var_0;
4870 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4871 *readStreamPtrPtr += 1 * 8;
4872 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4873 auto unboxed_device = unbox_VkDevice(device);
4874 auto vk = dispatch_VkDevice(device);
4875 // End manual dispatchable handle unboxing for device;
4876 // Begin manual non dispatchable handle destroy unboxing for pipelineLayout;
4877 VkPipelineLayout boxed_pipelineLayout_preserve;
4878 uint64_t cgen_var_1;
4879 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
4880 *readStreamPtrPtr += 1 * 8;
4881 *(VkPipelineLayout*)&pipelineLayout =
4882 (VkPipelineLayout)(VkPipelineLayout)((VkPipelineLayout)(*&cgen_var_1));
4883 boxed_pipelineLayout_preserve = pipelineLayout;
4884 pipelineLayout = try_unbox_VkPipelineLayout(pipelineLayout);
4885 // WARNING PTR CHECK
4886 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4887 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4888 *readStreamPtrPtr += 8;
4889 if (pAllocator) {
4890 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4891 reservedunmarshal_VkAllocationCallbacks(
4892 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4893 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4894 }
4895 if (pAllocator) {
4896 transform_tohost_VkAllocationCallbacks(m_state,
4897 (VkAllocationCallbacks*)(pAllocator));
4898 }
4899 if (m_logCalls) {
4900 fprintf(stderr,
4901 "stream %p: call vkDestroyPipelineLayout 0x%llx 0x%llx 0x%llx \n",
4902 ioStream, (unsigned long long)device,
4903 (unsigned long long)pipelineLayout, (unsigned long long)pAllocator);
4904 }
4905 std::function<void()> delayed_remove_callback = [vk, unboxed_device, pipelineLayout,
4906 pAllocator]() {
4907 auto state = VkDecoderGlobalState::get();
4908 // state already locked;
4909 vk->vkDestroyPipelineLayout(unboxed_device, pipelineLayout, pAllocator);
4910 };
4911 vkStream->unsetHandleMapping();
4912 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4913 (uintptr_t)snapshotTraceBegin);
4914 size_t snapshotTraceBytes = vkReadStream->endTrace();
4915 if (m_state->snapshotsEnabled()) {
4916 m_state->snapshot()->vkDestroyPipelineLayout(
4917 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
4918 boxed_pipelineLayout_preserve, pAllocator);
4919 }
4920 delayed_delete_VkPipelineLayout(boxed_pipelineLayout_preserve, unboxed_device,
4921 delayed_remove_callback);
4922 vkReadStream->clearPool();
4923 if (m_queueSubmitWithCommandsEnabled)
4924 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
4925 break;
4926 }
4927 case OP_vkCreateSampler: {
4928 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
4929 "VkDecoder vkCreateSampler");
4930 VkDevice device;
4931 const VkSamplerCreateInfo* pCreateInfo;
4932 const VkAllocationCallbacks* pAllocator;
4933 VkSampler* pSampler;
4934 // Begin global wrapped dispatchable handle unboxing for device;
4935 uint64_t cgen_var_0;
4936 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4937 *readStreamPtrPtr += 1 * 8;
4938 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
4939 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkSamplerCreateInfo));
4940 reservedunmarshal_VkSamplerCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4941 (VkSamplerCreateInfo*)(pCreateInfo),
4942 readStreamPtrPtr);
4943 // WARNING PTR CHECK
4944 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
4945 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
4946 *readStreamPtrPtr += 8;
4947 if (pAllocator) {
4948 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
4949 reservedunmarshal_VkAllocationCallbacks(
4950 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4951 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
4952 }
4953 // Begin manual dispatchable handle unboxing for pSampler;
4954 vkReadStream->unsetHandleMapping();
4955 vkReadStream->alloc((void**)&pSampler, sizeof(VkSampler));
4956 uint64_t cgen_var_2;
4957 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
4958 *readStreamPtrPtr += 8;
4959 *(VkSampler*)pSampler = (VkSampler)(VkSampler)((VkSampler)(*&cgen_var_2));
4960 if (pCreateInfo) {
4961 transform_tohost_VkSamplerCreateInfo(m_state,
4962 (VkSamplerCreateInfo*)(pCreateInfo));
4963 }
4964 if (pAllocator) {
4965 transform_tohost_VkAllocationCallbacks(m_state,
4966 (VkAllocationCallbacks*)(pAllocator));
4967 }
4968 if (m_logCalls) {
4969 fprintf(stderr,
4970 "stream %p: call vkCreateSampler 0x%llx 0x%llx 0x%llx 0x%llx \n",
4971 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
4972 (unsigned long long)pAllocator, (unsigned long long)pSampler);
4973 }
4974 VkResult vkCreateSampler_VkResult_return = (VkResult)0;
4975 vkCreateSampler_VkResult_return =
4976 m_state->on_vkCreateSampler(&m_pool, device, pCreateInfo, pAllocator, pSampler);
4977 if ((vkCreateSampler_VkResult_return) == VK_ERROR_DEVICE_LOST)
4978 m_state->on_DeviceLost();
4979 m_state->on_CheckOutOfMemory(vkCreateSampler_VkResult_return, opcode, context);
4980 vkStream->unsetHandleMapping();
4981 // Begin manual non dispatchable handle create for pSampler;
4982 vkStream->unsetHandleMapping();
4983 uint64_t cgen_var_3;
4984 static_assert(8 == sizeof(VkSampler),
4985 "handle map overwrite requires VkSampler to be 8 bytes long");
4986 vkStream->handleMapping()->mapHandles_VkSampler((VkSampler*)pSampler, 1);
4987 vkStream->write((VkSampler*)pSampler, 8 * 1);
4988 // Begin manual non dispatchable handle create for pSampler;
4989 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
4990 vkStream->write(&vkCreateSampler_VkResult_return, sizeof(VkResult));
4991 vkStream->commitWrite();
4992 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
4993 (uintptr_t)snapshotTraceBegin);
4994 size_t snapshotTraceBytes = vkReadStream->endTrace();
4995 if (m_state->snapshotsEnabled()) {
4996 m_state->snapshot()->vkCreateSampler(snapshotTraceBegin, snapshotTraceBytes,
4997 &m_pool, vkCreateSampler_VkResult_return,
4998 device, pCreateInfo, pAllocator, pSampler);
4999 }
5000 vkReadStream->clearPool();
5001 if (m_queueSubmitWithCommandsEnabled)
5002 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5003 break;
5004 }
5005 case OP_vkDestroySampler: {
5006 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5007 "VkDecoder vkDestroySampler");
5008 VkDevice device;
5009 VkSampler sampler;
5010 const VkAllocationCallbacks* pAllocator;
5011 // Begin global wrapped dispatchable handle unboxing for device;
5012 uint64_t cgen_var_0;
5013 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5014 *readStreamPtrPtr += 1 * 8;
5015 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5016 // Begin manual non dispatchable handle destroy unboxing for sampler;
5017 VkSampler boxed_sampler_preserve;
5018 uint64_t cgen_var_1;
5019 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
5020 *readStreamPtrPtr += 1 * 8;
5021 *(VkSampler*)&sampler = (VkSampler)(VkSampler)((VkSampler)(*&cgen_var_1));
5022 boxed_sampler_preserve = sampler;
5023 sampler = try_unbox_VkSampler(sampler);
5024 // WARNING PTR CHECK
5025 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5026 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5027 *readStreamPtrPtr += 8;
5028 if (pAllocator) {
5029 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5030 reservedunmarshal_VkAllocationCallbacks(
5031 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5032 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5033 }
5034 if (pAllocator) {
5035 transform_tohost_VkAllocationCallbacks(m_state,
5036 (VkAllocationCallbacks*)(pAllocator));
5037 }
5038 if (m_logCalls) {
5039 fprintf(stderr, "stream %p: call vkDestroySampler 0x%llx 0x%llx 0x%llx \n",
5040 ioStream, (unsigned long long)device, (unsigned long long)sampler,
5041 (unsigned long long)pAllocator);
5042 }
5043 m_state->on_vkDestroySampler(&m_pool, device, sampler, pAllocator);
5044 vkStream->unsetHandleMapping();
5045 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5046 (uintptr_t)snapshotTraceBegin);
5047 size_t snapshotTraceBytes = vkReadStream->endTrace();
5048 if (m_state->snapshotsEnabled()) {
5049 m_state->snapshot()->vkDestroySampler(snapshotTraceBegin, snapshotTraceBytes,
5050 &m_pool, device, boxed_sampler_preserve,
5051 pAllocator);
5052 }
5053 delete_VkSampler(boxed_sampler_preserve);
5054 vkReadStream->clearPool();
5055 if (m_queueSubmitWithCommandsEnabled)
5056 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5057 break;
5058 }
5059 case OP_vkCreateDescriptorSetLayout: {
5060 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5061 "VkDecoder vkCreateDescriptorSetLayout");
5062 VkDevice device;
5063 const VkDescriptorSetLayoutCreateInfo* pCreateInfo;
5064 const VkAllocationCallbacks* pAllocator;
5065 VkDescriptorSetLayout* pSetLayout;
5066 // Begin global wrapped dispatchable handle unboxing for device;
5067 uint64_t cgen_var_0;
5068 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5069 *readStreamPtrPtr += 1 * 8;
5070 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5071 vkReadStream->alloc((void**)&pCreateInfo,
5072 sizeof(const VkDescriptorSetLayoutCreateInfo));
5073 reservedunmarshal_VkDescriptorSetLayoutCreateInfo(
5074 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5075 (VkDescriptorSetLayoutCreateInfo*)(pCreateInfo), readStreamPtrPtr);
5076 // WARNING PTR CHECK
5077 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5078 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5079 *readStreamPtrPtr += 8;
5080 if (pAllocator) {
5081 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5082 reservedunmarshal_VkAllocationCallbacks(
5083 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5084 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5085 }
5086 // Begin manual dispatchable handle unboxing for pSetLayout;
5087 vkReadStream->unsetHandleMapping();
5088 vkReadStream->alloc((void**)&pSetLayout, sizeof(VkDescriptorSetLayout));
5089 uint64_t cgen_var_2;
5090 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
5091 *readStreamPtrPtr += 8;
5092 *(VkDescriptorSetLayout*)pSetLayout =
5093 (VkDescriptorSetLayout)(VkDescriptorSetLayout)((
5094 VkDescriptorSetLayout)(*&cgen_var_2));
5095 if (pCreateInfo) {
5096 transform_tohost_VkDescriptorSetLayoutCreateInfo(
5097 m_state, (VkDescriptorSetLayoutCreateInfo*)(pCreateInfo));
5098 }
5099 if (pAllocator) {
5100 transform_tohost_VkAllocationCallbacks(m_state,
5101 (VkAllocationCallbacks*)(pAllocator));
5102 }
5103 if (m_logCalls) {
5104 fprintf(stderr,
5105 "stream %p: call vkCreateDescriptorSetLayout 0x%llx 0x%llx 0x%llx "
5106 "0x%llx \n",
5107 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
5108 (unsigned long long)pAllocator, (unsigned long long)pSetLayout);
5109 }
5110 VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
5111 vkCreateDescriptorSetLayout_VkResult_return =
5112 m_state->on_vkCreateDescriptorSetLayout(&m_pool, device, pCreateInfo,
5113 pAllocator, pSetLayout);
5114 if ((vkCreateDescriptorSetLayout_VkResult_return) == VK_ERROR_DEVICE_LOST)
5115 m_state->on_DeviceLost();
5116 m_state->on_CheckOutOfMemory(vkCreateDescriptorSetLayout_VkResult_return, opcode,
5117 context);
5118 vkStream->unsetHandleMapping();
5119 // Begin manual non dispatchable handle create for pSetLayout;
5120 vkStream->unsetHandleMapping();
5121 uint64_t cgen_var_3;
5122 static_assert(
5123 8 == sizeof(VkDescriptorSetLayout),
5124 "handle map overwrite requires VkDescriptorSetLayout to be 8 bytes long");
5125 vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout(
5126 (VkDescriptorSetLayout*)pSetLayout, 1);
5127 vkStream->write((VkDescriptorSetLayout*)pSetLayout, 8 * 1);
5128 // Begin manual non dispatchable handle create for pSetLayout;
5129 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
5130 vkStream->write(&vkCreateDescriptorSetLayout_VkResult_return, sizeof(VkResult));
5131 vkStream->commitWrite();
5132 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5133 (uintptr_t)snapshotTraceBegin);
5134 size_t snapshotTraceBytes = vkReadStream->endTrace();
5135 if (m_state->snapshotsEnabled()) {
5136 m_state->snapshot()->vkCreateDescriptorSetLayout(
5137 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
5138 vkCreateDescriptorSetLayout_VkResult_return, device, pCreateInfo,
5139 pAllocator, pSetLayout);
5140 }
5141 vkReadStream->clearPool();
5142 if (m_queueSubmitWithCommandsEnabled)
5143 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5144 break;
5145 }
5146 case OP_vkDestroyDescriptorSetLayout: {
5147 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5148 "VkDecoder vkDestroyDescriptorSetLayout");
5149 VkDevice device;
5150 VkDescriptorSetLayout descriptorSetLayout;
5151 const VkAllocationCallbacks* pAllocator;
5152 // Begin global wrapped dispatchable handle unboxing for device;
5153 uint64_t cgen_var_0;
5154 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5155 *readStreamPtrPtr += 1 * 8;
5156 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5157 // Begin manual non dispatchable handle destroy unboxing for descriptorSetLayout;
5158 VkDescriptorSetLayout boxed_descriptorSetLayout_preserve;
5159 uint64_t cgen_var_1;
5160 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
5161 *readStreamPtrPtr += 1 * 8;
5162 *(VkDescriptorSetLayout*)&descriptorSetLayout =
5163 (VkDescriptorSetLayout)(VkDescriptorSetLayout)((
5164 VkDescriptorSetLayout)(*&cgen_var_1));
5165 boxed_descriptorSetLayout_preserve = descriptorSetLayout;
5166 descriptorSetLayout = try_unbox_VkDescriptorSetLayout(descriptorSetLayout);
5167 // WARNING PTR CHECK
5168 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5169 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5170 *readStreamPtrPtr += 8;
5171 if (pAllocator) {
5172 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5173 reservedunmarshal_VkAllocationCallbacks(
5174 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5175 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5176 }
5177 if (pAllocator) {
5178 transform_tohost_VkAllocationCallbacks(m_state,
5179 (VkAllocationCallbacks*)(pAllocator));
5180 }
5181 if (m_logCalls) {
5182 fprintf(stderr,
5183 "stream %p: call vkDestroyDescriptorSetLayout 0x%llx 0x%llx 0x%llx \n",
5184 ioStream, (unsigned long long)device,
5185 (unsigned long long)descriptorSetLayout,
5186 (unsigned long long)pAllocator);
5187 }
5188 m_state->on_vkDestroyDescriptorSetLayout(&m_pool, device, descriptorSetLayout,
5189 pAllocator);
5190 vkStream->unsetHandleMapping();
5191 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5192 (uintptr_t)snapshotTraceBegin);
5193 size_t snapshotTraceBytes = vkReadStream->endTrace();
5194 if (m_state->snapshotsEnabled()) {
5195 m_state->snapshot()->vkDestroyDescriptorSetLayout(
5196 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
5197 boxed_descriptorSetLayout_preserve, pAllocator);
5198 }
5199 delete_VkDescriptorSetLayout(boxed_descriptorSetLayout_preserve);
5200 vkReadStream->clearPool();
5201 if (m_queueSubmitWithCommandsEnabled)
5202 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5203 break;
5204 }
5205 case OP_vkCreateDescriptorPool: {
5206 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5207 "VkDecoder vkCreateDescriptorPool");
5208 VkDevice device;
5209 const VkDescriptorPoolCreateInfo* pCreateInfo;
5210 const VkAllocationCallbacks* pAllocator;
5211 VkDescriptorPool* pDescriptorPool;
5212 // Begin global wrapped dispatchable handle unboxing for device;
5213 uint64_t cgen_var_0;
5214 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5215 *readStreamPtrPtr += 1 * 8;
5216 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5217 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkDescriptorPoolCreateInfo));
5218 reservedunmarshal_VkDescriptorPoolCreateInfo(
5219 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5220 (VkDescriptorPoolCreateInfo*)(pCreateInfo), readStreamPtrPtr);
5221 // WARNING PTR CHECK
5222 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5223 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5224 *readStreamPtrPtr += 8;
5225 if (pAllocator) {
5226 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5227 reservedunmarshal_VkAllocationCallbacks(
5228 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5229 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5230 }
5231 // Begin manual dispatchable handle unboxing for pDescriptorPool;
5232 vkReadStream->unsetHandleMapping();
5233 vkReadStream->alloc((void**)&pDescriptorPool, sizeof(VkDescriptorPool));
5234 uint64_t cgen_var_2;
5235 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
5236 *readStreamPtrPtr += 8;
5237 *(VkDescriptorPool*)pDescriptorPool =
5238 (VkDescriptorPool)(VkDescriptorPool)((VkDescriptorPool)(*&cgen_var_2));
5239 if (pCreateInfo) {
5240 transform_tohost_VkDescriptorPoolCreateInfo(
5241 m_state, (VkDescriptorPoolCreateInfo*)(pCreateInfo));
5242 }
5243 if (pAllocator) {
5244 transform_tohost_VkAllocationCallbacks(m_state,
5245 (VkAllocationCallbacks*)(pAllocator));
5246 }
5247 if (m_logCalls) {
5248 fprintf(stderr,
5249 "stream %p: call vkCreateDescriptorPool 0x%llx 0x%llx 0x%llx 0x%llx \n",
5250 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
5251 (unsigned long long)pAllocator, (unsigned long long)pDescriptorPool);
5252 }
5253 VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
5254 vkCreateDescriptorPool_VkResult_return = m_state->on_vkCreateDescriptorPool(
5255 &m_pool, device, pCreateInfo, pAllocator, pDescriptorPool);
5256 if ((vkCreateDescriptorPool_VkResult_return) == VK_ERROR_DEVICE_LOST)
5257 m_state->on_DeviceLost();
5258 m_state->on_CheckOutOfMemory(vkCreateDescriptorPool_VkResult_return, opcode,
5259 context);
5260 vkStream->unsetHandleMapping();
5261 // Begin manual non dispatchable handle create for pDescriptorPool;
5262 vkStream->unsetHandleMapping();
5263 uint64_t cgen_var_3;
5264 static_assert(8 == sizeof(VkDescriptorPool),
5265 "handle map overwrite requires VkDescriptorPool to be 8 bytes long");
5266 vkStream->handleMapping()->mapHandles_VkDescriptorPool(
5267 (VkDescriptorPool*)pDescriptorPool, 1);
5268 vkStream->write((VkDescriptorPool*)pDescriptorPool, 8 * 1);
5269 // Begin manual non dispatchable handle create for pDescriptorPool;
5270 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
5271 vkStream->write(&vkCreateDescriptorPool_VkResult_return, sizeof(VkResult));
5272 vkStream->commitWrite();
5273 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5274 (uintptr_t)snapshotTraceBegin);
5275 size_t snapshotTraceBytes = vkReadStream->endTrace();
5276 if (m_state->snapshotsEnabled()) {
5277 m_state->snapshot()->vkCreateDescriptorPool(
5278 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
5279 vkCreateDescriptorPool_VkResult_return, device, pCreateInfo, pAllocator,
5280 pDescriptorPool);
5281 }
5282 vkReadStream->clearPool();
5283 if (m_queueSubmitWithCommandsEnabled)
5284 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5285 break;
5286 }
5287 case OP_vkDestroyDescriptorPool: {
5288 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5289 "VkDecoder vkDestroyDescriptorPool");
5290 VkDevice device;
5291 VkDescriptorPool descriptorPool;
5292 const VkAllocationCallbacks* pAllocator;
5293 // Begin global wrapped dispatchable handle unboxing for device;
5294 uint64_t cgen_var_0;
5295 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5296 *readStreamPtrPtr += 1 * 8;
5297 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5298 // Begin manual non dispatchable handle destroy unboxing for descriptorPool;
5299 VkDescriptorPool boxed_descriptorPool_preserve;
5300 uint64_t cgen_var_1;
5301 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
5302 *readStreamPtrPtr += 1 * 8;
5303 *(VkDescriptorPool*)&descriptorPool =
5304 (VkDescriptorPool)(VkDescriptorPool)((VkDescriptorPool)(*&cgen_var_1));
5305 boxed_descriptorPool_preserve = descriptorPool;
5306 descriptorPool = try_unbox_VkDescriptorPool(descriptorPool);
5307 // WARNING PTR CHECK
5308 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5309 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5310 *readStreamPtrPtr += 8;
5311 if (pAllocator) {
5312 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5313 reservedunmarshal_VkAllocationCallbacks(
5314 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5315 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5316 }
5317 if (pAllocator) {
5318 transform_tohost_VkAllocationCallbacks(m_state,
5319 (VkAllocationCallbacks*)(pAllocator));
5320 }
5321 if (m_logCalls) {
5322 fprintf(stderr,
5323 "stream %p: call vkDestroyDescriptorPool 0x%llx 0x%llx 0x%llx \n",
5324 ioStream, (unsigned long long)device,
5325 (unsigned long long)descriptorPool, (unsigned long long)pAllocator);
5326 }
5327 m_state->on_vkDestroyDescriptorPool(&m_pool, device, descriptorPool, pAllocator);
5328 vkStream->unsetHandleMapping();
5329 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5330 (uintptr_t)snapshotTraceBegin);
5331 size_t snapshotTraceBytes = vkReadStream->endTrace();
5332 if (m_state->snapshotsEnabled()) {
5333 m_state->snapshot()->vkDestroyDescriptorPool(
5334 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
5335 boxed_descriptorPool_preserve, pAllocator);
5336 }
5337 delete_VkDescriptorPool(boxed_descriptorPool_preserve);
5338 vkReadStream->clearPool();
5339 if (m_queueSubmitWithCommandsEnabled)
5340 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5341 break;
5342 }
5343 case OP_vkResetDescriptorPool: {
5344 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5345 "VkDecoder vkResetDescriptorPool");
5346 VkDevice device;
5347 VkDescriptorPool descriptorPool;
5348 VkDescriptorPoolResetFlags flags;
5349 // Begin global wrapped dispatchable handle unboxing for device;
5350 uint64_t cgen_var_0;
5351 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5352 *readStreamPtrPtr += 1 * 8;
5353 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5354 uint64_t cgen_var_1;
5355 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
5356 *readStreamPtrPtr += 1 * 8;
5357 *(VkDescriptorPool*)&descriptorPool =
5358 (VkDescriptorPool)unbox_VkDescriptorPool((VkDescriptorPool)(*&cgen_var_1));
5359 memcpy((VkDescriptorPoolResetFlags*)&flags, *readStreamPtrPtr,
5360 sizeof(VkDescriptorPoolResetFlags));
5361 *readStreamPtrPtr += sizeof(VkDescriptorPoolResetFlags);
5362 if (m_logCalls) {
5363 fprintf(stderr, "stream %p: call vkResetDescriptorPool 0x%llx 0x%llx 0x%llx \n",
5364 ioStream, (unsigned long long)device,
5365 (unsigned long long)descriptorPool, (unsigned long long)flags);
5366 }
5367 VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
5368 vkResetDescriptorPool_VkResult_return =
5369 m_state->on_vkResetDescriptorPool(&m_pool, device, descriptorPool, flags);
5370 if ((vkResetDescriptorPool_VkResult_return) == VK_ERROR_DEVICE_LOST)
5371 m_state->on_DeviceLost();
5372 m_state->on_CheckOutOfMemory(vkResetDescriptorPool_VkResult_return, opcode,
5373 context);
5374 vkStream->unsetHandleMapping();
5375 vkStream->write(&vkResetDescriptorPool_VkResult_return, sizeof(VkResult));
5376 vkStream->commitWrite();
5377 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5378 (uintptr_t)snapshotTraceBegin);
5379 size_t snapshotTraceBytes = vkReadStream->endTrace();
5380 if (m_state->snapshotsEnabled()) {
5381 m_state->snapshot()->vkResetDescriptorPool(
5382 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
5383 vkResetDescriptorPool_VkResult_return, device, descriptorPool, flags);
5384 }
5385 vkReadStream->clearPool();
5386 if (m_queueSubmitWithCommandsEnabled)
5387 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5388 break;
5389 }
5390 case OP_vkAllocateDescriptorSets: {
5391 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5392 "VkDecoder vkAllocateDescriptorSets");
5393 VkDevice device;
5394 const VkDescriptorSetAllocateInfo* pAllocateInfo;
5395 VkDescriptorSet* pDescriptorSets;
5396 // Begin global wrapped dispatchable handle unboxing for device;
5397 uint64_t cgen_var_0;
5398 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5399 *readStreamPtrPtr += 1 * 8;
5400 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5401 vkReadStream->alloc((void**)&pAllocateInfo,
5402 sizeof(const VkDescriptorSetAllocateInfo));
5403 reservedunmarshal_VkDescriptorSetAllocateInfo(
5404 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5405 (VkDescriptorSetAllocateInfo*)(pAllocateInfo), readStreamPtrPtr);
5406 // Begin manual dispatchable handle unboxing for pDescriptorSets;
5407 vkReadStream->unsetHandleMapping();
5408 vkReadStream->alloc((void**)&pDescriptorSets,
5409 pAllocateInfo->descriptorSetCount * sizeof(VkDescriptorSet));
5410 if (pAllocateInfo->descriptorSetCount) {
5411 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
5412 *readStreamPtrPtr += 8 * pAllocateInfo->descriptorSetCount;
5413 for (uint32_t k = 0; k < pAllocateInfo->descriptorSetCount; ++k) {
5414 uint64_t tmpval;
5415 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
5416 *(((VkDescriptorSet*)pDescriptorSets) + k) =
5417 tmpval ? (VkDescriptorSet)(VkDescriptorSet)((VkDescriptorSet)tmpval)
5418 : VK_NULL_HANDLE;
5419 }
5420 }
5421 if (pAllocateInfo) {
5422 transform_tohost_VkDescriptorSetAllocateInfo(
5423 m_state, (VkDescriptorSetAllocateInfo*)(pAllocateInfo));
5424 }
5425 if (m_logCalls) {
5426 fprintf(stderr,
5427 "stream %p: call vkAllocateDescriptorSets 0x%llx 0x%llx 0x%llx \n",
5428 ioStream, (unsigned long long)device, (unsigned long long)pAllocateInfo,
5429 (unsigned long long)pDescriptorSets);
5430 }
5431 VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
5432 vkAllocateDescriptorSets_VkResult_return = m_state->on_vkAllocateDescriptorSets(
5433 &m_pool, device, pAllocateInfo, pDescriptorSets);
5434 if ((vkAllocateDescriptorSets_VkResult_return) == VK_ERROR_DEVICE_LOST)
5435 m_state->on_DeviceLost();
5436 m_state->on_CheckOutOfMemory(vkAllocateDescriptorSets_VkResult_return, opcode,
5437 context);
5438 vkStream->unsetHandleMapping();
5439 // Begin manual non dispatchable handle create for pDescriptorSets;
5440 vkStream->unsetHandleMapping();
5441 if (pAllocateInfo->descriptorSetCount) {
5442 uint64_t* cgen_var_2;
5443 vkStream->alloc((void**)&cgen_var_2, pAllocateInfo->descriptorSetCount * 8);
5444 static_assert(
5445 8 == sizeof(VkDescriptorSet),
5446 "handle map overwrite requires VkDescriptorSet to be 8 bytes long");
5447 vkStream->handleMapping()->mapHandles_VkDescriptorSet(
5448 (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
5449 vkStream->write((VkDescriptorSet*)pDescriptorSets,
5450 8 * pAllocateInfo->descriptorSetCount);
5451 }
5452 // Begin manual non dispatchable handle create for pDescriptorSets;
5453 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
5454 vkStream->write(&vkAllocateDescriptorSets_VkResult_return, sizeof(VkResult));
5455 vkStream->commitWrite();
5456 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5457 (uintptr_t)snapshotTraceBegin);
5458 size_t snapshotTraceBytes = vkReadStream->endTrace();
5459 if (m_state->snapshotsEnabled()) {
5460 m_state->snapshot()->vkAllocateDescriptorSets(
5461 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
5462 vkAllocateDescriptorSets_VkResult_return, device, pAllocateInfo,
5463 pDescriptorSets);
5464 }
5465 vkReadStream->clearPool();
5466 if (m_queueSubmitWithCommandsEnabled)
5467 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5468 break;
5469 }
5470 case OP_vkFreeDescriptorSets: {
5471 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5472 "VkDecoder vkFreeDescriptorSets");
5473 VkDevice device;
5474 VkDescriptorPool descriptorPool;
5475 uint32_t descriptorSetCount;
5476 const VkDescriptorSet* pDescriptorSets;
5477 // Begin global wrapped dispatchable handle unboxing for device;
5478 uint64_t cgen_var_0;
5479 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5480 *readStreamPtrPtr += 1 * 8;
5481 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5482 uint64_t cgen_var_1;
5483 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
5484 *readStreamPtrPtr += 1 * 8;
5485 *(VkDescriptorPool*)&descriptorPool =
5486 (VkDescriptorPool)unbox_VkDescriptorPool((VkDescriptorPool)(*&cgen_var_1));
5487 memcpy((uint32_t*)&descriptorSetCount, *readStreamPtrPtr, sizeof(uint32_t));
5488 *readStreamPtrPtr += sizeof(uint32_t);
5489 // Begin manual non dispatchable handle destroy unboxing for pDescriptorSets;
5490 VkDescriptorSet* boxed_pDescriptorSets_preserve;
5491 vkReadStream->alloc((void**)&boxed_pDescriptorSets_preserve,
5492 ((descriptorSetCount)) * sizeof(VkDescriptorSet));
5493 // WARNING PTR CHECK
5494 memcpy((VkDescriptorSet**)&pDescriptorSets, (*readStreamPtrPtr), 8);
5495 android::base::Stream::fromBe64((uint8_t*)&pDescriptorSets);
5496 *readStreamPtrPtr += 8;
5497 if (pDescriptorSets) {
5498 vkReadStream->alloc((void**)&pDescriptorSets,
5499 ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
5500 if (((descriptorSetCount))) {
5501 uint8_t* cgen_var_2_0_ptr = (uint8_t*)(*readStreamPtrPtr);
5502 *readStreamPtrPtr += 8 * ((descriptorSetCount));
5503 for (uint32_t k = 0; k < ((descriptorSetCount)); ++k) {
5504 uint64_t tmpval;
5505 memcpy(&tmpval, cgen_var_2_0_ptr + k * 8, sizeof(uint64_t));
5506 *(((VkDescriptorSet*)pDescriptorSets) + k) =
5507 tmpval ? (VkDescriptorSet)(VkDescriptorSet)((VkDescriptorSet)tmpval)
5508 : VK_NULL_HANDLE;
5509 }
5510 }
5511 }
5512 for (uint32_t i = 0; i < ((descriptorSetCount)); ++i) {
5513 boxed_pDescriptorSets_preserve[i] = pDescriptorSets[i];
5514 ((VkDescriptorSet*)(pDescriptorSets))[i] =
5515 try_unbox_VkDescriptorSet(pDescriptorSets[i]);
5516 }
5517 if (m_logCalls) {
5518 fprintf(stderr,
5519 "stream %p: call vkFreeDescriptorSets 0x%llx 0x%llx 0x%llx 0x%llx \n",
5520 ioStream, (unsigned long long)device,
5521 (unsigned long long)descriptorPool,
5522 (unsigned long long)descriptorSetCount,
5523 (unsigned long long)pDescriptorSets);
5524 }
5525 VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
5526 vkFreeDescriptorSets_VkResult_return = m_state->on_vkFreeDescriptorSets(
5527 &m_pool, device, descriptorPool, descriptorSetCount, pDescriptorSets);
5528 if ((vkFreeDescriptorSets_VkResult_return) == VK_ERROR_DEVICE_LOST)
5529 m_state->on_DeviceLost();
5530 m_state->on_CheckOutOfMemory(vkFreeDescriptorSets_VkResult_return, opcode, context);
5531 vkStream->unsetHandleMapping();
5532 vkStream->write(&vkFreeDescriptorSets_VkResult_return, sizeof(VkResult));
5533 vkStream->commitWrite();
5534 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5535 (uintptr_t)snapshotTraceBegin);
5536 size_t snapshotTraceBytes = vkReadStream->endTrace();
5537 if (m_state->snapshotsEnabled()) {
5538 m_state->snapshot()->vkFreeDescriptorSets(
5539 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
5540 vkFreeDescriptorSets_VkResult_return, device, descriptorPool,
5541 descriptorSetCount, boxed_pDescriptorSets_preserve);
5542 }
5543 // Skipping handle cleanup for vkFreeDescriptorSets
5544 vkReadStream->clearPool();
5545 if (m_queueSubmitWithCommandsEnabled)
5546 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5547 break;
5548 }
5549 case OP_vkUpdateDescriptorSets: {
5550 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5551 "VkDecoder vkUpdateDescriptorSets");
5552 VkDevice device;
5553 uint32_t descriptorWriteCount;
5554 const VkWriteDescriptorSet* pDescriptorWrites;
5555 uint32_t descriptorCopyCount;
5556 const VkCopyDescriptorSet* pDescriptorCopies;
5557 // Begin global wrapped dispatchable handle unboxing for device;
5558 uint64_t cgen_var_0;
5559 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5560 *readStreamPtrPtr += 1 * 8;
5561 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5562 memcpy((uint32_t*)&descriptorWriteCount, *readStreamPtrPtr, sizeof(uint32_t));
5563 *readStreamPtrPtr += sizeof(uint32_t);
5564 vkReadStream->alloc((void**)&pDescriptorWrites,
5565 ((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
5566 for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
5567 reservedunmarshal_VkWriteDescriptorSet(
5568 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5569 (VkWriteDescriptorSet*)(pDescriptorWrites + i), readStreamPtrPtr);
5570 }
5571 memcpy((uint32_t*)&descriptorCopyCount, *readStreamPtrPtr, sizeof(uint32_t));
5572 *readStreamPtrPtr += sizeof(uint32_t);
5573 vkReadStream->alloc((void**)&pDescriptorCopies,
5574 ((descriptorCopyCount)) * sizeof(const VkCopyDescriptorSet));
5575 for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i) {
5576 reservedunmarshal_VkCopyDescriptorSet(
5577 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5578 (VkCopyDescriptorSet*)(pDescriptorCopies + i), readStreamPtrPtr);
5579 }
5580 if (pDescriptorWrites) {
5581 for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
5582 transform_tohost_VkWriteDescriptorSet(
5583 m_state, (VkWriteDescriptorSet*)(pDescriptorWrites + i));
5584 }
5585 }
5586 if (pDescriptorCopies) {
5587 for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i) {
5588 transform_tohost_VkCopyDescriptorSet(
5589 m_state, (VkCopyDescriptorSet*)(pDescriptorCopies + i));
5590 }
5591 }
5592 if (m_logCalls) {
5593 fprintf(stderr,
5594 "stream %p: call vkUpdateDescriptorSets 0x%llx 0x%llx 0x%llx 0x%llx "
5595 "0x%llx \n",
5596 ioStream, (unsigned long long)device,
5597 (unsigned long long)descriptorWriteCount,
5598 (unsigned long long)pDescriptorWrites,
5599 (unsigned long long)descriptorCopyCount,
5600 (unsigned long long)pDescriptorCopies);
5601 }
5602 m_state->on_vkUpdateDescriptorSets(&m_pool, device, descriptorWriteCount,
5603 pDescriptorWrites, descriptorCopyCount,
5604 pDescriptorCopies);
5605 vkStream->unsetHandleMapping();
5606 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5607 (uintptr_t)snapshotTraceBegin);
5608 size_t snapshotTraceBytes = vkReadStream->endTrace();
5609 if (m_state->snapshotsEnabled()) {
5610 m_state->snapshot()->vkUpdateDescriptorSets(
5611 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
5612 descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
5613 pDescriptorCopies);
5614 }
5615 vkReadStream->clearPool();
5616 if (m_queueSubmitWithCommandsEnabled)
5617 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5618 break;
5619 }
5620 case OP_vkCreateFramebuffer: {
5621 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5622 "VkDecoder vkCreateFramebuffer");
5623 VkDevice device;
5624 const VkFramebufferCreateInfo* pCreateInfo;
5625 const VkAllocationCallbacks* pAllocator;
5626 VkFramebuffer* pFramebuffer;
5627 // Begin global wrapped dispatchable handle unboxing for device;
5628 uint64_t cgen_var_0;
5629 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5630 *readStreamPtrPtr += 1 * 8;
5631 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5632 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkFramebufferCreateInfo));
5633 reservedunmarshal_VkFramebufferCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5634 (VkFramebufferCreateInfo*)(pCreateInfo),
5635 readStreamPtrPtr);
5636 // WARNING PTR CHECK
5637 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5638 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5639 *readStreamPtrPtr += 8;
5640 if (pAllocator) {
5641 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5642 reservedunmarshal_VkAllocationCallbacks(
5643 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5644 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5645 }
5646 // Begin manual dispatchable handle unboxing for pFramebuffer;
5647 vkReadStream->unsetHandleMapping();
5648 vkReadStream->alloc((void**)&pFramebuffer, sizeof(VkFramebuffer));
5649 uint64_t cgen_var_2;
5650 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
5651 *readStreamPtrPtr += 8;
5652 *(VkFramebuffer*)pFramebuffer =
5653 (VkFramebuffer)(VkFramebuffer)((VkFramebuffer)(*&cgen_var_2));
5654 if (pCreateInfo) {
5655 transform_tohost_VkFramebufferCreateInfo(
5656 m_state, (VkFramebufferCreateInfo*)(pCreateInfo));
5657 }
5658 if (pAllocator) {
5659 transform_tohost_VkAllocationCallbacks(m_state,
5660 (VkAllocationCallbacks*)(pAllocator));
5661 }
5662 if (m_logCalls) {
5663 fprintf(stderr,
5664 "stream %p: call vkCreateFramebuffer 0x%llx 0x%llx 0x%llx 0x%llx \n",
5665 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
5666 (unsigned long long)pAllocator, (unsigned long long)pFramebuffer);
5667 }
5668 VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
5669 vkCreateFramebuffer_VkResult_return = m_state->on_vkCreateFramebuffer(
5670 &m_pool, device, pCreateInfo, pAllocator, pFramebuffer);
5671 if ((vkCreateFramebuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
5672 m_state->on_DeviceLost();
5673 m_state->on_CheckOutOfMemory(vkCreateFramebuffer_VkResult_return, opcode, context);
5674 vkStream->unsetHandleMapping();
5675 // Begin manual non dispatchable handle create for pFramebuffer;
5676 vkStream->unsetHandleMapping();
5677 uint64_t cgen_var_3;
5678 static_assert(8 == sizeof(VkFramebuffer),
5679 "handle map overwrite requires VkFramebuffer to be 8 bytes long");
5680 vkStream->handleMapping()->mapHandles_VkFramebuffer((VkFramebuffer*)pFramebuffer,
5681 1);
5682 vkStream->write((VkFramebuffer*)pFramebuffer, 8 * 1);
5683 // Begin manual non dispatchable handle create for pFramebuffer;
5684 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
5685 vkStream->write(&vkCreateFramebuffer_VkResult_return, sizeof(VkResult));
5686 vkStream->commitWrite();
5687 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5688 (uintptr_t)snapshotTraceBegin);
5689 size_t snapshotTraceBytes = vkReadStream->endTrace();
5690 if (m_state->snapshotsEnabled()) {
5691 m_state->snapshot()->vkCreateFramebuffer(
5692 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
5693 vkCreateFramebuffer_VkResult_return, device, pCreateInfo, pAllocator,
5694 pFramebuffer);
5695 }
5696 vkReadStream->clearPool();
5697 if (m_queueSubmitWithCommandsEnabled)
5698 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5699 break;
5700 }
5701 case OP_vkDestroyFramebuffer: {
5702 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5703 "VkDecoder vkDestroyFramebuffer");
5704 VkDevice device;
5705 VkFramebuffer framebuffer;
5706 const VkAllocationCallbacks* pAllocator;
5707 // Begin global wrapped dispatchable handle unboxing for device;
5708 uint64_t cgen_var_0;
5709 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5710 *readStreamPtrPtr += 1 * 8;
5711 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5712 // Begin manual non dispatchable handle destroy unboxing for framebuffer;
5713 VkFramebuffer boxed_framebuffer_preserve;
5714 uint64_t cgen_var_1;
5715 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
5716 *readStreamPtrPtr += 1 * 8;
5717 *(VkFramebuffer*)&framebuffer =
5718 (VkFramebuffer)(VkFramebuffer)((VkFramebuffer)(*&cgen_var_1));
5719 boxed_framebuffer_preserve = framebuffer;
5720 framebuffer = try_unbox_VkFramebuffer(framebuffer);
5721 // WARNING PTR CHECK
5722 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5723 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5724 *readStreamPtrPtr += 8;
5725 if (pAllocator) {
5726 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5727 reservedunmarshal_VkAllocationCallbacks(
5728 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5729 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5730 }
5731 if (pAllocator) {
5732 transform_tohost_VkAllocationCallbacks(m_state,
5733 (VkAllocationCallbacks*)(pAllocator));
5734 }
5735 if (m_logCalls) {
5736 fprintf(stderr, "stream %p: call vkDestroyFramebuffer 0x%llx 0x%llx 0x%llx \n",
5737 ioStream, (unsigned long long)device, (unsigned long long)framebuffer,
5738 (unsigned long long)pAllocator);
5739 }
5740 m_state->on_vkDestroyFramebuffer(&m_pool, device, framebuffer, pAllocator);
5741 vkStream->unsetHandleMapping();
5742 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5743 (uintptr_t)snapshotTraceBegin);
5744 size_t snapshotTraceBytes = vkReadStream->endTrace();
5745 if (m_state->snapshotsEnabled()) {
5746 m_state->snapshot()->vkDestroyFramebuffer(
5747 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
5748 boxed_framebuffer_preserve, pAllocator);
5749 }
5750 delete_VkFramebuffer(boxed_framebuffer_preserve);
5751 vkReadStream->clearPool();
5752 if (m_queueSubmitWithCommandsEnabled)
5753 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5754 break;
5755 }
5756 case OP_vkCreateRenderPass: {
5757 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5758 "VkDecoder vkCreateRenderPass");
5759 VkDevice device;
5760 const VkRenderPassCreateInfo* pCreateInfo;
5761 const VkAllocationCallbacks* pAllocator;
5762 VkRenderPass* pRenderPass;
5763 // Begin global wrapped dispatchable handle unboxing for device;
5764 uint64_t cgen_var_0;
5765 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5766 *readStreamPtrPtr += 1 * 8;
5767 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5768 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkRenderPassCreateInfo));
5769 reservedunmarshal_VkRenderPassCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5770 (VkRenderPassCreateInfo*)(pCreateInfo),
5771 readStreamPtrPtr);
5772 // WARNING PTR CHECK
5773 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5774 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5775 *readStreamPtrPtr += 8;
5776 if (pAllocator) {
5777 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5778 reservedunmarshal_VkAllocationCallbacks(
5779 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5780 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5781 }
5782 // Begin manual dispatchable handle unboxing for pRenderPass;
5783 vkReadStream->unsetHandleMapping();
5784 vkReadStream->alloc((void**)&pRenderPass, sizeof(VkRenderPass));
5785 uint64_t cgen_var_2;
5786 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
5787 *readStreamPtrPtr += 8;
5788 *(VkRenderPass*)pRenderPass =
5789 (VkRenderPass)(VkRenderPass)((VkRenderPass)(*&cgen_var_2));
5790 if (pCreateInfo) {
5791 transform_tohost_VkRenderPassCreateInfo(m_state,
5792 (VkRenderPassCreateInfo*)(pCreateInfo));
5793 }
5794 if (pAllocator) {
5795 transform_tohost_VkAllocationCallbacks(m_state,
5796 (VkAllocationCallbacks*)(pAllocator));
5797 }
5798 if (m_logCalls) {
5799 fprintf(stderr,
5800 "stream %p: call vkCreateRenderPass 0x%llx 0x%llx 0x%llx 0x%llx \n",
5801 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
5802 (unsigned long long)pAllocator, (unsigned long long)pRenderPass);
5803 }
5804 VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
5805 vkCreateRenderPass_VkResult_return = m_state->on_vkCreateRenderPass(
5806 &m_pool, device, pCreateInfo, pAllocator, pRenderPass);
5807 if ((vkCreateRenderPass_VkResult_return) == VK_ERROR_DEVICE_LOST)
5808 m_state->on_DeviceLost();
5809 m_state->on_CheckOutOfMemory(vkCreateRenderPass_VkResult_return, opcode, context);
5810 vkStream->unsetHandleMapping();
5811 // Begin manual non dispatchable handle create for pRenderPass;
5812 vkStream->unsetHandleMapping();
5813 uint64_t cgen_var_3;
5814 static_assert(8 == sizeof(VkRenderPass),
5815 "handle map overwrite requires VkRenderPass to be 8 bytes long");
5816 vkStream->handleMapping()->mapHandles_VkRenderPass((VkRenderPass*)pRenderPass, 1);
5817 vkStream->write((VkRenderPass*)pRenderPass, 8 * 1);
5818 // Begin manual non dispatchable handle create for pRenderPass;
5819 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
5820 vkStream->write(&vkCreateRenderPass_VkResult_return, sizeof(VkResult));
5821 vkStream->commitWrite();
5822 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5823 (uintptr_t)snapshotTraceBegin);
5824 size_t snapshotTraceBytes = vkReadStream->endTrace();
5825 if (m_state->snapshotsEnabled()) {
5826 m_state->snapshot()->vkCreateRenderPass(
5827 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
5828 vkCreateRenderPass_VkResult_return, device, pCreateInfo, pAllocator,
5829 pRenderPass);
5830 }
5831 vkReadStream->clearPool();
5832 if (m_queueSubmitWithCommandsEnabled)
5833 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5834 break;
5835 }
5836 case OP_vkDestroyRenderPass: {
5837 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5838 "VkDecoder vkDestroyRenderPass");
5839 VkDevice device;
5840 VkRenderPass renderPass;
5841 const VkAllocationCallbacks* pAllocator;
5842 // Begin global wrapped dispatchable handle unboxing for device;
5843 uint64_t cgen_var_0;
5844 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5845 *readStreamPtrPtr += 1 * 8;
5846 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5847 // Begin manual non dispatchable handle destroy unboxing for renderPass;
5848 VkRenderPass boxed_renderPass_preserve;
5849 uint64_t cgen_var_1;
5850 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
5851 *readStreamPtrPtr += 1 * 8;
5852 *(VkRenderPass*)&renderPass =
5853 (VkRenderPass)(VkRenderPass)((VkRenderPass)(*&cgen_var_1));
5854 boxed_renderPass_preserve = renderPass;
5855 renderPass = try_unbox_VkRenderPass(renderPass);
5856 // WARNING PTR CHECK
5857 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5858 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5859 *readStreamPtrPtr += 8;
5860 if (pAllocator) {
5861 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5862 reservedunmarshal_VkAllocationCallbacks(
5863 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5864 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5865 }
5866 if (pAllocator) {
5867 transform_tohost_VkAllocationCallbacks(m_state,
5868 (VkAllocationCallbacks*)(pAllocator));
5869 }
5870 if (m_logCalls) {
5871 fprintf(stderr, "stream %p: call vkDestroyRenderPass 0x%llx 0x%llx 0x%llx \n",
5872 ioStream, (unsigned long long)device, (unsigned long long)renderPass,
5873 (unsigned long long)pAllocator);
5874 }
5875 m_state->on_vkDestroyRenderPass(&m_pool, device, renderPass, pAllocator);
5876 vkStream->unsetHandleMapping();
5877 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5878 (uintptr_t)snapshotTraceBegin);
5879 size_t snapshotTraceBytes = vkReadStream->endTrace();
5880 if (m_state->snapshotsEnabled()) {
5881 m_state->snapshot()->vkDestroyRenderPass(snapshotTraceBegin, snapshotTraceBytes,
5882 &m_pool, device,
5883 boxed_renderPass_preserve, pAllocator);
5884 }
5885 delete_VkRenderPass(boxed_renderPass_preserve);
5886 vkReadStream->clearPool();
5887 if (m_queueSubmitWithCommandsEnabled)
5888 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5889 break;
5890 }
5891 case OP_vkGetRenderAreaGranularity: {
5892 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5893 "VkDecoder vkGetRenderAreaGranularity");
5894 VkDevice device;
5895 VkRenderPass renderPass;
5896 VkExtent2D* pGranularity;
5897 // Begin non wrapped dispatchable handle unboxing for device;
5898 uint64_t cgen_var_0;
5899 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5900 *readStreamPtrPtr += 1 * 8;
5901 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5902 auto unboxed_device = unbox_VkDevice(device);
5903 auto vk = dispatch_VkDevice(device);
5904 // End manual dispatchable handle unboxing for device;
5905 uint64_t cgen_var_1;
5906 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
5907 *readStreamPtrPtr += 1 * 8;
5908 *(VkRenderPass*)&renderPass =
5909 (VkRenderPass)unbox_VkRenderPass((VkRenderPass)(*&cgen_var_1));
5910 // Begin manual dispatchable handle unboxing for pGranularity;
5911 vkReadStream->unsetHandleMapping();
5912 vkReadStream->alloc((void**)&pGranularity, sizeof(VkExtent2D));
5913 reservedunmarshal_VkExtent2D(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5914 (VkExtent2D*)(pGranularity), readStreamPtrPtr);
5915 if (pGranularity) {
5916 transform_tohost_VkExtent2D(m_state, (VkExtent2D*)(pGranularity));
5917 }
5918 if (m_logCalls) {
5919 fprintf(stderr,
5920 "stream %p: call vkGetRenderAreaGranularity 0x%llx 0x%llx 0x%llx \n",
5921 ioStream, (unsigned long long)device, (unsigned long long)renderPass,
5922 (unsigned long long)pGranularity);
5923 }
5924 vk->vkGetRenderAreaGranularity(unboxed_device, renderPass, pGranularity);
5925 vkStream->unsetHandleMapping();
5926 if (pGranularity) {
5927 transform_fromhost_VkExtent2D(m_state, (VkExtent2D*)(pGranularity));
5928 }
5929 marshal_VkExtent2D(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5930 (VkExtent2D*)(pGranularity));
5931 vkStream->commitWrite();
5932 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
5933 (uintptr_t)snapshotTraceBegin);
5934 size_t snapshotTraceBytes = vkReadStream->endTrace();
5935 if (m_state->snapshotsEnabled()) {
5936 m_state->snapshot()->vkGetRenderAreaGranularity(
5937 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, renderPass,
5938 pGranularity);
5939 }
5940 vkReadStream->clearPool();
5941 if (m_queueSubmitWithCommandsEnabled)
5942 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
5943 break;
5944 }
5945 case OP_vkCreateCommandPool: {
5946 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
5947 "VkDecoder vkCreateCommandPool");
5948 VkDevice device;
5949 const VkCommandPoolCreateInfo* pCreateInfo;
5950 const VkAllocationCallbacks* pAllocator;
5951 VkCommandPool* pCommandPool;
5952 // Begin global wrapped dispatchable handle unboxing for device;
5953 uint64_t cgen_var_0;
5954 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5955 *readStreamPtrPtr += 1 * 8;
5956 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
5957 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkCommandPoolCreateInfo));
5958 reservedunmarshal_VkCommandPoolCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5959 (VkCommandPoolCreateInfo*)(pCreateInfo),
5960 readStreamPtrPtr);
5961 // WARNING PTR CHECK
5962 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
5963 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
5964 *readStreamPtrPtr += 8;
5965 if (pAllocator) {
5966 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
5967 reservedunmarshal_VkAllocationCallbacks(
5968 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5969 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
5970 }
5971 // Begin manual dispatchable handle unboxing for pCommandPool;
5972 vkReadStream->unsetHandleMapping();
5973 vkReadStream->alloc((void**)&pCommandPool, sizeof(VkCommandPool));
5974 uint64_t cgen_var_2;
5975 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
5976 *readStreamPtrPtr += 8;
5977 *(VkCommandPool*)pCommandPool =
5978 (VkCommandPool)(VkCommandPool)((VkCommandPool)(*&cgen_var_2));
5979 if (pCreateInfo) {
5980 transform_tohost_VkCommandPoolCreateInfo(
5981 m_state, (VkCommandPoolCreateInfo*)(pCreateInfo));
5982 }
5983 if (pAllocator) {
5984 transform_tohost_VkAllocationCallbacks(m_state,
5985 (VkAllocationCallbacks*)(pAllocator));
5986 }
5987 if (m_logCalls) {
5988 fprintf(stderr,
5989 "stream %p: call vkCreateCommandPool 0x%llx 0x%llx 0x%llx 0x%llx \n",
5990 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
5991 (unsigned long long)pAllocator, (unsigned long long)pCommandPool);
5992 }
5993 VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
5994 vkCreateCommandPool_VkResult_return = m_state->on_vkCreateCommandPool(
5995 &m_pool, device, pCreateInfo, pAllocator, pCommandPool);
5996 if ((vkCreateCommandPool_VkResult_return) == VK_ERROR_DEVICE_LOST)
5997 m_state->on_DeviceLost();
5998 m_state->on_CheckOutOfMemory(vkCreateCommandPool_VkResult_return, opcode, context);
5999 vkStream->unsetHandleMapping();
6000 // Begin manual non dispatchable handle create for pCommandPool;
6001 vkStream->unsetHandleMapping();
6002 uint64_t cgen_var_3;
6003 static_assert(8 == sizeof(VkCommandPool),
6004 "handle map overwrite requires VkCommandPool to be 8 bytes long");
6005 vkStream->handleMapping()->mapHandles_VkCommandPool((VkCommandPool*)pCommandPool,
6006 1);
6007 vkStream->write((VkCommandPool*)pCommandPool, 8 * 1);
6008 // Begin manual non dispatchable handle create for pCommandPool;
6009 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
6010 vkStream->write(&vkCreateCommandPool_VkResult_return, sizeof(VkResult));
6011 vkStream->commitWrite();
6012 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6013 (uintptr_t)snapshotTraceBegin);
6014 size_t snapshotTraceBytes = vkReadStream->endTrace();
6015 if (m_state->snapshotsEnabled()) {
6016 m_state->snapshot()->vkCreateCommandPool(
6017 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
6018 vkCreateCommandPool_VkResult_return, device, pCreateInfo, pAllocator,
6019 pCommandPool);
6020 }
6021 vkReadStream->clearPool();
6022 if (m_queueSubmitWithCommandsEnabled)
6023 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6024 break;
6025 }
6026 case OP_vkDestroyCommandPool: {
6027 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6028 "VkDecoder vkDestroyCommandPool");
6029 VkDevice device;
6030 VkCommandPool commandPool;
6031 const VkAllocationCallbacks* pAllocator;
6032 // Begin global wrapped dispatchable handle unboxing for device;
6033 uint64_t cgen_var_0;
6034 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6035 *readStreamPtrPtr += 1 * 8;
6036 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
6037 // Begin manual non dispatchable handle destroy unboxing for commandPool;
6038 VkCommandPool boxed_commandPool_preserve;
6039 uint64_t cgen_var_1;
6040 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
6041 *readStreamPtrPtr += 1 * 8;
6042 *(VkCommandPool*)&commandPool =
6043 (VkCommandPool)(VkCommandPool)((VkCommandPool)(*&cgen_var_1));
6044 boxed_commandPool_preserve = commandPool;
6045 commandPool = try_unbox_VkCommandPool(commandPool);
6046 // WARNING PTR CHECK
6047 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
6048 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
6049 *readStreamPtrPtr += 8;
6050 if (pAllocator) {
6051 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
6052 reservedunmarshal_VkAllocationCallbacks(
6053 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6054 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
6055 }
6056 if (pAllocator) {
6057 transform_tohost_VkAllocationCallbacks(m_state,
6058 (VkAllocationCallbacks*)(pAllocator));
6059 }
6060 if (m_logCalls) {
6061 fprintf(stderr, "stream %p: call vkDestroyCommandPool 0x%llx 0x%llx 0x%llx \n",
6062 ioStream, (unsigned long long)device, (unsigned long long)commandPool,
6063 (unsigned long long)pAllocator);
6064 }
6065 m_state->on_vkDestroyCommandPool(&m_pool, device, commandPool, pAllocator);
6066 vkStream->unsetHandleMapping();
6067 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6068 (uintptr_t)snapshotTraceBegin);
6069 size_t snapshotTraceBytes = vkReadStream->endTrace();
6070 if (m_state->snapshotsEnabled()) {
6071 m_state->snapshot()->vkDestroyCommandPool(
6072 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
6073 boxed_commandPool_preserve, pAllocator);
6074 }
6075 delete_VkCommandPool(boxed_commandPool_preserve);
6076 vkReadStream->clearPool();
6077 if (m_queueSubmitWithCommandsEnabled)
6078 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6079 break;
6080 }
6081 case OP_vkResetCommandPool: {
6082 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6083 "VkDecoder vkResetCommandPool");
6084 VkDevice device;
6085 VkCommandPool commandPool;
6086 VkCommandPoolResetFlags flags;
6087 // Begin global wrapped dispatchable handle unboxing for device;
6088 uint64_t cgen_var_0;
6089 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6090 *readStreamPtrPtr += 1 * 8;
6091 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
6092 uint64_t cgen_var_1;
6093 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
6094 *readStreamPtrPtr += 1 * 8;
6095 *(VkCommandPool*)&commandPool =
6096 (VkCommandPool)unbox_VkCommandPool((VkCommandPool)(*&cgen_var_1));
6097 memcpy((VkCommandPoolResetFlags*)&flags, *readStreamPtrPtr,
6098 sizeof(VkCommandPoolResetFlags));
6099 *readStreamPtrPtr += sizeof(VkCommandPoolResetFlags);
6100 if (m_logCalls) {
6101 fprintf(stderr, "stream %p: call vkResetCommandPool 0x%llx 0x%llx 0x%llx \n",
6102 ioStream, (unsigned long long)device, (unsigned long long)commandPool,
6103 (unsigned long long)flags);
6104 }
6105 VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
6106 vkResetCommandPool_VkResult_return =
6107 m_state->on_vkResetCommandPool(&m_pool, device, commandPool, flags);
6108 if ((vkResetCommandPool_VkResult_return) == VK_ERROR_DEVICE_LOST)
6109 m_state->on_DeviceLost();
6110 m_state->on_CheckOutOfMemory(vkResetCommandPool_VkResult_return, opcode, context);
6111 vkStream->unsetHandleMapping();
6112 vkStream->write(&vkResetCommandPool_VkResult_return, sizeof(VkResult));
6113 vkStream->commitWrite();
6114 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6115 (uintptr_t)snapshotTraceBegin);
6116 size_t snapshotTraceBytes = vkReadStream->endTrace();
6117 if (m_state->snapshotsEnabled()) {
6118 m_state->snapshot()->vkResetCommandPool(
6119 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
6120 vkResetCommandPool_VkResult_return, device, commandPool, flags);
6121 }
6122 vkReadStream->clearPool();
6123 if (m_queueSubmitWithCommandsEnabled)
6124 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6125 break;
6126 }
6127 case OP_vkAllocateCommandBuffers: {
6128 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6129 "VkDecoder vkAllocateCommandBuffers");
6130 VkDevice device;
6131 const VkCommandBufferAllocateInfo* pAllocateInfo;
6132 VkCommandBuffer* pCommandBuffers;
6133 // Begin global wrapped dispatchable handle unboxing for device;
6134 uint64_t cgen_var_0;
6135 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6136 *readStreamPtrPtr += 1 * 8;
6137 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
6138 vkReadStream->alloc((void**)&pAllocateInfo,
6139 sizeof(const VkCommandBufferAllocateInfo));
6140 reservedunmarshal_VkCommandBufferAllocateInfo(
6141 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6142 (VkCommandBufferAllocateInfo*)(pAllocateInfo), readStreamPtrPtr);
6143 // Begin manual dispatchable handle unboxing for pCommandBuffers;
6144 vkReadStream->unsetHandleMapping();
6145 vkReadStream->alloc((void**)&pCommandBuffers,
6146 pAllocateInfo->commandBufferCount * sizeof(VkCommandBuffer));
6147 if (pAllocateInfo->commandBufferCount) {
6148 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
6149 *readStreamPtrPtr += 8 * pAllocateInfo->commandBufferCount;
6150 for (uint32_t k = 0; k < pAllocateInfo->commandBufferCount; ++k) {
6151 uint64_t tmpval;
6152 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
6153 *(((VkCommandBuffer*)pCommandBuffers) + k) =
6154 tmpval ? (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)tmpval)
6155 : VK_NULL_HANDLE;
6156 }
6157 }
6158 if (pAllocateInfo) {
6159 transform_tohost_VkCommandBufferAllocateInfo(
6160 m_state, (VkCommandBufferAllocateInfo*)(pAllocateInfo));
6161 }
6162 if (m_logCalls) {
6163 fprintf(stderr,
6164 "stream %p: call vkAllocateCommandBuffers 0x%llx 0x%llx 0x%llx \n",
6165 ioStream, (unsigned long long)device, (unsigned long long)pAllocateInfo,
6166 (unsigned long long)pCommandBuffers);
6167 }
6168 VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
6169 vkAllocateCommandBuffers_VkResult_return = m_state->on_vkAllocateCommandBuffers(
6170 &m_pool, device, pAllocateInfo, pCommandBuffers);
6171 if ((vkAllocateCommandBuffers_VkResult_return) == VK_ERROR_DEVICE_LOST)
6172 m_state->on_DeviceLost();
6173 m_state->on_CheckOutOfMemory(vkAllocateCommandBuffers_VkResult_return, opcode,
6174 context);
6175 vkStream->unsetHandleMapping();
6176 if (pAllocateInfo->commandBufferCount) {
6177 uint64_t* cgen_var_2;
6178 vkStream->alloc((void**)&cgen_var_2, pAllocateInfo->commandBufferCount * 8);
6179 static_assert(
6180 8 == sizeof(VkCommandBuffer),
6181 "handle map overwrite requires VkCommandBuffer to be 8 bytes long");
6182 vkStream->handleMapping()->mapHandles_VkCommandBuffer(
6183 (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
6184 vkStream->write((VkCommandBuffer*)pCommandBuffers,
6185 8 * pAllocateInfo->commandBufferCount);
6186 }
6187 vkStream->write(&vkAllocateCommandBuffers_VkResult_return, sizeof(VkResult));
6188 vkStream->commitWrite();
6189 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6190 (uintptr_t)snapshotTraceBegin);
6191 size_t snapshotTraceBytes = vkReadStream->endTrace();
6192 if (m_state->snapshotsEnabled()) {
6193 m_state->snapshot()->vkAllocateCommandBuffers(
6194 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
6195 vkAllocateCommandBuffers_VkResult_return, device, pAllocateInfo,
6196 pCommandBuffers);
6197 }
6198 vkReadStream->clearPool();
6199 if (m_queueSubmitWithCommandsEnabled)
6200 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6201 break;
6202 }
6203 case OP_vkFreeCommandBuffers: {
6204 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6205 "VkDecoder vkFreeCommandBuffers");
6206 VkDevice device;
6207 VkCommandPool commandPool;
6208 uint32_t commandBufferCount;
6209 const VkCommandBuffer* pCommandBuffers;
6210 // Begin global wrapped dispatchable handle unboxing for device;
6211 uint64_t cgen_var_0;
6212 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6213 *readStreamPtrPtr += 1 * 8;
6214 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
6215 uint64_t cgen_var_1;
6216 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
6217 *readStreamPtrPtr += 1 * 8;
6218 *(VkCommandPool*)&commandPool =
6219 (VkCommandPool)unbox_VkCommandPool((VkCommandPool)(*&cgen_var_1));
6220 memcpy((uint32_t*)&commandBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
6221 *readStreamPtrPtr += sizeof(uint32_t);
6222 // Begin manual non dispatchable handle destroy unboxing for pCommandBuffers;
6223 VkCommandBuffer* boxed_pCommandBuffers_preserve;
6224 vkReadStream->alloc((void**)&boxed_pCommandBuffers_preserve,
6225 ((commandBufferCount)) * sizeof(VkCommandBuffer));
6226 // WARNING PTR CHECK
6227 memcpy((VkCommandBuffer**)&pCommandBuffers, (*readStreamPtrPtr), 8);
6228 android::base::Stream::fromBe64((uint8_t*)&pCommandBuffers);
6229 *readStreamPtrPtr += 8;
6230 if (pCommandBuffers) {
6231 vkReadStream->alloc((void**)&pCommandBuffers,
6232 ((commandBufferCount)) * sizeof(const VkCommandBuffer));
6233 if (((commandBufferCount))) {
6234 uint8_t* cgen_var_2_0_ptr = (uint8_t*)(*readStreamPtrPtr);
6235 *readStreamPtrPtr += 8 * ((commandBufferCount));
6236 for (uint32_t k = 0; k < ((commandBufferCount)); ++k) {
6237 uint64_t tmpval;
6238 memcpy(&tmpval, cgen_var_2_0_ptr + k * 8, sizeof(uint64_t));
6239 *(((VkCommandBuffer*)pCommandBuffers) + k) =
6240 tmpval ? (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)tmpval)
6241 : VK_NULL_HANDLE;
6242 }
6243 }
6244 }
6245 for (uint32_t i = 0; i < ((commandBufferCount)); ++i) {
6246 boxed_pCommandBuffers_preserve[i] = pCommandBuffers[i];
6247 ((VkCommandBuffer*)(pCommandBuffers))[i] =
6248 try_unbox_VkCommandBuffer(pCommandBuffers[i]);
6249 }
6250 if (m_logCalls) {
6251 fprintf(stderr,
6252 "stream %p: call vkFreeCommandBuffers 0x%llx 0x%llx 0x%llx 0x%llx \n",
6253 ioStream, (unsigned long long)device, (unsigned long long)commandPool,
6254 (unsigned long long)commandBufferCount,
6255 (unsigned long long)pCommandBuffers);
6256 }
6257 m_state->on_vkFreeCommandBuffers(&m_pool, device, commandPool, commandBufferCount,
6258 pCommandBuffers);
6259 vkStream->unsetHandleMapping();
6260 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6261 (uintptr_t)snapshotTraceBegin);
6262 size_t snapshotTraceBytes = vkReadStream->endTrace();
6263 if (m_state->snapshotsEnabled()) {
6264 m_state->snapshot()->vkFreeCommandBuffers(
6265 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, commandPool,
6266 commandBufferCount, boxed_pCommandBuffers_preserve);
6267 }
6268 if (((commandBufferCount))) {
6269 for (uint32_t i = 0; i < ((commandBufferCount)); ++i) {
6270 delete_VkCommandBuffer(boxed_pCommandBuffers_preserve[i]);
6271 }
6272 }
6273 vkReadStream->clearPool();
6274 if (m_queueSubmitWithCommandsEnabled)
6275 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6276 break;
6277 }
6278 case OP_vkBeginCommandBuffer: {
6279 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6280 "VkDecoder vkBeginCommandBuffer");
6281 VkCommandBuffer commandBuffer;
6282 const VkCommandBufferBeginInfo* pBeginInfo;
6283 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
6284 uint64_t cgen_var_0;
6285 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6286 *readStreamPtrPtr += 1 * 8;
6287 *(VkCommandBuffer*)&commandBuffer =
6288 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6289 vkReadStream->alloc((void**)&pBeginInfo, sizeof(const VkCommandBufferBeginInfo));
6290 reservedunmarshal_VkCommandBufferBeginInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6291 (VkCommandBufferBeginInfo*)(pBeginInfo),
6292 readStreamPtrPtr);
6293 if (pBeginInfo) {
6294 transform_tohost_VkCommandBufferBeginInfo(
6295 m_state, (VkCommandBufferBeginInfo*)(pBeginInfo));
6296 }
6297 if (m_logCalls) {
6298 fprintf(stderr, "stream %p: call vkBeginCommandBuffer 0x%llx 0x%llx \n",
6299 ioStream, (unsigned long long)commandBuffer,
6300 (unsigned long long)pBeginInfo);
6301 }
6302 VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
6303 vkBeginCommandBuffer_VkResult_return =
6304 m_state->on_vkBeginCommandBuffer(&m_pool, commandBuffer, pBeginInfo, context);
6305 if ((vkBeginCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
6306 m_state->on_DeviceLost();
6307 m_state->on_CheckOutOfMemory(vkBeginCommandBuffer_VkResult_return, opcode, context);
6308 vkStream->unsetHandleMapping();
6309 vkStream->write(&vkBeginCommandBuffer_VkResult_return, sizeof(VkResult));
6310 vkStream->commitWrite();
6311 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6312 (uintptr_t)snapshotTraceBegin);
6313 size_t snapshotTraceBytes = vkReadStream->endTrace();
6314 if (m_state->snapshotsEnabled()) {
6315 m_state->snapshot()->vkBeginCommandBuffer(
6316 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
6317 vkBeginCommandBuffer_VkResult_return, commandBuffer, pBeginInfo);
6318 }
6319 vkReadStream->clearPool();
6320 if (m_queueSubmitWithCommandsEnabled)
6321 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6322 break;
6323 }
6324 case OP_vkEndCommandBuffer: {
6325 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6326 "VkDecoder vkEndCommandBuffer");
6327 VkCommandBuffer commandBuffer;
6328 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
6329 uint64_t cgen_var_0;
6330 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6331 *readStreamPtrPtr += 1 * 8;
6332 *(VkCommandBuffer*)&commandBuffer =
6333 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6334 if (m_logCalls) {
6335 fprintf(stderr, "stream %p: call vkEndCommandBuffer 0x%llx \n", ioStream,
6336 (unsigned long long)commandBuffer);
6337 }
6338 VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
6339 vkEndCommandBuffer_VkResult_return =
6340 m_state->on_vkEndCommandBuffer(&m_pool, commandBuffer, context);
6341 if ((vkEndCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
6342 m_state->on_DeviceLost();
6343 m_state->on_CheckOutOfMemory(vkEndCommandBuffer_VkResult_return, opcode, context);
6344 vkStream->unsetHandleMapping();
6345 vkStream->write(&vkEndCommandBuffer_VkResult_return, sizeof(VkResult));
6346 vkStream->commitWrite();
6347 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6348 (uintptr_t)snapshotTraceBegin);
6349 size_t snapshotTraceBytes = vkReadStream->endTrace();
6350 if (m_state->snapshotsEnabled()) {
6351 m_state->snapshot()->vkEndCommandBuffer(
6352 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
6353 vkEndCommandBuffer_VkResult_return, commandBuffer);
6354 }
6355 vkReadStream->clearPool();
6356 if (m_queueSubmitWithCommandsEnabled)
6357 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6358 break;
6359 }
6360 case OP_vkResetCommandBuffer: {
6361 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6362 "VkDecoder vkResetCommandBuffer");
6363 VkCommandBuffer commandBuffer;
6364 VkCommandBufferResetFlags flags;
6365 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
6366 uint64_t cgen_var_0;
6367 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6368 *readStreamPtrPtr += 1 * 8;
6369 *(VkCommandBuffer*)&commandBuffer =
6370 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6371 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr,
6372 sizeof(VkCommandBufferResetFlags));
6373 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
6374 if (m_logCalls) {
6375 fprintf(stderr, "stream %p: call vkResetCommandBuffer 0x%llx 0x%llx \n",
6376 ioStream, (unsigned long long)commandBuffer, (unsigned long long)flags);
6377 }
6378 VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
6379 vkResetCommandBuffer_VkResult_return =
6380 m_state->on_vkResetCommandBuffer(&m_pool, commandBuffer, flags);
6381 if ((vkResetCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
6382 m_state->on_DeviceLost();
6383 m_state->on_CheckOutOfMemory(vkResetCommandBuffer_VkResult_return, opcode, context);
6384 vkStream->unsetHandleMapping();
6385 vkStream->write(&vkResetCommandBuffer_VkResult_return, sizeof(VkResult));
6386 vkStream->commitWrite();
6387 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6388 (uintptr_t)snapshotTraceBegin);
6389 size_t snapshotTraceBytes = vkReadStream->endTrace();
6390 if (m_state->snapshotsEnabled()) {
6391 m_state->snapshot()->vkResetCommandBuffer(
6392 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
6393 vkResetCommandBuffer_VkResult_return, commandBuffer, flags);
6394 }
6395 vkReadStream->clearPool();
6396 if (m_queueSubmitWithCommandsEnabled)
6397 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6398 break;
6399 }
6400 case OP_vkCmdBindPipeline: {
6401 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6402 "VkDecoder vkCmdBindPipeline");
6403 VkCommandBuffer commandBuffer;
6404 VkPipelineBindPoint pipelineBindPoint;
6405 VkPipeline pipeline;
6406 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
6407 uint64_t cgen_var_0;
6408 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6409 *readStreamPtrPtr += 1 * 8;
6410 *(VkCommandBuffer*)&commandBuffer =
6411 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6412 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
6413 sizeof(VkPipelineBindPoint));
6414 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
6415 uint64_t cgen_var_1;
6416 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
6417 *readStreamPtrPtr += 1 * 8;
6418 *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_1));
6419 if (m_logCalls) {
6420 fprintf(stderr, "stream %p: call vkCmdBindPipeline 0x%llx 0x%llx 0x%llx \n",
6421 ioStream, (unsigned long long)commandBuffer,
6422 (unsigned long long)pipelineBindPoint, (unsigned long long)pipeline);
6423 }
6424 m_state->on_vkCmdBindPipeline(&m_pool, commandBuffer, pipelineBindPoint, pipeline);
6425 vkStream->unsetHandleMapping();
6426 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6427 (uintptr_t)snapshotTraceBegin);
6428 size_t snapshotTraceBytes = vkReadStream->endTrace();
6429 if (m_state->snapshotsEnabled()) {
6430 m_state->snapshot()->vkCmdBindPipeline(snapshotTraceBegin, snapshotTraceBytes,
6431 &m_pool, commandBuffer,
6432 pipelineBindPoint, pipeline);
6433 }
6434 vkReadStream->clearPool();
6435 if (m_queueSubmitWithCommandsEnabled)
6436 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6437 break;
6438 }
6439 case OP_vkCmdSetViewport: {
6440 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6441 "VkDecoder vkCmdSetViewport");
6442 VkCommandBuffer commandBuffer;
6443 uint32_t firstViewport;
6444 uint32_t viewportCount;
6445 const VkViewport* pViewports;
6446 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6447 uint64_t cgen_var_0;
6448 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6449 *readStreamPtrPtr += 1 * 8;
6450 *(VkCommandBuffer*)&commandBuffer =
6451 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6452 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6453 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6454 // End manual dispatchable handle unboxing for commandBuffer;
6455 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
6456 *readStreamPtrPtr += sizeof(uint32_t);
6457 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
6458 *readStreamPtrPtr += sizeof(uint32_t);
6459 vkReadStream->alloc((void**)&pViewports,
6460 ((viewportCount)) * sizeof(const VkViewport));
6461 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
6462 reservedunmarshal_VkViewport(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6463 (VkViewport*)(pViewports + i), readStreamPtrPtr);
6464 }
6465 if (pViewports) {
6466 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
6467 transform_tohost_VkViewport(m_state, (VkViewport*)(pViewports + i));
6468 }
6469 }
6470 if (m_logCalls) {
6471 fprintf(stderr,
6472 "stream %p: call vkCmdSetViewport 0x%llx 0x%llx 0x%llx 0x%llx \n",
6473 ioStream, (unsigned long long)commandBuffer,
6474 (unsigned long long)firstViewport, (unsigned long long)viewportCount,
6475 (unsigned long long)pViewports);
6476 }
6477 vk->vkCmdSetViewport(unboxed_commandBuffer, firstViewport, viewportCount,
6478 pViewports);
6479 vkStream->unsetHandleMapping();
6480 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6481 (uintptr_t)snapshotTraceBegin);
6482 size_t snapshotTraceBytes = vkReadStream->endTrace();
6483 if (m_state->snapshotsEnabled()) {
6484 m_state->snapshot()->vkCmdSetViewport(snapshotTraceBegin, snapshotTraceBytes,
6485 &m_pool, commandBuffer, firstViewport,
6486 viewportCount, pViewports);
6487 }
6488 vkReadStream->clearPool();
6489 if (m_queueSubmitWithCommandsEnabled)
6490 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6491 break;
6492 }
6493 case OP_vkCmdSetScissor: {
6494 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6495 "VkDecoder vkCmdSetScissor");
6496 VkCommandBuffer commandBuffer;
6497 uint32_t firstScissor;
6498 uint32_t scissorCount;
6499 const VkRect2D* pScissors;
6500 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6501 uint64_t cgen_var_0;
6502 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6503 *readStreamPtrPtr += 1 * 8;
6504 *(VkCommandBuffer*)&commandBuffer =
6505 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6506 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6507 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6508 // End manual dispatchable handle unboxing for commandBuffer;
6509 memcpy((uint32_t*)&firstScissor, *readStreamPtrPtr, sizeof(uint32_t));
6510 *readStreamPtrPtr += sizeof(uint32_t);
6511 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
6512 *readStreamPtrPtr += sizeof(uint32_t);
6513 vkReadStream->alloc((void**)&pScissors, ((scissorCount)) * sizeof(const VkRect2D));
6514 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
6515 reservedunmarshal_VkRect2D(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6516 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
6517 }
6518 if (pScissors) {
6519 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
6520 transform_tohost_VkRect2D(m_state, (VkRect2D*)(pScissors + i));
6521 }
6522 }
6523 if (m_logCalls) {
6524 fprintf(stderr,
6525 "stream %p: call vkCmdSetScissor 0x%llx 0x%llx 0x%llx 0x%llx \n",
6526 ioStream, (unsigned long long)commandBuffer,
6527 (unsigned long long)firstScissor, (unsigned long long)scissorCount,
6528 (unsigned long long)pScissors);
6529 }
6530 vk->vkCmdSetScissor(unboxed_commandBuffer, firstScissor, scissorCount, pScissors);
6531 vkStream->unsetHandleMapping();
6532 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6533 (uintptr_t)snapshotTraceBegin);
6534 size_t snapshotTraceBytes = vkReadStream->endTrace();
6535 if (m_state->snapshotsEnabled()) {
6536 m_state->snapshot()->vkCmdSetScissor(snapshotTraceBegin, snapshotTraceBytes,
6537 &m_pool, commandBuffer, firstScissor,
6538 scissorCount, pScissors);
6539 }
6540 vkReadStream->clearPool();
6541 if (m_queueSubmitWithCommandsEnabled)
6542 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6543 break;
6544 }
6545 case OP_vkCmdSetLineWidth: {
6546 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6547 "VkDecoder vkCmdSetLineWidth");
6548 VkCommandBuffer commandBuffer;
6549 float lineWidth;
6550 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6551 uint64_t cgen_var_0;
6552 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6553 *readStreamPtrPtr += 1 * 8;
6554 *(VkCommandBuffer*)&commandBuffer =
6555 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6556 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6557 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6558 // End manual dispatchable handle unboxing for commandBuffer;
6559 memcpy((float*)&lineWidth, *readStreamPtrPtr, sizeof(float));
6560 *readStreamPtrPtr += sizeof(float);
6561 if (m_logCalls) {
6562 fprintf(stderr, "stream %p: call vkCmdSetLineWidth 0x%llx 0x%llx \n", ioStream,
6563 (unsigned long long)commandBuffer, (unsigned long long)lineWidth);
6564 }
6565 vk->vkCmdSetLineWidth(unboxed_commandBuffer, lineWidth);
6566 vkStream->unsetHandleMapping();
6567 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6568 (uintptr_t)snapshotTraceBegin);
6569 size_t snapshotTraceBytes = vkReadStream->endTrace();
6570 if (m_state->snapshotsEnabled()) {
6571 m_state->snapshot()->vkCmdSetLineWidth(snapshotTraceBegin, snapshotTraceBytes,
6572 &m_pool, commandBuffer, lineWidth);
6573 }
6574 vkReadStream->clearPool();
6575 if (m_queueSubmitWithCommandsEnabled)
6576 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6577 break;
6578 }
6579 case OP_vkCmdSetDepthBias: {
6580 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6581 "VkDecoder vkCmdSetDepthBias");
6582 VkCommandBuffer commandBuffer;
6583 float depthBiasConstantFactor;
6584 float depthBiasClamp;
6585 float depthBiasSlopeFactor;
6586 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6587 uint64_t cgen_var_0;
6588 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6589 *readStreamPtrPtr += 1 * 8;
6590 *(VkCommandBuffer*)&commandBuffer =
6591 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6592 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6593 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6594 // End manual dispatchable handle unboxing for commandBuffer;
6595 memcpy((float*)&depthBiasConstantFactor, *readStreamPtrPtr, sizeof(float));
6596 *readStreamPtrPtr += sizeof(float);
6597 memcpy((float*)&depthBiasClamp, *readStreamPtrPtr, sizeof(float));
6598 *readStreamPtrPtr += sizeof(float);
6599 memcpy((float*)&depthBiasSlopeFactor, *readStreamPtrPtr, sizeof(float));
6600 *readStreamPtrPtr += sizeof(float);
6601 if (m_logCalls) {
6602 fprintf(stderr,
6603 "stream %p: call vkCmdSetDepthBias 0x%llx 0x%llx 0x%llx 0x%llx \n",
6604 ioStream, (unsigned long long)commandBuffer,
6605 (unsigned long long)depthBiasConstantFactor,
6606 (unsigned long long)depthBiasClamp,
6607 (unsigned long long)depthBiasSlopeFactor);
6608 }
6609 vk->vkCmdSetDepthBias(unboxed_commandBuffer, depthBiasConstantFactor,
6610 depthBiasClamp, depthBiasSlopeFactor);
6611 vkStream->unsetHandleMapping();
6612 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6613 (uintptr_t)snapshotTraceBegin);
6614 size_t snapshotTraceBytes = vkReadStream->endTrace();
6615 if (m_state->snapshotsEnabled()) {
6616 m_state->snapshot()->vkCmdSetDepthBias(
6617 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
6618 depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
6619 }
6620 vkReadStream->clearPool();
6621 if (m_queueSubmitWithCommandsEnabled)
6622 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6623 break;
6624 }
6625 case OP_vkCmdSetBlendConstants: {
6626 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6627 "VkDecoder vkCmdSetBlendConstants");
6628 VkCommandBuffer commandBuffer;
6629 float blendConstants[4];
6630 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6631 uint64_t cgen_var_0;
6632 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6633 *readStreamPtrPtr += 1 * 8;
6634 *(VkCommandBuffer*)&commandBuffer =
6635 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6636 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6637 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6638 // End manual dispatchable handle unboxing for commandBuffer;
6639 memcpy((float*)blendConstants, *readStreamPtrPtr, 4 * sizeof(const float));
6640 *readStreamPtrPtr += 4 * sizeof(const float);
6641 if (m_logCalls) {
6642 fprintf(stderr, "stream %p: call vkCmdSetBlendConstants 0x%llx 0x%llx \n",
6643 ioStream, (unsigned long long)commandBuffer,
6644 (unsigned long long)blendConstants);
6645 }
6646 vk->vkCmdSetBlendConstants(unboxed_commandBuffer, blendConstants);
6647 vkStream->unsetHandleMapping();
6648 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6649 (uintptr_t)snapshotTraceBegin);
6650 size_t snapshotTraceBytes = vkReadStream->endTrace();
6651 if (m_state->snapshotsEnabled()) {
6652 m_state->snapshot()->vkCmdSetBlendConstants(snapshotTraceBegin,
6653 snapshotTraceBytes, &m_pool,
6654 commandBuffer, blendConstants);
6655 }
6656 vkReadStream->clearPool();
6657 if (m_queueSubmitWithCommandsEnabled)
6658 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6659 break;
6660 }
6661 case OP_vkCmdSetDepthBounds: {
6662 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6663 "VkDecoder vkCmdSetDepthBounds");
6664 VkCommandBuffer commandBuffer;
6665 float minDepthBounds;
6666 float maxDepthBounds;
6667 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6668 uint64_t cgen_var_0;
6669 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6670 *readStreamPtrPtr += 1 * 8;
6671 *(VkCommandBuffer*)&commandBuffer =
6672 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6673 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6674 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6675 // End manual dispatchable handle unboxing for commandBuffer;
6676 memcpy((float*)&minDepthBounds, *readStreamPtrPtr, sizeof(float));
6677 *readStreamPtrPtr += sizeof(float);
6678 memcpy((float*)&maxDepthBounds, *readStreamPtrPtr, sizeof(float));
6679 *readStreamPtrPtr += sizeof(float);
6680 if (m_logCalls) {
6681 fprintf(stderr, "stream %p: call vkCmdSetDepthBounds 0x%llx 0x%llx 0x%llx \n",
6682 ioStream, (unsigned long long)commandBuffer,
6683 (unsigned long long)minDepthBounds, (unsigned long long)maxDepthBounds);
6684 }
6685 vk->vkCmdSetDepthBounds(unboxed_commandBuffer, minDepthBounds, maxDepthBounds);
6686 vkStream->unsetHandleMapping();
6687 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6688 (uintptr_t)snapshotTraceBegin);
6689 size_t snapshotTraceBytes = vkReadStream->endTrace();
6690 if (m_state->snapshotsEnabled()) {
6691 m_state->snapshot()->vkCmdSetDepthBounds(snapshotTraceBegin, snapshotTraceBytes,
6692 &m_pool, commandBuffer, minDepthBounds,
6693 maxDepthBounds);
6694 }
6695 vkReadStream->clearPool();
6696 if (m_queueSubmitWithCommandsEnabled)
6697 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6698 break;
6699 }
6700 case OP_vkCmdSetStencilCompareMask: {
6701 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6702 "VkDecoder vkCmdSetStencilCompareMask");
6703 VkCommandBuffer commandBuffer;
6704 VkStencilFaceFlags faceMask;
6705 uint32_t compareMask;
6706 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6707 uint64_t cgen_var_0;
6708 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6709 *readStreamPtrPtr += 1 * 8;
6710 *(VkCommandBuffer*)&commandBuffer =
6711 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6712 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6713 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6714 // End manual dispatchable handle unboxing for commandBuffer;
6715 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
6716 sizeof(VkStencilFaceFlags));
6717 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
6718 memcpy((uint32_t*)&compareMask, *readStreamPtrPtr, sizeof(uint32_t));
6719 *readStreamPtrPtr += sizeof(uint32_t);
6720 if (m_logCalls) {
6721 fprintf(stderr,
6722 "stream %p: call vkCmdSetStencilCompareMask 0x%llx 0x%llx 0x%llx \n",
6723 ioStream, (unsigned long long)commandBuffer,
6724 (unsigned long long)faceMask, (unsigned long long)compareMask);
6725 }
6726 vk->vkCmdSetStencilCompareMask(unboxed_commandBuffer, faceMask, compareMask);
6727 vkStream->unsetHandleMapping();
6728 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6729 (uintptr_t)snapshotTraceBegin);
6730 size_t snapshotTraceBytes = vkReadStream->endTrace();
6731 if (m_state->snapshotsEnabled()) {
6732 m_state->snapshot()->vkCmdSetStencilCompareMask(
6733 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, faceMask,
6734 compareMask);
6735 }
6736 vkReadStream->clearPool();
6737 if (m_queueSubmitWithCommandsEnabled)
6738 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6739 break;
6740 }
6741 case OP_vkCmdSetStencilWriteMask: {
6742 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6743 "VkDecoder vkCmdSetStencilWriteMask");
6744 VkCommandBuffer commandBuffer;
6745 VkStencilFaceFlags faceMask;
6746 uint32_t writeMask;
6747 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6748 uint64_t cgen_var_0;
6749 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6750 *readStreamPtrPtr += 1 * 8;
6751 *(VkCommandBuffer*)&commandBuffer =
6752 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6753 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6754 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6755 // End manual dispatchable handle unboxing for commandBuffer;
6756 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
6757 sizeof(VkStencilFaceFlags));
6758 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
6759 memcpy((uint32_t*)&writeMask, *readStreamPtrPtr, sizeof(uint32_t));
6760 *readStreamPtrPtr += sizeof(uint32_t);
6761 if (m_logCalls) {
6762 fprintf(stderr,
6763 "stream %p: call vkCmdSetStencilWriteMask 0x%llx 0x%llx 0x%llx \n",
6764 ioStream, (unsigned long long)commandBuffer,
6765 (unsigned long long)faceMask, (unsigned long long)writeMask);
6766 }
6767 vk->vkCmdSetStencilWriteMask(unboxed_commandBuffer, faceMask, writeMask);
6768 vkStream->unsetHandleMapping();
6769 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6770 (uintptr_t)snapshotTraceBegin);
6771 size_t snapshotTraceBytes = vkReadStream->endTrace();
6772 if (m_state->snapshotsEnabled()) {
6773 m_state->snapshot()->vkCmdSetStencilWriteMask(
6774 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, faceMask,
6775 writeMask);
6776 }
6777 vkReadStream->clearPool();
6778 if (m_queueSubmitWithCommandsEnabled)
6779 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6780 break;
6781 }
6782 case OP_vkCmdSetStencilReference: {
6783 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6784 "VkDecoder vkCmdSetStencilReference");
6785 VkCommandBuffer commandBuffer;
6786 VkStencilFaceFlags faceMask;
6787 uint32_t reference;
6788 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6789 uint64_t cgen_var_0;
6790 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6791 *readStreamPtrPtr += 1 * 8;
6792 *(VkCommandBuffer*)&commandBuffer =
6793 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6794 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6795 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6796 // End manual dispatchable handle unboxing for commandBuffer;
6797 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
6798 sizeof(VkStencilFaceFlags));
6799 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
6800 memcpy((uint32_t*)&reference, *readStreamPtrPtr, sizeof(uint32_t));
6801 *readStreamPtrPtr += sizeof(uint32_t);
6802 if (m_logCalls) {
6803 fprintf(stderr,
6804 "stream %p: call vkCmdSetStencilReference 0x%llx 0x%llx 0x%llx \n",
6805 ioStream, (unsigned long long)commandBuffer,
6806 (unsigned long long)faceMask, (unsigned long long)reference);
6807 }
6808 vk->vkCmdSetStencilReference(unboxed_commandBuffer, faceMask, reference);
6809 vkStream->unsetHandleMapping();
6810 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6811 (uintptr_t)snapshotTraceBegin);
6812 size_t snapshotTraceBytes = vkReadStream->endTrace();
6813 if (m_state->snapshotsEnabled()) {
6814 m_state->snapshot()->vkCmdSetStencilReference(
6815 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, faceMask,
6816 reference);
6817 }
6818 vkReadStream->clearPool();
6819 if (m_queueSubmitWithCommandsEnabled)
6820 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6821 break;
6822 }
6823 case OP_vkCmdBindDescriptorSets: {
6824 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6825 "VkDecoder vkCmdBindDescriptorSets");
6826 VkCommandBuffer commandBuffer;
6827 VkPipelineBindPoint pipelineBindPoint;
6828 VkPipelineLayout layout;
6829 uint32_t firstSet;
6830 uint32_t descriptorSetCount;
6831 const VkDescriptorSet* pDescriptorSets;
6832 uint32_t dynamicOffsetCount;
6833 const uint32_t* pDynamicOffsets;
6834 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
6835 uint64_t cgen_var_0;
6836 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6837 *readStreamPtrPtr += 1 * 8;
6838 *(VkCommandBuffer*)&commandBuffer =
6839 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6840 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
6841 sizeof(VkPipelineBindPoint));
6842 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
6843 uint64_t cgen_var_1;
6844 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
6845 *readStreamPtrPtr += 1 * 8;
6846 *(VkPipelineLayout*)&layout =
6847 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_1));
6848 memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
6849 *readStreamPtrPtr += sizeof(uint32_t);
6850 memcpy((uint32_t*)&descriptorSetCount, *readStreamPtrPtr, sizeof(uint32_t));
6851 *readStreamPtrPtr += sizeof(uint32_t);
6852 vkReadStream->alloc((void**)&pDescriptorSets,
6853 ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
6854 if (((descriptorSetCount))) {
6855 uint8_t* cgen_var_2_ptr = (uint8_t*)(*readStreamPtrPtr);
6856 *readStreamPtrPtr += 8 * ((descriptorSetCount));
6857 for (uint32_t k = 0; k < ((descriptorSetCount)); ++k) {
6858 uint64_t tmpval;
6859 memcpy(&tmpval, cgen_var_2_ptr + k * 8, sizeof(uint64_t));
6860 *(((VkDescriptorSet*)pDescriptorSets) + k) =
6861 tmpval ? (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)tmpval)
6862 : VK_NULL_HANDLE;
6863 }
6864 }
6865 memcpy((uint32_t*)&dynamicOffsetCount, *readStreamPtrPtr, sizeof(uint32_t));
6866 *readStreamPtrPtr += sizeof(uint32_t);
6867 vkReadStream->alloc((void**)&pDynamicOffsets,
6868 ((dynamicOffsetCount)) * sizeof(const uint32_t));
6869 memcpy((uint32_t*)pDynamicOffsets, *readStreamPtrPtr,
6870 ((dynamicOffsetCount)) * sizeof(const uint32_t));
6871 *readStreamPtrPtr += ((dynamicOffsetCount)) * sizeof(const uint32_t);
6872 if (m_logCalls) {
6873 fprintf(stderr,
6874 "stream %p: call vkCmdBindDescriptorSets 0x%llx 0x%llx 0x%llx 0x%llx "
6875 "0x%llx 0x%llx 0x%llx 0x%llx \n",
6876 ioStream, (unsigned long long)commandBuffer,
6877 (unsigned long long)pipelineBindPoint, (unsigned long long)layout,
6878 (unsigned long long)firstSet, (unsigned long long)descriptorSetCount,
6879 (unsigned long long)pDescriptorSets,
6880 (unsigned long long)dynamicOffsetCount,
6881 (unsigned long long)pDynamicOffsets);
6882 }
6883 m_state->on_vkCmdBindDescriptorSets(
6884 &m_pool, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount,
6885 pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
6886 vkStream->unsetHandleMapping();
6887 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6888 (uintptr_t)snapshotTraceBegin);
6889 size_t snapshotTraceBytes = vkReadStream->endTrace();
6890 if (m_state->snapshotsEnabled()) {
6891 m_state->snapshot()->vkCmdBindDescriptorSets(
6892 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
6893 pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets,
6894 dynamicOffsetCount, pDynamicOffsets);
6895 }
6896 vkReadStream->clearPool();
6897 if (m_queueSubmitWithCommandsEnabled)
6898 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6899 break;
6900 }
6901 case OP_vkCmdBindIndexBuffer: {
6902 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6903 "VkDecoder vkCmdBindIndexBuffer");
6904 VkCommandBuffer commandBuffer;
6905 VkBuffer buffer;
6906 VkDeviceSize offset;
6907 VkIndexType indexType;
6908 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6909 uint64_t cgen_var_0;
6910 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6911 *readStreamPtrPtr += 1 * 8;
6912 *(VkCommandBuffer*)&commandBuffer =
6913 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6914 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6915 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6916 // End manual dispatchable handle unboxing for commandBuffer;
6917 uint64_t cgen_var_1;
6918 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
6919 *readStreamPtrPtr += 1 * 8;
6920 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
6921 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
6922 *readStreamPtrPtr += sizeof(VkDeviceSize);
6923 memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
6924 *readStreamPtrPtr += sizeof(VkIndexType);
6925 if (m_logCalls) {
6926 fprintf(stderr,
6927 "stream %p: call vkCmdBindIndexBuffer 0x%llx 0x%llx 0x%llx 0x%llx \n",
6928 ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
6929 (unsigned long long)offset, (unsigned long long)indexType);
6930 }
6931 vk->vkCmdBindIndexBuffer(unboxed_commandBuffer, buffer, offset, indexType);
6932 vkStream->unsetHandleMapping();
6933 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6934 (uintptr_t)snapshotTraceBegin);
6935 size_t snapshotTraceBytes = vkReadStream->endTrace();
6936 if (m_state->snapshotsEnabled()) {
6937 m_state->snapshot()->vkCmdBindIndexBuffer(
6938 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, buffer,
6939 offset, indexType);
6940 }
6941 vkReadStream->clearPool();
6942 if (m_queueSubmitWithCommandsEnabled)
6943 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
6944 break;
6945 }
6946 case OP_vkCmdBindVertexBuffers: {
6947 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
6948 "VkDecoder vkCmdBindVertexBuffers");
6949 VkCommandBuffer commandBuffer;
6950 uint32_t firstBinding;
6951 uint32_t bindingCount;
6952 const VkBuffer* pBuffers;
6953 const VkDeviceSize* pOffsets;
6954 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
6955 uint64_t cgen_var_0;
6956 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6957 *readStreamPtrPtr += 1 * 8;
6958 *(VkCommandBuffer*)&commandBuffer =
6959 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
6960 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
6961 auto vk = dispatch_VkCommandBuffer(commandBuffer);
6962 // End manual dispatchable handle unboxing for commandBuffer;
6963 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
6964 *readStreamPtrPtr += sizeof(uint32_t);
6965 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
6966 *readStreamPtrPtr += sizeof(uint32_t);
6967 vkReadStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
6968 if (((bindingCount))) {
6969 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
6970 *readStreamPtrPtr += 8 * ((bindingCount));
6971 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
6972 uint64_t tmpval;
6973 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
6974 *(((VkBuffer*)pBuffers) + k) =
6975 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval) : VK_NULL_HANDLE;
6976 }
6977 }
6978 vkReadStream->alloc((void**)&pOffsets,
6979 ((bindingCount)) * sizeof(const VkDeviceSize));
6980 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
6981 ((bindingCount)) * sizeof(const VkDeviceSize));
6982 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
6983 if (m_logCalls) {
6984 fprintf(stderr,
6985 "stream %p: call vkCmdBindVertexBuffers 0x%llx 0x%llx 0x%llx 0x%llx "
6986 "0x%llx \n",
6987 ioStream, (unsigned long long)commandBuffer,
6988 (unsigned long long)firstBinding, (unsigned long long)bindingCount,
6989 (unsigned long long)pBuffers, (unsigned long long)pOffsets);
6990 }
6991 vk->vkCmdBindVertexBuffers(unboxed_commandBuffer, firstBinding, bindingCount,
6992 pBuffers, pOffsets);
6993 vkStream->unsetHandleMapping();
6994 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
6995 (uintptr_t)snapshotTraceBegin);
6996 size_t snapshotTraceBytes = vkReadStream->endTrace();
6997 if (m_state->snapshotsEnabled()) {
6998 m_state->snapshot()->vkCmdBindVertexBuffers(
6999 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
7000 firstBinding, bindingCount, pBuffers, pOffsets);
7001 }
7002 vkReadStream->clearPool();
7003 if (m_queueSubmitWithCommandsEnabled)
7004 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7005 break;
7006 }
7007 case OP_vkCmdDraw: {
7008 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCmdDraw");
7009 VkCommandBuffer commandBuffer;
7010 uint32_t vertexCount;
7011 uint32_t instanceCount;
7012 uint32_t firstVertex;
7013 uint32_t firstInstance;
7014 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7015 uint64_t cgen_var_0;
7016 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7017 *readStreamPtrPtr += 1 * 8;
7018 *(VkCommandBuffer*)&commandBuffer =
7019 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7020 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7021 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7022 // End manual dispatchable handle unboxing for commandBuffer;
7023 memcpy((uint32_t*)&vertexCount, *readStreamPtrPtr, sizeof(uint32_t));
7024 *readStreamPtrPtr += sizeof(uint32_t);
7025 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
7026 *readStreamPtrPtr += sizeof(uint32_t);
7027 memcpy((uint32_t*)&firstVertex, *readStreamPtrPtr, sizeof(uint32_t));
7028 *readStreamPtrPtr += sizeof(uint32_t);
7029 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
7030 *readStreamPtrPtr += sizeof(uint32_t);
7031 if (m_logCalls) {
7032 fprintf(stderr,
7033 "stream %p: call vkCmdDraw 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
7034 ioStream, (unsigned long long)commandBuffer,
7035 (unsigned long long)vertexCount, (unsigned long long)instanceCount,
7036 (unsigned long long)firstVertex, (unsigned long long)firstInstance);
7037 }
7038 vk->vkCmdDraw(unboxed_commandBuffer, vertexCount, instanceCount, firstVertex,
7039 firstInstance);
7040 vkStream->unsetHandleMapping();
7041 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7042 (uintptr_t)snapshotTraceBegin);
7043 size_t snapshotTraceBytes = vkReadStream->endTrace();
7044 if (m_state->snapshotsEnabled()) {
7045 m_state->snapshot()->vkCmdDraw(snapshotTraceBegin, snapshotTraceBytes, &m_pool,
7046 commandBuffer, vertexCount, instanceCount,
7047 firstVertex, firstInstance);
7048 }
7049 vkReadStream->clearPool();
7050 if (m_queueSubmitWithCommandsEnabled)
7051 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7052 break;
7053 }
7054 case OP_vkCmdDrawIndexed: {
7055 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7056 "VkDecoder vkCmdDrawIndexed");
7057 VkCommandBuffer commandBuffer;
7058 uint32_t indexCount;
7059 uint32_t instanceCount;
7060 uint32_t firstIndex;
7061 int32_t vertexOffset;
7062 uint32_t firstInstance;
7063 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7064 uint64_t cgen_var_0;
7065 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7066 *readStreamPtrPtr += 1 * 8;
7067 *(VkCommandBuffer*)&commandBuffer =
7068 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7069 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7070 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7071 // End manual dispatchable handle unboxing for commandBuffer;
7072 memcpy((uint32_t*)&indexCount, *readStreamPtrPtr, sizeof(uint32_t));
7073 *readStreamPtrPtr += sizeof(uint32_t);
7074 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
7075 *readStreamPtrPtr += sizeof(uint32_t);
7076 memcpy((uint32_t*)&firstIndex, *readStreamPtrPtr, sizeof(uint32_t));
7077 *readStreamPtrPtr += sizeof(uint32_t);
7078 memcpy((int32_t*)&vertexOffset, *readStreamPtrPtr, sizeof(int32_t));
7079 *readStreamPtrPtr += sizeof(int32_t);
7080 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
7081 *readStreamPtrPtr += sizeof(uint32_t);
7082 if (m_logCalls) {
7083 fprintf(stderr,
7084 "stream %p: call vkCmdDrawIndexed 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
7085 "0x%llx \n",
7086 ioStream, (unsigned long long)commandBuffer,
7087 (unsigned long long)indexCount, (unsigned long long)instanceCount,
7088 (unsigned long long)firstIndex, (unsigned long long)vertexOffset,
7089 (unsigned long long)firstInstance);
7090 }
7091 vk->vkCmdDrawIndexed(unboxed_commandBuffer, indexCount, instanceCount, firstIndex,
7092 vertexOffset, firstInstance);
7093 vkStream->unsetHandleMapping();
7094 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7095 (uintptr_t)snapshotTraceBegin);
7096 size_t snapshotTraceBytes = vkReadStream->endTrace();
7097 if (m_state->snapshotsEnabled()) {
7098 m_state->snapshot()->vkCmdDrawIndexed(
7099 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, indexCount,
7100 instanceCount, firstIndex, vertexOffset, firstInstance);
7101 }
7102 vkReadStream->clearPool();
7103 if (m_queueSubmitWithCommandsEnabled)
7104 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7105 break;
7106 }
7107 case OP_vkCmdDrawIndirect: {
7108 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7109 "VkDecoder vkCmdDrawIndirect");
7110 VkCommandBuffer commandBuffer;
7111 VkBuffer buffer;
7112 VkDeviceSize offset;
7113 uint32_t drawCount;
7114 uint32_t stride;
7115 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7116 uint64_t cgen_var_0;
7117 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7118 *readStreamPtrPtr += 1 * 8;
7119 *(VkCommandBuffer*)&commandBuffer =
7120 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7121 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7122 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7123 // End manual dispatchable handle unboxing for commandBuffer;
7124 uint64_t cgen_var_1;
7125 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7126 *readStreamPtrPtr += 1 * 8;
7127 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
7128 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
7129 *readStreamPtrPtr += sizeof(VkDeviceSize);
7130 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
7131 *readStreamPtrPtr += sizeof(uint32_t);
7132 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
7133 *readStreamPtrPtr += sizeof(uint32_t);
7134 if (m_logCalls) {
7135 fprintf(
7136 stderr,
7137 "stream %p: call vkCmdDrawIndirect 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
7138 ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
7139 (unsigned long long)offset, (unsigned long long)drawCount,
7140 (unsigned long long)stride);
7141 }
7142 vk->vkCmdDrawIndirect(unboxed_commandBuffer, buffer, offset, drawCount, stride);
7143 vkStream->unsetHandleMapping();
7144 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7145 (uintptr_t)snapshotTraceBegin);
7146 size_t snapshotTraceBytes = vkReadStream->endTrace();
7147 if (m_state->snapshotsEnabled()) {
7148 m_state->snapshot()->vkCmdDrawIndirect(snapshotTraceBegin, snapshotTraceBytes,
7149 &m_pool, commandBuffer, buffer, offset,
7150 drawCount, stride);
7151 }
7152 vkReadStream->clearPool();
7153 if (m_queueSubmitWithCommandsEnabled)
7154 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7155 break;
7156 }
7157 case OP_vkCmdDrawIndexedIndirect: {
7158 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7159 "VkDecoder vkCmdDrawIndexedIndirect");
7160 VkCommandBuffer commandBuffer;
7161 VkBuffer buffer;
7162 VkDeviceSize offset;
7163 uint32_t drawCount;
7164 uint32_t stride;
7165 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7166 uint64_t cgen_var_0;
7167 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7168 *readStreamPtrPtr += 1 * 8;
7169 *(VkCommandBuffer*)&commandBuffer =
7170 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7171 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7172 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7173 // End manual dispatchable handle unboxing for commandBuffer;
7174 uint64_t cgen_var_1;
7175 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7176 *readStreamPtrPtr += 1 * 8;
7177 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
7178 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
7179 *readStreamPtrPtr += sizeof(VkDeviceSize);
7180 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
7181 *readStreamPtrPtr += sizeof(uint32_t);
7182 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
7183 *readStreamPtrPtr += sizeof(uint32_t);
7184 if (m_logCalls) {
7185 fprintf(stderr,
7186 "stream %p: call vkCmdDrawIndexedIndirect 0x%llx 0x%llx 0x%llx 0x%llx "
7187 "0x%llx \n",
7188 ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
7189 (unsigned long long)offset, (unsigned long long)drawCount,
7190 (unsigned long long)stride);
7191 }
7192 vk->vkCmdDrawIndexedIndirect(unboxed_commandBuffer, buffer, offset, drawCount,
7193 stride);
7194 vkStream->unsetHandleMapping();
7195 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7196 (uintptr_t)snapshotTraceBegin);
7197 size_t snapshotTraceBytes = vkReadStream->endTrace();
7198 if (m_state->snapshotsEnabled()) {
7199 m_state->snapshot()->vkCmdDrawIndexedIndirect(
7200 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, buffer,
7201 offset, drawCount, stride);
7202 }
7203 vkReadStream->clearPool();
7204 if (m_queueSubmitWithCommandsEnabled)
7205 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7206 break;
7207 }
7208 case OP_vkCmdDispatch: {
7209 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCmdDispatch");
7210 VkCommandBuffer commandBuffer;
7211 uint32_t groupCountX;
7212 uint32_t groupCountY;
7213 uint32_t groupCountZ;
7214 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7215 uint64_t cgen_var_0;
7216 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7217 *readStreamPtrPtr += 1 * 8;
7218 *(VkCommandBuffer*)&commandBuffer =
7219 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7220 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7221 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7222 // End manual dispatchable handle unboxing for commandBuffer;
7223 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
7224 *readStreamPtrPtr += sizeof(uint32_t);
7225 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
7226 *readStreamPtrPtr += sizeof(uint32_t);
7227 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
7228 *readStreamPtrPtr += sizeof(uint32_t);
7229 if (m_logCalls) {
7230 fprintf(stderr, "stream %p: call vkCmdDispatch 0x%llx 0x%llx 0x%llx 0x%llx \n",
7231 ioStream, (unsigned long long)commandBuffer,
7232 (unsigned long long)groupCountX, (unsigned long long)groupCountY,
7233 (unsigned long long)groupCountZ);
7234 }
7235 vk->vkCmdDispatch(unboxed_commandBuffer, groupCountX, groupCountY, groupCountZ);
7236 vkStream->unsetHandleMapping();
7237 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7238 (uintptr_t)snapshotTraceBegin);
7239 size_t snapshotTraceBytes = vkReadStream->endTrace();
7240 if (m_state->snapshotsEnabled()) {
7241 m_state->snapshot()->vkCmdDispatch(snapshotTraceBegin, snapshotTraceBytes,
7242 &m_pool, commandBuffer, groupCountX,
7243 groupCountY, groupCountZ);
7244 }
7245 vkReadStream->clearPool();
7246 if (m_queueSubmitWithCommandsEnabled)
7247 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7248 break;
7249 }
7250 case OP_vkCmdDispatchIndirect: {
7251 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7252 "VkDecoder vkCmdDispatchIndirect");
7253 VkCommandBuffer commandBuffer;
7254 VkBuffer buffer;
7255 VkDeviceSize offset;
7256 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7257 uint64_t cgen_var_0;
7258 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7259 *readStreamPtrPtr += 1 * 8;
7260 *(VkCommandBuffer*)&commandBuffer =
7261 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7262 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7263 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7264 // End manual dispatchable handle unboxing for commandBuffer;
7265 uint64_t cgen_var_1;
7266 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7267 *readStreamPtrPtr += 1 * 8;
7268 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
7269 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
7270 *readStreamPtrPtr += sizeof(VkDeviceSize);
7271 if (m_logCalls) {
7272 fprintf(stderr, "stream %p: call vkCmdDispatchIndirect 0x%llx 0x%llx 0x%llx \n",
7273 ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
7274 (unsigned long long)offset);
7275 }
7276 vk->vkCmdDispatchIndirect(unboxed_commandBuffer, buffer, offset);
7277 vkStream->unsetHandleMapping();
7278 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7279 (uintptr_t)snapshotTraceBegin);
7280 size_t snapshotTraceBytes = vkReadStream->endTrace();
7281 if (m_state->snapshotsEnabled()) {
7282 m_state->snapshot()->vkCmdDispatchIndirect(snapshotTraceBegin,
7283 snapshotTraceBytes, &m_pool,
7284 commandBuffer, buffer, offset);
7285 }
7286 vkReadStream->clearPool();
7287 if (m_queueSubmitWithCommandsEnabled)
7288 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7289 break;
7290 }
7291 case OP_vkCmdCopyBuffer: {
7292 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7293 "VkDecoder vkCmdCopyBuffer");
7294 VkCommandBuffer commandBuffer;
7295 VkBuffer srcBuffer;
7296 VkBuffer dstBuffer;
7297 uint32_t regionCount;
7298 const VkBufferCopy* pRegions;
7299 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7300 uint64_t cgen_var_0;
7301 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7302 *readStreamPtrPtr += 1 * 8;
7303 *(VkCommandBuffer*)&commandBuffer =
7304 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7305 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7306 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7307 // End manual dispatchable handle unboxing for commandBuffer;
7308 uint64_t cgen_var_1;
7309 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7310 *readStreamPtrPtr += 1 * 8;
7311 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
7312 uint64_t cgen_var_2;
7313 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
7314 *readStreamPtrPtr += 1 * 8;
7315 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_2));
7316 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
7317 *readStreamPtrPtr += sizeof(uint32_t);
7318 vkReadStream->alloc((void**)&pRegions,
7319 ((regionCount)) * sizeof(const VkBufferCopy));
7320 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7321 reservedunmarshal_VkBufferCopy(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7322 (VkBufferCopy*)(pRegions + i), readStreamPtrPtr);
7323 }
7324 if (pRegions) {
7325 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7326 transform_tohost_VkBufferCopy(m_state, (VkBufferCopy*)(pRegions + i));
7327 }
7328 }
7329 if (m_logCalls) {
7330 fprintf(stderr,
7331 "stream %p: call vkCmdCopyBuffer 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
7332 ioStream, (unsigned long long)commandBuffer,
7333 (unsigned long long)srcBuffer, (unsigned long long)dstBuffer,
7334 (unsigned long long)regionCount, (unsigned long long)pRegions);
7335 }
7336 vk->vkCmdCopyBuffer(unboxed_commandBuffer, srcBuffer, dstBuffer, regionCount,
7337 pRegions);
7338 vkStream->unsetHandleMapping();
7339 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7340 (uintptr_t)snapshotTraceBegin);
7341 size_t snapshotTraceBytes = vkReadStream->endTrace();
7342 if (m_state->snapshotsEnabled()) {
7343 m_state->snapshot()->vkCmdCopyBuffer(snapshotTraceBegin, snapshotTraceBytes,
7344 &m_pool, commandBuffer, srcBuffer,
7345 dstBuffer, regionCount, pRegions);
7346 }
7347 vkReadStream->clearPool();
7348 if (m_queueSubmitWithCommandsEnabled)
7349 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7350 break;
7351 }
7352 case OP_vkCmdCopyImage: {
7353 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCmdCopyImage");
7354 VkCommandBuffer commandBuffer;
7355 VkImage srcImage;
7356 VkImageLayout srcImageLayout;
7357 VkImage dstImage;
7358 VkImageLayout dstImageLayout;
7359 uint32_t regionCount;
7360 const VkImageCopy* pRegions;
7361 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
7362 uint64_t cgen_var_0;
7363 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7364 *readStreamPtrPtr += 1 * 8;
7365 *(VkCommandBuffer*)&commandBuffer =
7366 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7367 uint64_t cgen_var_1;
7368 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7369 *readStreamPtrPtr += 1 * 8;
7370 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
7371 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7372 *readStreamPtrPtr += sizeof(VkImageLayout);
7373 uint64_t cgen_var_2;
7374 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
7375 *readStreamPtrPtr += 1 * 8;
7376 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_2));
7377 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7378 *readStreamPtrPtr += sizeof(VkImageLayout);
7379 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
7380 *readStreamPtrPtr += sizeof(uint32_t);
7381 vkReadStream->alloc((void**)&pRegions, ((regionCount)) * sizeof(const VkImageCopy));
7382 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7383 reservedunmarshal_VkImageCopy(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7384 (VkImageCopy*)(pRegions + i), readStreamPtrPtr);
7385 }
7386 if (pRegions) {
7387 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7388 transform_tohost_VkImageCopy(m_state, (VkImageCopy*)(pRegions + i));
7389 }
7390 }
7391 if (m_logCalls) {
7392 fprintf(stderr,
7393 "stream %p: call vkCmdCopyImage 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
7394 "0x%llx 0x%llx \n",
7395 ioStream, (unsigned long long)commandBuffer,
7396 (unsigned long long)srcImage, (unsigned long long)srcImageLayout,
7397 (unsigned long long)dstImage, (unsigned long long)dstImageLayout,
7398 (unsigned long long)regionCount, (unsigned long long)pRegions);
7399 }
7400 m_state->on_vkCmdCopyImage(&m_pool, commandBuffer, srcImage, srcImageLayout,
7401 dstImage, dstImageLayout, regionCount, pRegions);
7402 vkStream->unsetHandleMapping();
7403 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7404 (uintptr_t)snapshotTraceBegin);
7405 size_t snapshotTraceBytes = vkReadStream->endTrace();
7406 if (m_state->snapshotsEnabled()) {
7407 m_state->snapshot()->vkCmdCopyImage(
7408 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, srcImage,
7409 srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
7410 }
7411 vkReadStream->clearPool();
7412 if (m_queueSubmitWithCommandsEnabled)
7413 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7414 break;
7415 }
7416 case OP_vkCmdBlitImage: {
7417 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCmdBlitImage");
7418 VkCommandBuffer commandBuffer;
7419 VkImage srcImage;
7420 VkImageLayout srcImageLayout;
7421 VkImage dstImage;
7422 VkImageLayout dstImageLayout;
7423 uint32_t regionCount;
7424 const VkImageBlit* pRegions;
7425 VkFilter filter;
7426 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7427 uint64_t cgen_var_0;
7428 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7429 *readStreamPtrPtr += 1 * 8;
7430 *(VkCommandBuffer*)&commandBuffer =
7431 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7432 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7433 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7434 // End manual dispatchable handle unboxing for commandBuffer;
7435 uint64_t cgen_var_1;
7436 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7437 *readStreamPtrPtr += 1 * 8;
7438 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
7439 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7440 *readStreamPtrPtr += sizeof(VkImageLayout);
7441 uint64_t cgen_var_2;
7442 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
7443 *readStreamPtrPtr += 1 * 8;
7444 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_2));
7445 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7446 *readStreamPtrPtr += sizeof(VkImageLayout);
7447 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
7448 *readStreamPtrPtr += sizeof(uint32_t);
7449 vkReadStream->alloc((void**)&pRegions, ((regionCount)) * sizeof(const VkImageBlit));
7450 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7451 reservedunmarshal_VkImageBlit(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7452 (VkImageBlit*)(pRegions + i), readStreamPtrPtr);
7453 }
7454 memcpy((VkFilter*)&filter, *readStreamPtrPtr, sizeof(VkFilter));
7455 *readStreamPtrPtr += sizeof(VkFilter);
7456 if (pRegions) {
7457 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7458 transform_tohost_VkImageBlit(m_state, (VkImageBlit*)(pRegions + i));
7459 }
7460 }
7461 if (m_logCalls) {
7462 fprintf(stderr,
7463 "stream %p: call vkCmdBlitImage 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
7464 "0x%llx 0x%llx 0x%llx \n",
7465 ioStream, (unsigned long long)commandBuffer,
7466 (unsigned long long)srcImage, (unsigned long long)srcImageLayout,
7467 (unsigned long long)dstImage, (unsigned long long)dstImageLayout,
7468 (unsigned long long)regionCount, (unsigned long long)pRegions,
7469 (unsigned long long)filter);
7470 }
7471 vk->vkCmdBlitImage(unboxed_commandBuffer, srcImage, srcImageLayout, dstImage,
7472 dstImageLayout, regionCount, pRegions, filter);
7473 vkStream->unsetHandleMapping();
7474 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7475 (uintptr_t)snapshotTraceBegin);
7476 size_t snapshotTraceBytes = vkReadStream->endTrace();
7477 if (m_state->snapshotsEnabled()) {
7478 m_state->snapshot()->vkCmdBlitImage(
7479 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, srcImage,
7480 srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
7481 }
7482 vkReadStream->clearPool();
7483 if (m_queueSubmitWithCommandsEnabled)
7484 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7485 break;
7486 }
7487 case OP_vkCmdCopyBufferToImage: {
7488 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7489 "VkDecoder vkCmdCopyBufferToImage");
7490 VkCommandBuffer commandBuffer;
7491 VkBuffer srcBuffer;
7492 VkImage dstImage;
7493 VkImageLayout dstImageLayout;
7494 uint32_t regionCount;
7495 const VkBufferImageCopy* pRegions;
7496 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
7497 uint64_t cgen_var_0;
7498 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7499 *readStreamPtrPtr += 1 * 8;
7500 *(VkCommandBuffer*)&commandBuffer =
7501 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7502 uint64_t cgen_var_1;
7503 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7504 *readStreamPtrPtr += 1 * 8;
7505 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
7506 uint64_t cgen_var_2;
7507 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
7508 *readStreamPtrPtr += 1 * 8;
7509 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_2));
7510 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7511 *readStreamPtrPtr += sizeof(VkImageLayout);
7512 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
7513 *readStreamPtrPtr += sizeof(uint32_t);
7514 vkReadStream->alloc((void**)&pRegions,
7515 ((regionCount)) * sizeof(const VkBufferImageCopy));
7516 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7517 reservedunmarshal_VkBufferImageCopy(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7518 (VkBufferImageCopy*)(pRegions + i),
7519 readStreamPtrPtr);
7520 }
7521 if (pRegions) {
7522 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7523 transform_tohost_VkBufferImageCopy(m_state,
7524 (VkBufferImageCopy*)(pRegions + i));
7525 }
7526 }
7527 if (m_logCalls) {
7528 fprintf(stderr,
7529 "stream %p: call vkCmdCopyBufferToImage 0x%llx 0x%llx 0x%llx 0x%llx "
7530 "0x%llx 0x%llx \n",
7531 ioStream, (unsigned long long)commandBuffer,
7532 (unsigned long long)srcBuffer, (unsigned long long)dstImage,
7533 (unsigned long long)dstImageLayout, (unsigned long long)regionCount,
7534 (unsigned long long)pRegions);
7535 }
7536 m_state->on_vkCmdCopyBufferToImage(&m_pool, commandBuffer, srcBuffer, dstImage,
7537 dstImageLayout, regionCount, pRegions, context);
7538 vkStream->unsetHandleMapping();
7539 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7540 (uintptr_t)snapshotTraceBegin);
7541 size_t snapshotTraceBytes = vkReadStream->endTrace();
7542 if (m_state->snapshotsEnabled()) {
7543 m_state->snapshot()->vkCmdCopyBufferToImage(
7544 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, srcBuffer,
7545 dstImage, dstImageLayout, regionCount, pRegions);
7546 }
7547 vkReadStream->clearPool();
7548 if (m_queueSubmitWithCommandsEnabled)
7549 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7550 break;
7551 }
7552 case OP_vkCmdCopyImageToBuffer: {
7553 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7554 "VkDecoder vkCmdCopyImageToBuffer");
7555 VkCommandBuffer commandBuffer;
7556 VkImage srcImage;
7557 VkImageLayout srcImageLayout;
7558 VkBuffer dstBuffer;
7559 uint32_t regionCount;
7560 const VkBufferImageCopy* pRegions;
7561 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
7562 uint64_t cgen_var_0;
7563 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7564 *readStreamPtrPtr += 1 * 8;
7565 *(VkCommandBuffer*)&commandBuffer =
7566 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7567 uint64_t cgen_var_1;
7568 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7569 *readStreamPtrPtr += 1 * 8;
7570 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
7571 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7572 *readStreamPtrPtr += sizeof(VkImageLayout);
7573 uint64_t cgen_var_2;
7574 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
7575 *readStreamPtrPtr += 1 * 8;
7576 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_2));
7577 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
7578 *readStreamPtrPtr += sizeof(uint32_t);
7579 vkReadStream->alloc((void**)&pRegions,
7580 ((regionCount)) * sizeof(const VkBufferImageCopy));
7581 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7582 reservedunmarshal_VkBufferImageCopy(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7583 (VkBufferImageCopy*)(pRegions + i),
7584 readStreamPtrPtr);
7585 }
7586 if (pRegions) {
7587 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7588 transform_tohost_VkBufferImageCopy(m_state,
7589 (VkBufferImageCopy*)(pRegions + i));
7590 }
7591 }
7592 if (m_logCalls) {
7593 fprintf(stderr,
7594 "stream %p: call vkCmdCopyImageToBuffer 0x%llx 0x%llx 0x%llx 0x%llx "
7595 "0x%llx 0x%llx \n",
7596 ioStream, (unsigned long long)commandBuffer,
7597 (unsigned long long)srcImage, (unsigned long long)srcImageLayout,
7598 (unsigned long long)dstBuffer, (unsigned long long)regionCount,
7599 (unsigned long long)pRegions);
7600 }
7601 m_state->on_vkCmdCopyImageToBuffer(&m_pool, commandBuffer, srcImage, srcImageLayout,
7602 dstBuffer, regionCount, pRegions);
7603 vkStream->unsetHandleMapping();
7604 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7605 (uintptr_t)snapshotTraceBegin);
7606 size_t snapshotTraceBytes = vkReadStream->endTrace();
7607 if (m_state->snapshotsEnabled()) {
7608 m_state->snapshot()->vkCmdCopyImageToBuffer(
7609 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, srcImage,
7610 srcImageLayout, dstBuffer, regionCount, pRegions);
7611 }
7612 vkReadStream->clearPool();
7613 if (m_queueSubmitWithCommandsEnabled)
7614 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7615 break;
7616 }
7617 case OP_vkCmdUpdateBuffer: {
7618 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7619 "VkDecoder vkCmdUpdateBuffer");
7620 VkCommandBuffer commandBuffer;
7621 VkBuffer dstBuffer;
7622 VkDeviceSize dstOffset;
7623 VkDeviceSize dataSize;
7624 const void* pData;
7625 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7626 uint64_t cgen_var_0;
7627 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7628 *readStreamPtrPtr += 1 * 8;
7629 *(VkCommandBuffer*)&commandBuffer =
7630 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7631 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7632 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7633 // End manual dispatchable handle unboxing for commandBuffer;
7634 uint64_t cgen_var_1;
7635 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7636 *readStreamPtrPtr += 1 * 8;
7637 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
7638 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
7639 *readStreamPtrPtr += sizeof(VkDeviceSize);
7640 memcpy((VkDeviceSize*)&dataSize, *readStreamPtrPtr, sizeof(VkDeviceSize));
7641 *readStreamPtrPtr += sizeof(VkDeviceSize);
7642 vkReadStream->alloc((void**)&pData, ((dataSize)) * sizeof(const uint8_t));
7643 memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(const uint8_t));
7644 *readStreamPtrPtr += ((dataSize)) * sizeof(const uint8_t);
7645 if (m_logCalls) {
7646 fprintf(
7647 stderr,
7648 "stream %p: call vkCmdUpdateBuffer 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
7649 ioStream, (unsigned long long)commandBuffer, (unsigned long long)dstBuffer,
7650 (unsigned long long)dstOffset, (unsigned long long)dataSize,
7651 (unsigned long long)pData);
7652 }
7653 vk->vkCmdUpdateBuffer(unboxed_commandBuffer, dstBuffer, dstOffset, dataSize, pData);
7654 vkStream->unsetHandleMapping();
7655 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7656 (uintptr_t)snapshotTraceBegin);
7657 size_t snapshotTraceBytes = vkReadStream->endTrace();
7658 if (m_state->snapshotsEnabled()) {
7659 m_state->snapshot()->vkCmdUpdateBuffer(snapshotTraceBegin, snapshotTraceBytes,
7660 &m_pool, commandBuffer, dstBuffer,
7661 dstOffset, dataSize, pData);
7662 }
7663 vkReadStream->clearPool();
7664 if (m_queueSubmitWithCommandsEnabled)
7665 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7666 break;
7667 }
7668 case OP_vkCmdFillBuffer: {
7669 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7670 "VkDecoder vkCmdFillBuffer");
7671 VkCommandBuffer commandBuffer;
7672 VkBuffer dstBuffer;
7673 VkDeviceSize dstOffset;
7674 VkDeviceSize size;
7675 uint32_t data;
7676 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7677 uint64_t cgen_var_0;
7678 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7679 *readStreamPtrPtr += 1 * 8;
7680 *(VkCommandBuffer*)&commandBuffer =
7681 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7682 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7683 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7684 // End manual dispatchable handle unboxing for commandBuffer;
7685 uint64_t cgen_var_1;
7686 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7687 *readStreamPtrPtr += 1 * 8;
7688 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
7689 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
7690 *readStreamPtrPtr += sizeof(VkDeviceSize);
7691 memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
7692 *readStreamPtrPtr += sizeof(VkDeviceSize);
7693 memcpy((uint32_t*)&data, *readStreamPtrPtr, sizeof(uint32_t));
7694 *readStreamPtrPtr += sizeof(uint32_t);
7695 if (m_logCalls) {
7696 fprintf(stderr,
7697 "stream %p: call vkCmdFillBuffer 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
7698 ioStream, (unsigned long long)commandBuffer,
7699 (unsigned long long)dstBuffer, (unsigned long long)dstOffset,
7700 (unsigned long long)size, (unsigned long long)data);
7701 }
7702 vk->vkCmdFillBuffer(unboxed_commandBuffer, dstBuffer, dstOffset, size, data);
7703 vkStream->unsetHandleMapping();
7704 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7705 (uintptr_t)snapshotTraceBegin);
7706 size_t snapshotTraceBytes = vkReadStream->endTrace();
7707 if (m_state->snapshotsEnabled()) {
7708 m_state->snapshot()->vkCmdFillBuffer(snapshotTraceBegin, snapshotTraceBytes,
7709 &m_pool, commandBuffer, dstBuffer,
7710 dstOffset, size, data);
7711 }
7712 vkReadStream->clearPool();
7713 if (m_queueSubmitWithCommandsEnabled)
7714 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7715 break;
7716 }
7717 case OP_vkCmdClearColorImage: {
7718 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7719 "VkDecoder vkCmdClearColorImage");
7720 VkCommandBuffer commandBuffer;
7721 VkImage image;
7722 VkImageLayout imageLayout;
7723 const VkClearColorValue* pColor;
7724 uint32_t rangeCount;
7725 const VkImageSubresourceRange* pRanges;
7726 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7727 uint64_t cgen_var_0;
7728 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7729 *readStreamPtrPtr += 1 * 8;
7730 *(VkCommandBuffer*)&commandBuffer =
7731 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7732 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7733 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7734 // End manual dispatchable handle unboxing for commandBuffer;
7735 uint64_t cgen_var_1;
7736 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7737 *readStreamPtrPtr += 1 * 8;
7738 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
7739 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7740 *readStreamPtrPtr += sizeof(VkImageLayout);
7741 vkReadStream->alloc((void**)&pColor, sizeof(const VkClearColorValue));
7742 reservedunmarshal_VkClearColorValue(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7743 (VkClearColorValue*)(pColor), readStreamPtrPtr);
7744 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
7745 *readStreamPtrPtr += sizeof(uint32_t);
7746 vkReadStream->alloc((void**)&pRanges,
7747 ((rangeCount)) * sizeof(const VkImageSubresourceRange));
7748 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
7749 reservedunmarshal_VkImageSubresourceRange(
7750 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7751 (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
7752 }
7753 if (pColor) {
7754 transform_tohost_VkClearColorValue(m_state, (VkClearColorValue*)(pColor));
7755 }
7756 if (pRanges) {
7757 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
7758 transform_tohost_VkImageSubresourceRange(
7759 m_state, (VkImageSubresourceRange*)(pRanges + i));
7760 }
7761 }
7762 if (m_logCalls) {
7763 fprintf(stderr,
7764 "stream %p: call vkCmdClearColorImage 0x%llx 0x%llx 0x%llx 0x%llx "
7765 "0x%llx 0x%llx \n",
7766 ioStream, (unsigned long long)commandBuffer, (unsigned long long)image,
7767 (unsigned long long)imageLayout, (unsigned long long)pColor,
7768 (unsigned long long)rangeCount, (unsigned long long)pRanges);
7769 }
7770 vk->vkCmdClearColorImage(unboxed_commandBuffer, image, imageLayout, pColor,
7771 rangeCount, pRanges);
7772 vkStream->unsetHandleMapping();
7773 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7774 (uintptr_t)snapshotTraceBegin);
7775 size_t snapshotTraceBytes = vkReadStream->endTrace();
7776 if (m_state->snapshotsEnabled()) {
7777 m_state->snapshot()->vkCmdClearColorImage(
7778 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, image,
7779 imageLayout, pColor, rangeCount, pRanges);
7780 }
7781 vkReadStream->clearPool();
7782 if (m_queueSubmitWithCommandsEnabled)
7783 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7784 break;
7785 }
7786 case OP_vkCmdClearDepthStencilImage: {
7787 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7788 "VkDecoder vkCmdClearDepthStencilImage");
7789 VkCommandBuffer commandBuffer;
7790 VkImage image;
7791 VkImageLayout imageLayout;
7792 const VkClearDepthStencilValue* pDepthStencil;
7793 uint32_t rangeCount;
7794 const VkImageSubresourceRange* pRanges;
7795 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7796 uint64_t cgen_var_0;
7797 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7798 *readStreamPtrPtr += 1 * 8;
7799 *(VkCommandBuffer*)&commandBuffer =
7800 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7801 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7802 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7803 // End manual dispatchable handle unboxing for commandBuffer;
7804 uint64_t cgen_var_1;
7805 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7806 *readStreamPtrPtr += 1 * 8;
7807 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
7808 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7809 *readStreamPtrPtr += sizeof(VkImageLayout);
7810 vkReadStream->alloc((void**)&pDepthStencil, sizeof(const VkClearDepthStencilValue));
7811 reservedunmarshal_VkClearDepthStencilValue(
7812 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7813 (VkClearDepthStencilValue*)(pDepthStencil), readStreamPtrPtr);
7814 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
7815 *readStreamPtrPtr += sizeof(uint32_t);
7816 vkReadStream->alloc((void**)&pRanges,
7817 ((rangeCount)) * sizeof(const VkImageSubresourceRange));
7818 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
7819 reservedunmarshal_VkImageSubresourceRange(
7820 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7821 (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
7822 }
7823 if (pDepthStencil) {
7824 transform_tohost_VkClearDepthStencilValue(
7825 m_state, (VkClearDepthStencilValue*)(pDepthStencil));
7826 }
7827 if (pRanges) {
7828 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
7829 transform_tohost_VkImageSubresourceRange(
7830 m_state, (VkImageSubresourceRange*)(pRanges + i));
7831 }
7832 }
7833 if (m_logCalls) {
7834 fprintf(stderr,
7835 "stream %p: call vkCmdClearDepthStencilImage 0x%llx 0x%llx 0x%llx "
7836 "0x%llx 0x%llx 0x%llx \n",
7837 ioStream, (unsigned long long)commandBuffer, (unsigned long long)image,
7838 (unsigned long long)imageLayout, (unsigned long long)pDepthStencil,
7839 (unsigned long long)rangeCount, (unsigned long long)pRanges);
7840 }
7841 vk->vkCmdClearDepthStencilImage(unboxed_commandBuffer, image, imageLayout,
7842 pDepthStencil, rangeCount, pRanges);
7843 vkStream->unsetHandleMapping();
7844 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7845 (uintptr_t)snapshotTraceBegin);
7846 size_t snapshotTraceBytes = vkReadStream->endTrace();
7847 if (m_state->snapshotsEnabled()) {
7848 m_state->snapshot()->vkCmdClearDepthStencilImage(
7849 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, image,
7850 imageLayout, pDepthStencil, rangeCount, pRanges);
7851 }
7852 vkReadStream->clearPool();
7853 if (m_queueSubmitWithCommandsEnabled)
7854 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7855 break;
7856 }
7857 case OP_vkCmdClearAttachments: {
7858 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7859 "VkDecoder vkCmdClearAttachments");
7860 VkCommandBuffer commandBuffer;
7861 uint32_t attachmentCount;
7862 const VkClearAttachment* pAttachments;
7863 uint32_t rectCount;
7864 const VkClearRect* pRects;
7865 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7866 uint64_t cgen_var_0;
7867 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7868 *readStreamPtrPtr += 1 * 8;
7869 *(VkCommandBuffer*)&commandBuffer =
7870 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7871 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7872 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7873 // End manual dispatchable handle unboxing for commandBuffer;
7874 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
7875 *readStreamPtrPtr += sizeof(uint32_t);
7876 vkReadStream->alloc((void**)&pAttachments,
7877 ((attachmentCount)) * sizeof(const VkClearAttachment));
7878 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
7879 reservedunmarshal_VkClearAttachment(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7880 (VkClearAttachment*)(pAttachments + i),
7881 readStreamPtrPtr);
7882 }
7883 memcpy((uint32_t*)&rectCount, *readStreamPtrPtr, sizeof(uint32_t));
7884 *readStreamPtrPtr += sizeof(uint32_t);
7885 vkReadStream->alloc((void**)&pRects, ((rectCount)) * sizeof(const VkClearRect));
7886 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
7887 reservedunmarshal_VkClearRect(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7888 (VkClearRect*)(pRects + i), readStreamPtrPtr);
7889 }
7890 if (pAttachments) {
7891 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
7892 transform_tohost_VkClearAttachment(m_state,
7893 (VkClearAttachment*)(pAttachments + i));
7894 }
7895 }
7896 if (pRects) {
7897 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
7898 transform_tohost_VkClearRect(m_state, (VkClearRect*)(pRects + i));
7899 }
7900 }
7901 if (m_logCalls) {
7902 fprintf(stderr,
7903 "stream %p: call vkCmdClearAttachments 0x%llx 0x%llx 0x%llx 0x%llx "
7904 "0x%llx \n",
7905 ioStream, (unsigned long long)commandBuffer,
7906 (unsigned long long)attachmentCount, (unsigned long long)pAttachments,
7907 (unsigned long long)rectCount, (unsigned long long)pRects);
7908 }
7909 vk->vkCmdClearAttachments(unboxed_commandBuffer, attachmentCount, pAttachments,
7910 rectCount, pRects);
7911 vkStream->unsetHandleMapping();
7912 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7913 (uintptr_t)snapshotTraceBegin);
7914 size_t snapshotTraceBytes = vkReadStream->endTrace();
7915 if (m_state->snapshotsEnabled()) {
7916 m_state->snapshot()->vkCmdClearAttachments(
7917 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
7918 attachmentCount, pAttachments, rectCount, pRects);
7919 }
7920 vkReadStream->clearPool();
7921 if (m_queueSubmitWithCommandsEnabled)
7922 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7923 break;
7924 }
7925 case OP_vkCmdResolveImage: {
7926 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
7927 "VkDecoder vkCmdResolveImage");
7928 VkCommandBuffer commandBuffer;
7929 VkImage srcImage;
7930 VkImageLayout srcImageLayout;
7931 VkImage dstImage;
7932 VkImageLayout dstImageLayout;
7933 uint32_t regionCount;
7934 const VkImageResolve* pRegions;
7935 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
7936 uint64_t cgen_var_0;
7937 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
7938 *readStreamPtrPtr += 1 * 8;
7939 *(VkCommandBuffer*)&commandBuffer =
7940 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
7941 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
7942 auto vk = dispatch_VkCommandBuffer(commandBuffer);
7943 // End manual dispatchable handle unboxing for commandBuffer;
7944 uint64_t cgen_var_1;
7945 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
7946 *readStreamPtrPtr += 1 * 8;
7947 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
7948 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7949 *readStreamPtrPtr += sizeof(VkImageLayout);
7950 uint64_t cgen_var_2;
7951 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
7952 *readStreamPtrPtr += 1 * 8;
7953 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_2));
7954 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
7955 *readStreamPtrPtr += sizeof(VkImageLayout);
7956 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
7957 *readStreamPtrPtr += sizeof(uint32_t);
7958 vkReadStream->alloc((void**)&pRegions,
7959 ((regionCount)) * sizeof(const VkImageResolve));
7960 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7961 reservedunmarshal_VkImageResolve(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
7962 (VkImageResolve*)(pRegions + i),
7963 readStreamPtrPtr);
7964 }
7965 if (pRegions) {
7966 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
7967 transform_tohost_VkImageResolve(m_state, (VkImageResolve*)(pRegions + i));
7968 }
7969 }
7970 if (m_logCalls) {
7971 fprintf(stderr,
7972 "stream %p: call vkCmdResolveImage 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
7973 "0x%llx 0x%llx \n",
7974 ioStream, (unsigned long long)commandBuffer,
7975 (unsigned long long)srcImage, (unsigned long long)srcImageLayout,
7976 (unsigned long long)dstImage, (unsigned long long)dstImageLayout,
7977 (unsigned long long)regionCount, (unsigned long long)pRegions);
7978 }
7979 vk->vkCmdResolveImage(unboxed_commandBuffer, srcImage, srcImageLayout, dstImage,
7980 dstImageLayout, regionCount, pRegions);
7981 vkStream->unsetHandleMapping();
7982 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
7983 (uintptr_t)snapshotTraceBegin);
7984 size_t snapshotTraceBytes = vkReadStream->endTrace();
7985 if (m_state->snapshotsEnabled()) {
7986 m_state->snapshot()->vkCmdResolveImage(
7987 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, srcImage,
7988 srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
7989 }
7990 vkReadStream->clearPool();
7991 if (m_queueSubmitWithCommandsEnabled)
7992 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
7993 break;
7994 }
7995 case OP_vkCmdSetEvent: {
7996 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCmdSetEvent");
7997 VkCommandBuffer commandBuffer;
7998 VkEvent event;
7999 VkPipelineStageFlags stageMask;
8000 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8001 uint64_t cgen_var_0;
8002 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8003 *readStreamPtrPtr += 1 * 8;
8004 *(VkCommandBuffer*)&commandBuffer =
8005 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8006 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8007 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8008 // End manual dispatchable handle unboxing for commandBuffer;
8009 uint64_t cgen_var_1;
8010 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
8011 *readStreamPtrPtr += 1 * 8;
8012 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
8013 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr,
8014 sizeof(VkPipelineStageFlags));
8015 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
8016 if (m_logCalls) {
8017 fprintf(stderr, "stream %p: call vkCmdSetEvent 0x%llx 0x%llx 0x%llx \n",
8018 ioStream, (unsigned long long)commandBuffer, (unsigned long long)event,
8019 (unsigned long long)stageMask);
8020 }
8021 vk->vkCmdSetEvent(unboxed_commandBuffer, event, stageMask);
8022 vkStream->unsetHandleMapping();
8023 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8024 (uintptr_t)snapshotTraceBegin);
8025 size_t snapshotTraceBytes = vkReadStream->endTrace();
8026 if (m_state->snapshotsEnabled()) {
8027 m_state->snapshot()->vkCmdSetEvent(snapshotTraceBegin, snapshotTraceBytes,
8028 &m_pool, commandBuffer, event, stageMask);
8029 }
8030 vkReadStream->clearPool();
8031 if (m_queueSubmitWithCommandsEnabled)
8032 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8033 break;
8034 }
8035 case OP_vkCmdResetEvent: {
8036 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8037 "VkDecoder vkCmdResetEvent");
8038 VkCommandBuffer commandBuffer;
8039 VkEvent event;
8040 VkPipelineStageFlags stageMask;
8041 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8042 uint64_t cgen_var_0;
8043 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8044 *readStreamPtrPtr += 1 * 8;
8045 *(VkCommandBuffer*)&commandBuffer =
8046 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8047 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8048 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8049 // End manual dispatchable handle unboxing for commandBuffer;
8050 uint64_t cgen_var_1;
8051 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
8052 *readStreamPtrPtr += 1 * 8;
8053 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
8054 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr,
8055 sizeof(VkPipelineStageFlags));
8056 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
8057 if (m_logCalls) {
8058 fprintf(stderr, "stream %p: call vkCmdResetEvent 0x%llx 0x%llx 0x%llx \n",
8059 ioStream, (unsigned long long)commandBuffer, (unsigned long long)event,
8060 (unsigned long long)stageMask);
8061 }
8062 vk->vkCmdResetEvent(unboxed_commandBuffer, event, stageMask);
8063 vkStream->unsetHandleMapping();
8064 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8065 (uintptr_t)snapshotTraceBegin);
8066 size_t snapshotTraceBytes = vkReadStream->endTrace();
8067 if (m_state->snapshotsEnabled()) {
8068 m_state->snapshot()->vkCmdResetEvent(snapshotTraceBegin, snapshotTraceBytes,
8069 &m_pool, commandBuffer, event, stageMask);
8070 }
8071 vkReadStream->clearPool();
8072 if (m_queueSubmitWithCommandsEnabled)
8073 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8074 break;
8075 }
8076 case OP_vkCmdWaitEvents: {
8077 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8078 "VkDecoder vkCmdWaitEvents");
8079 VkCommandBuffer commandBuffer;
8080 uint32_t eventCount;
8081 const VkEvent* pEvents;
8082 VkPipelineStageFlags srcStageMask;
8083 VkPipelineStageFlags dstStageMask;
8084 uint32_t memoryBarrierCount;
8085 const VkMemoryBarrier* pMemoryBarriers;
8086 uint32_t bufferMemoryBarrierCount;
8087 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
8088 uint32_t imageMemoryBarrierCount;
8089 const VkImageMemoryBarrier* pImageMemoryBarriers;
8090 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8091 uint64_t cgen_var_0;
8092 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8093 *readStreamPtrPtr += 1 * 8;
8094 *(VkCommandBuffer*)&commandBuffer =
8095 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8096 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8097 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8098 // End manual dispatchable handle unboxing for commandBuffer;
8099 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
8100 *readStreamPtrPtr += sizeof(uint32_t);
8101 vkReadStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
8102 if (((eventCount))) {
8103 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
8104 *readStreamPtrPtr += 8 * ((eventCount));
8105 for (uint32_t k = 0; k < ((eventCount)); ++k) {
8106 uint64_t tmpval;
8107 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
8108 *(((VkEvent*)pEvents) + k) =
8109 tmpval ? (VkEvent)unbox_VkEvent((VkEvent)tmpval) : VK_NULL_HANDLE;
8110 }
8111 }
8112 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr,
8113 sizeof(VkPipelineStageFlags));
8114 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
8115 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr,
8116 sizeof(VkPipelineStageFlags));
8117 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
8118 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
8119 *readStreamPtrPtr += sizeof(uint32_t);
8120 vkReadStream->alloc((void**)&pMemoryBarriers,
8121 ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
8122 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
8123 reservedunmarshal_VkMemoryBarrier(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
8124 (VkMemoryBarrier*)(pMemoryBarriers + i),
8125 readStreamPtrPtr);
8126 }
8127 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
8128 *readStreamPtrPtr += sizeof(uint32_t);
8129 vkReadStream->alloc(
8130 (void**)&pBufferMemoryBarriers,
8131 ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
8132 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
8133 reservedunmarshal_VkBufferMemoryBarrier(
8134 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
8135 (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
8136 }
8137 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
8138 *readStreamPtrPtr += sizeof(uint32_t);
8139 vkReadStream->alloc(
8140 (void**)&pImageMemoryBarriers,
8141 ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
8142 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
8143 reservedunmarshal_VkImageMemoryBarrier(
8144 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
8145 (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
8146 }
8147 if (pMemoryBarriers) {
8148 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
8149 transform_tohost_VkMemoryBarrier(m_state,
8150 (VkMemoryBarrier*)(pMemoryBarriers + i));
8151 }
8152 }
8153 if (pBufferMemoryBarriers) {
8154 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
8155 transform_tohost_VkBufferMemoryBarrier(
8156 m_state, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
8157 }
8158 }
8159 if (pImageMemoryBarriers) {
8160 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
8161 transform_tohost_VkImageMemoryBarrier(
8162 m_state, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
8163 }
8164 }
8165 if (m_logCalls) {
8166 fprintf(stderr,
8167 "stream %p: call vkCmdWaitEvents 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
8168 "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
8169 ioStream, (unsigned long long)commandBuffer,
8170 (unsigned long long)eventCount, (unsigned long long)pEvents,
8171 (unsigned long long)srcStageMask, (unsigned long long)dstStageMask,
8172 (unsigned long long)memoryBarrierCount,
8173 (unsigned long long)pMemoryBarriers,
8174 (unsigned long long)bufferMemoryBarrierCount,
8175 (unsigned long long)pBufferMemoryBarriers,
8176 (unsigned long long)imageMemoryBarrierCount,
8177 (unsigned long long)pImageMemoryBarriers);
8178 }
8179 vk->vkCmdWaitEvents(unboxed_commandBuffer, eventCount, pEvents, srcStageMask,
8180 dstStageMask, memoryBarrierCount, pMemoryBarriers,
8181 bufferMemoryBarrierCount, pBufferMemoryBarriers,
8182 imageMemoryBarrierCount, pImageMemoryBarriers);
8183 vkStream->unsetHandleMapping();
8184 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8185 (uintptr_t)snapshotTraceBegin);
8186 size_t snapshotTraceBytes = vkReadStream->endTrace();
8187 if (m_state->snapshotsEnabled()) {
8188 m_state->snapshot()->vkCmdWaitEvents(
8189 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, eventCount,
8190 pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers,
8191 bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount,
8192 pImageMemoryBarriers);
8193 }
8194 vkReadStream->clearPool();
8195 if (m_queueSubmitWithCommandsEnabled)
8196 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8197 break;
8198 }
8199 case OP_vkCmdPipelineBarrier: {
8200 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8201 "VkDecoder vkCmdPipelineBarrier");
8202 VkCommandBuffer commandBuffer;
8203 VkPipelineStageFlags srcStageMask;
8204 VkPipelineStageFlags dstStageMask;
8205 VkDependencyFlags dependencyFlags;
8206 uint32_t memoryBarrierCount;
8207 const VkMemoryBarrier* pMemoryBarriers;
8208 uint32_t bufferMemoryBarrierCount;
8209 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
8210 uint32_t imageMemoryBarrierCount;
8211 const VkImageMemoryBarrier* pImageMemoryBarriers;
8212 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
8213 uint64_t cgen_var_0;
8214 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8215 *readStreamPtrPtr += 1 * 8;
8216 *(VkCommandBuffer*)&commandBuffer =
8217 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8218 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr,
8219 sizeof(VkPipelineStageFlags));
8220 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
8221 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr,
8222 sizeof(VkPipelineStageFlags));
8223 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
8224 memcpy((VkDependencyFlags*)&dependencyFlags, *readStreamPtrPtr,
8225 sizeof(VkDependencyFlags));
8226 *readStreamPtrPtr += sizeof(VkDependencyFlags);
8227 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
8228 *readStreamPtrPtr += sizeof(uint32_t);
8229 vkReadStream->alloc((void**)&pMemoryBarriers,
8230 ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
8231 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
8232 reservedunmarshal_VkMemoryBarrier(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
8233 (VkMemoryBarrier*)(pMemoryBarriers + i),
8234 readStreamPtrPtr);
8235 }
8236 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
8237 *readStreamPtrPtr += sizeof(uint32_t);
8238 vkReadStream->alloc(
8239 (void**)&pBufferMemoryBarriers,
8240 ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
8241 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
8242 reservedunmarshal_VkBufferMemoryBarrier(
8243 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
8244 (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
8245 }
8246 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
8247 *readStreamPtrPtr += sizeof(uint32_t);
8248 vkReadStream->alloc(
8249 (void**)&pImageMemoryBarriers,
8250 ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
8251 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
8252 reservedunmarshal_VkImageMemoryBarrier(
8253 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
8254 (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
8255 }
8256 if (pMemoryBarriers) {
8257 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
8258 transform_tohost_VkMemoryBarrier(m_state,
8259 (VkMemoryBarrier*)(pMemoryBarriers + i));
8260 }
8261 }
8262 if (pBufferMemoryBarriers) {
8263 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
8264 transform_tohost_VkBufferMemoryBarrier(
8265 m_state, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
8266 }
8267 }
8268 if (pImageMemoryBarriers) {
8269 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
8270 transform_tohost_VkImageMemoryBarrier(
8271 m_state, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
8272 }
8273 }
8274 if (m_logCalls) {
8275 fprintf(stderr,
8276 "stream %p: call vkCmdPipelineBarrier 0x%llx 0x%llx 0x%llx 0x%llx "
8277 "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
8278 ioStream, (unsigned long long)commandBuffer,
8279 (unsigned long long)srcStageMask, (unsigned long long)dstStageMask,
8280 (unsigned long long)dependencyFlags,
8281 (unsigned long long)memoryBarrierCount,
8282 (unsigned long long)pMemoryBarriers,
8283 (unsigned long long)bufferMemoryBarrierCount,
8284 (unsigned long long)pBufferMemoryBarriers,
8285 (unsigned long long)imageMemoryBarrierCount,
8286 (unsigned long long)pImageMemoryBarriers);
8287 }
8288 m_state->on_vkCmdPipelineBarrier(
8289 &m_pool, commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
8290 memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
8291 pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
8292 vkStream->unsetHandleMapping();
8293 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8294 (uintptr_t)snapshotTraceBegin);
8295 size_t snapshotTraceBytes = vkReadStream->endTrace();
8296 if (m_state->snapshotsEnabled()) {
8297 m_state->snapshot()->vkCmdPipelineBarrier(
8298 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
8299 srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount,
8300 pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers,
8301 imageMemoryBarrierCount, pImageMemoryBarriers);
8302 }
8303 vkReadStream->clearPool();
8304 if (m_queueSubmitWithCommandsEnabled)
8305 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8306 break;
8307 }
8308 case OP_vkCmdBeginQuery: {
8309 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8310 "VkDecoder vkCmdBeginQuery");
8311 VkCommandBuffer commandBuffer;
8312 VkQueryPool queryPool;
8313 uint32_t query;
8314 VkQueryControlFlags flags;
8315 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8316 uint64_t cgen_var_0;
8317 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8318 *readStreamPtrPtr += 1 * 8;
8319 *(VkCommandBuffer*)&commandBuffer =
8320 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8321 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8322 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8323 // End manual dispatchable handle unboxing for commandBuffer;
8324 uint64_t cgen_var_1;
8325 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
8326 *readStreamPtrPtr += 1 * 8;
8327 *(VkQueryPool*)&queryPool =
8328 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
8329 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
8330 *readStreamPtrPtr += sizeof(uint32_t);
8331 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr,
8332 sizeof(VkQueryControlFlags));
8333 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
8334 if (m_logCalls) {
8335 fprintf(
8336 stderr, "stream %p: call vkCmdBeginQuery 0x%llx 0x%llx 0x%llx 0x%llx \n",
8337 ioStream, (unsigned long long)commandBuffer, (unsigned long long)queryPool,
8338 (unsigned long long)query, (unsigned long long)flags);
8339 }
8340 vk->vkCmdBeginQuery(unboxed_commandBuffer, queryPool, query, flags);
8341 vkStream->unsetHandleMapping();
8342 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8343 (uintptr_t)snapshotTraceBegin);
8344 size_t snapshotTraceBytes = vkReadStream->endTrace();
8345 if (m_state->snapshotsEnabled()) {
8346 m_state->snapshot()->vkCmdBeginQuery(snapshotTraceBegin, snapshotTraceBytes,
8347 &m_pool, commandBuffer, queryPool, query,
8348 flags);
8349 }
8350 vkReadStream->clearPool();
8351 if (m_queueSubmitWithCommandsEnabled)
8352 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8353 break;
8354 }
8355 case OP_vkCmdEndQuery: {
8356 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCmdEndQuery");
8357 VkCommandBuffer commandBuffer;
8358 VkQueryPool queryPool;
8359 uint32_t query;
8360 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8361 uint64_t cgen_var_0;
8362 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8363 *readStreamPtrPtr += 1 * 8;
8364 *(VkCommandBuffer*)&commandBuffer =
8365 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8366 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8367 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8368 // End manual dispatchable handle unboxing for commandBuffer;
8369 uint64_t cgen_var_1;
8370 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
8371 *readStreamPtrPtr += 1 * 8;
8372 *(VkQueryPool*)&queryPool =
8373 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
8374 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
8375 *readStreamPtrPtr += sizeof(uint32_t);
8376 if (m_logCalls) {
8377 fprintf(stderr, "stream %p: call vkCmdEndQuery 0x%llx 0x%llx 0x%llx \n",
8378 ioStream, (unsigned long long)commandBuffer,
8379 (unsigned long long)queryPool, (unsigned long long)query);
8380 }
8381 vk->vkCmdEndQuery(unboxed_commandBuffer, queryPool, query);
8382 vkStream->unsetHandleMapping();
8383 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8384 (uintptr_t)snapshotTraceBegin);
8385 size_t snapshotTraceBytes = vkReadStream->endTrace();
8386 if (m_state->snapshotsEnabled()) {
8387 m_state->snapshot()->vkCmdEndQuery(snapshotTraceBegin, snapshotTraceBytes,
8388 &m_pool, commandBuffer, queryPool, query);
8389 }
8390 vkReadStream->clearPool();
8391 if (m_queueSubmitWithCommandsEnabled)
8392 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8393 break;
8394 }
8395 case OP_vkCmdResetQueryPool: {
8396 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8397 "VkDecoder vkCmdResetQueryPool");
8398 VkCommandBuffer commandBuffer;
8399 VkQueryPool queryPool;
8400 uint32_t firstQuery;
8401 uint32_t queryCount;
8402 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8403 uint64_t cgen_var_0;
8404 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8405 *readStreamPtrPtr += 1 * 8;
8406 *(VkCommandBuffer*)&commandBuffer =
8407 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8408 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8409 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8410 // End manual dispatchable handle unboxing for commandBuffer;
8411 uint64_t cgen_var_1;
8412 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
8413 *readStreamPtrPtr += 1 * 8;
8414 *(VkQueryPool*)&queryPool =
8415 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
8416 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
8417 *readStreamPtrPtr += sizeof(uint32_t);
8418 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
8419 *readStreamPtrPtr += sizeof(uint32_t);
8420 if (m_logCalls) {
8421 fprintf(stderr,
8422 "stream %p: call vkCmdResetQueryPool 0x%llx 0x%llx 0x%llx 0x%llx \n",
8423 ioStream, (unsigned long long)commandBuffer,
8424 (unsigned long long)queryPool, (unsigned long long)firstQuery,
8425 (unsigned long long)queryCount);
8426 }
8427 vk->vkCmdResetQueryPool(unboxed_commandBuffer, queryPool, firstQuery, queryCount);
8428 vkStream->unsetHandleMapping();
8429 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8430 (uintptr_t)snapshotTraceBegin);
8431 size_t snapshotTraceBytes = vkReadStream->endTrace();
8432 if (m_state->snapshotsEnabled()) {
8433 m_state->snapshot()->vkCmdResetQueryPool(snapshotTraceBegin, snapshotTraceBytes,
8434 &m_pool, commandBuffer, queryPool,
8435 firstQuery, queryCount);
8436 }
8437 vkReadStream->clearPool();
8438 if (m_queueSubmitWithCommandsEnabled)
8439 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8440 break;
8441 }
8442 case OP_vkCmdWriteTimestamp: {
8443 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8444 "VkDecoder vkCmdWriteTimestamp");
8445 VkCommandBuffer commandBuffer;
8446 VkPipelineStageFlagBits pipelineStage;
8447 VkQueryPool queryPool;
8448 uint32_t query;
8449 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8450 uint64_t cgen_var_0;
8451 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8452 *readStreamPtrPtr += 1 * 8;
8453 *(VkCommandBuffer*)&commandBuffer =
8454 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8455 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8456 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8457 // End manual dispatchable handle unboxing for commandBuffer;
8458 memcpy((VkPipelineStageFlagBits*)&pipelineStage, *readStreamPtrPtr,
8459 sizeof(VkPipelineStageFlagBits));
8460 *readStreamPtrPtr += sizeof(VkPipelineStageFlagBits);
8461 uint64_t cgen_var_1;
8462 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
8463 *readStreamPtrPtr += 1 * 8;
8464 *(VkQueryPool*)&queryPool =
8465 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
8466 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
8467 *readStreamPtrPtr += sizeof(uint32_t);
8468 if (m_logCalls) {
8469 fprintf(stderr,
8470 "stream %p: call vkCmdWriteTimestamp 0x%llx 0x%llx 0x%llx 0x%llx \n",
8471 ioStream, (unsigned long long)commandBuffer,
8472 (unsigned long long)pipelineStage, (unsigned long long)queryPool,
8473 (unsigned long long)query);
8474 }
8475 vk->vkCmdWriteTimestamp(unboxed_commandBuffer, pipelineStage, queryPool, query);
8476 vkStream->unsetHandleMapping();
8477 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8478 (uintptr_t)snapshotTraceBegin);
8479 size_t snapshotTraceBytes = vkReadStream->endTrace();
8480 if (m_state->snapshotsEnabled()) {
8481 m_state->snapshot()->vkCmdWriteTimestamp(snapshotTraceBegin, snapshotTraceBytes,
8482 &m_pool, commandBuffer, pipelineStage,
8483 queryPool, query);
8484 }
8485 vkReadStream->clearPool();
8486 if (m_queueSubmitWithCommandsEnabled)
8487 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8488 break;
8489 }
8490 case OP_vkCmdCopyQueryPoolResults: {
8491 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8492 "VkDecoder vkCmdCopyQueryPoolResults");
8493 VkCommandBuffer commandBuffer;
8494 VkQueryPool queryPool;
8495 uint32_t firstQuery;
8496 uint32_t queryCount;
8497 VkBuffer dstBuffer;
8498 VkDeviceSize dstOffset;
8499 VkDeviceSize stride;
8500 VkQueryResultFlags flags;
8501 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8502 uint64_t cgen_var_0;
8503 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8504 *readStreamPtrPtr += 1 * 8;
8505 *(VkCommandBuffer*)&commandBuffer =
8506 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8507 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8508 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8509 // End manual dispatchable handle unboxing for commandBuffer;
8510 uint64_t cgen_var_1;
8511 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
8512 *readStreamPtrPtr += 1 * 8;
8513 *(VkQueryPool*)&queryPool =
8514 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
8515 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
8516 *readStreamPtrPtr += sizeof(uint32_t);
8517 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
8518 *readStreamPtrPtr += sizeof(uint32_t);
8519 uint64_t cgen_var_2;
8520 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
8521 *readStreamPtrPtr += 1 * 8;
8522 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_2));
8523 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
8524 *readStreamPtrPtr += sizeof(VkDeviceSize);
8525 memcpy((VkDeviceSize*)&stride, *readStreamPtrPtr, sizeof(VkDeviceSize));
8526 *readStreamPtrPtr += sizeof(VkDeviceSize);
8527 memcpy((VkQueryResultFlags*)&flags, *readStreamPtrPtr, sizeof(VkQueryResultFlags));
8528 *readStreamPtrPtr += sizeof(VkQueryResultFlags);
8529 if (m_logCalls) {
8530 fprintf(stderr,
8531 "stream %p: call vkCmdCopyQueryPoolResults 0x%llx 0x%llx 0x%llx 0x%llx "
8532 "0x%llx 0x%llx 0x%llx 0x%llx \n",
8533 ioStream, (unsigned long long)commandBuffer,
8534 (unsigned long long)queryPool, (unsigned long long)firstQuery,
8535 (unsigned long long)queryCount, (unsigned long long)dstBuffer,
8536 (unsigned long long)dstOffset, (unsigned long long)stride,
8537 (unsigned long long)flags);
8538 }
8539 vk->vkCmdCopyQueryPoolResults(unboxed_commandBuffer, queryPool, firstQuery,
8540 queryCount, dstBuffer, dstOffset, stride, flags);
8541 vkStream->unsetHandleMapping();
8542 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8543 (uintptr_t)snapshotTraceBegin);
8544 size_t snapshotTraceBytes = vkReadStream->endTrace();
8545 if (m_state->snapshotsEnabled()) {
8546 m_state->snapshot()->vkCmdCopyQueryPoolResults(
8547 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, queryPool,
8548 firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
8549 }
8550 vkReadStream->clearPool();
8551 if (m_queueSubmitWithCommandsEnabled)
8552 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8553 break;
8554 }
8555 case OP_vkCmdPushConstants: {
8556 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8557 "VkDecoder vkCmdPushConstants");
8558 VkCommandBuffer commandBuffer;
8559 VkPipelineLayout layout;
8560 VkShaderStageFlags stageFlags;
8561 uint32_t offset;
8562 uint32_t size;
8563 const void* pValues;
8564 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8565 uint64_t cgen_var_0;
8566 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8567 *readStreamPtrPtr += 1 * 8;
8568 *(VkCommandBuffer*)&commandBuffer =
8569 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8570 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8571 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8572 // End manual dispatchable handle unboxing for commandBuffer;
8573 uint64_t cgen_var_1;
8574 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
8575 *readStreamPtrPtr += 1 * 8;
8576 *(VkPipelineLayout*)&layout =
8577 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_1));
8578 memcpy((VkShaderStageFlags*)&stageFlags, *readStreamPtrPtr,
8579 sizeof(VkShaderStageFlags));
8580 *readStreamPtrPtr += sizeof(VkShaderStageFlags);
8581 memcpy((uint32_t*)&offset, *readStreamPtrPtr, sizeof(uint32_t));
8582 *readStreamPtrPtr += sizeof(uint32_t);
8583 memcpy((uint32_t*)&size, *readStreamPtrPtr, sizeof(uint32_t));
8584 *readStreamPtrPtr += sizeof(uint32_t);
8585 vkReadStream->alloc((void**)&pValues, ((size)) * sizeof(const uint8_t));
8586 memcpy((void*)pValues, *readStreamPtrPtr, ((size)) * sizeof(const uint8_t));
8587 *readStreamPtrPtr += ((size)) * sizeof(const uint8_t);
8588 if (m_logCalls) {
8589 fprintf(stderr,
8590 "stream %p: call vkCmdPushConstants 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
8591 "0x%llx \n",
8592 ioStream, (unsigned long long)commandBuffer, (unsigned long long)layout,
8593 (unsigned long long)stageFlags, (unsigned long long)offset,
8594 (unsigned long long)size, (unsigned long long)pValues);
8595 }
8596 vk->vkCmdPushConstants(unboxed_commandBuffer, layout, stageFlags, offset, size,
8597 pValues);
8598 vkStream->unsetHandleMapping();
8599 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8600 (uintptr_t)snapshotTraceBegin);
8601 size_t snapshotTraceBytes = vkReadStream->endTrace();
8602 if (m_state->snapshotsEnabled()) {
8603 m_state->snapshot()->vkCmdPushConstants(snapshotTraceBegin, snapshotTraceBytes,
8604 &m_pool, commandBuffer, layout,
8605 stageFlags, offset, size, pValues);
8606 }
8607 vkReadStream->clearPool();
8608 if (m_queueSubmitWithCommandsEnabled)
8609 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8610 break;
8611 }
8612 case OP_vkCmdBeginRenderPass: {
8613 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8614 "VkDecoder vkCmdBeginRenderPass");
8615 VkCommandBuffer commandBuffer;
8616 const VkRenderPassBeginInfo* pRenderPassBegin;
8617 VkSubpassContents contents;
8618 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
8619 uint64_t cgen_var_0;
8620 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8621 *readStreamPtrPtr += 1 * 8;
8622 *(VkCommandBuffer*)&commandBuffer =
8623 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8624 vkReadStream->alloc((void**)&pRenderPassBegin, sizeof(const VkRenderPassBeginInfo));
8625 reservedunmarshal_VkRenderPassBeginInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
8626 (VkRenderPassBeginInfo*)(pRenderPassBegin),
8627 readStreamPtrPtr);
8628 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
8629 *readStreamPtrPtr += sizeof(VkSubpassContents);
8630 if (pRenderPassBegin) {
8631 transform_tohost_VkRenderPassBeginInfo(
8632 m_state, (VkRenderPassBeginInfo*)(pRenderPassBegin));
8633 }
8634 if (m_logCalls) {
8635 fprintf(stderr, "stream %p: call vkCmdBeginRenderPass 0x%llx 0x%llx 0x%llx \n",
8636 ioStream, (unsigned long long)commandBuffer,
8637 (unsigned long long)pRenderPassBegin, (unsigned long long)contents);
8638 }
8639 m_state->on_vkCmdBeginRenderPass(&m_pool, commandBuffer, pRenderPassBegin,
8640 contents);
8641 vkStream->unsetHandleMapping();
8642 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8643 (uintptr_t)snapshotTraceBegin);
8644 size_t snapshotTraceBytes = vkReadStream->endTrace();
8645 if (m_state->snapshotsEnabled()) {
8646 m_state->snapshot()->vkCmdBeginRenderPass(
8647 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
8648 pRenderPassBegin, contents);
8649 }
8650 vkReadStream->clearPool();
8651 if (m_queueSubmitWithCommandsEnabled)
8652 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8653 break;
8654 }
8655 case OP_vkCmdNextSubpass: {
8656 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8657 "VkDecoder vkCmdNextSubpass");
8658 VkCommandBuffer commandBuffer;
8659 VkSubpassContents contents;
8660 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8661 uint64_t cgen_var_0;
8662 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8663 *readStreamPtrPtr += 1 * 8;
8664 *(VkCommandBuffer*)&commandBuffer =
8665 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8666 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8667 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8668 // End manual dispatchable handle unboxing for commandBuffer;
8669 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
8670 *readStreamPtrPtr += sizeof(VkSubpassContents);
8671 if (m_logCalls) {
8672 fprintf(stderr, "stream %p: call vkCmdNextSubpass 0x%llx 0x%llx \n", ioStream,
8673 (unsigned long long)commandBuffer, (unsigned long long)contents);
8674 }
8675 vk->vkCmdNextSubpass(unboxed_commandBuffer, contents);
8676 vkStream->unsetHandleMapping();
8677 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8678 (uintptr_t)snapshotTraceBegin);
8679 size_t snapshotTraceBytes = vkReadStream->endTrace();
8680 if (m_state->snapshotsEnabled()) {
8681 m_state->snapshot()->vkCmdNextSubpass(snapshotTraceBegin, snapshotTraceBytes,
8682 &m_pool, commandBuffer, contents);
8683 }
8684 vkReadStream->clearPool();
8685 if (m_queueSubmitWithCommandsEnabled)
8686 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8687 break;
8688 }
8689 case OP_vkCmdEndRenderPass: {
8690 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8691 "VkDecoder vkCmdEndRenderPass");
8692 VkCommandBuffer commandBuffer;
8693 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8694 uint64_t cgen_var_0;
8695 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8696 *readStreamPtrPtr += 1 * 8;
8697 *(VkCommandBuffer*)&commandBuffer =
8698 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8699 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8700 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8701 // End manual dispatchable handle unboxing for commandBuffer;
8702 if (m_logCalls) {
8703 fprintf(stderr, "stream %p: call vkCmdEndRenderPass 0x%llx \n", ioStream,
8704 (unsigned long long)commandBuffer);
8705 }
8706 vk->vkCmdEndRenderPass(unboxed_commandBuffer);
8707 vkStream->unsetHandleMapping();
8708 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8709 (uintptr_t)snapshotTraceBegin);
8710 size_t snapshotTraceBytes = vkReadStream->endTrace();
8711 if (m_state->snapshotsEnabled()) {
8712 m_state->snapshot()->vkCmdEndRenderPass(snapshotTraceBegin, snapshotTraceBytes,
8713 &m_pool, commandBuffer);
8714 }
8715 vkReadStream->clearPool();
8716 if (m_queueSubmitWithCommandsEnabled)
8717 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8718 break;
8719 }
8720 case OP_vkCmdExecuteCommands: {
8721 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8722 "VkDecoder vkCmdExecuteCommands");
8723 VkCommandBuffer commandBuffer;
8724 uint32_t commandBufferCount;
8725 const VkCommandBuffer* pCommandBuffers;
8726 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
8727 uint64_t cgen_var_0;
8728 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8729 *readStreamPtrPtr += 1 * 8;
8730 *(VkCommandBuffer*)&commandBuffer =
8731 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8732 memcpy((uint32_t*)&commandBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
8733 *readStreamPtrPtr += sizeof(uint32_t);
8734 vkReadStream->alloc((void**)&pCommandBuffers,
8735 ((commandBufferCount)) * sizeof(const VkCommandBuffer));
8736 if (((commandBufferCount))) {
8737 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
8738 *readStreamPtrPtr += 8 * ((commandBufferCount));
8739 for (uint32_t k = 0; k < ((commandBufferCount)); ++k) {
8740 uint64_t tmpval;
8741 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
8742 *(((VkCommandBuffer*)pCommandBuffers) + k) =
8743 tmpval ? (VkCommandBuffer)unbox_VkCommandBuffer((VkCommandBuffer)tmpval)
8744 : VK_NULL_HANDLE;
8745 }
8746 }
8747 if (m_logCalls) {
8748 fprintf(stderr, "stream %p: call vkCmdExecuteCommands 0x%llx 0x%llx 0x%llx \n",
8749 ioStream, (unsigned long long)commandBuffer,
8750 (unsigned long long)commandBufferCount,
8751 (unsigned long long)pCommandBuffers);
8752 }
8753 m_state->on_vkCmdExecuteCommands(&m_pool, commandBuffer, commandBufferCount,
8754 pCommandBuffers);
8755 vkStream->unsetHandleMapping();
8756 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8757 (uintptr_t)snapshotTraceBegin);
8758 size_t snapshotTraceBytes = vkReadStream->endTrace();
8759 if (m_state->snapshotsEnabled()) {
8760 m_state->snapshot()->vkCmdExecuteCommands(
8761 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
8762 commandBufferCount, pCommandBuffers);
8763 }
8764 vkReadStream->clearPool();
8765 if (m_queueSubmitWithCommandsEnabled)
8766 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8767 break;
8768 }
8769 #endif
8770 #ifdef VK_VERSION_1_1
8771 case OP_vkEnumerateInstanceVersion: {
8772 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8773 "VkDecoder vkEnumerateInstanceVersion");
8774 uint32_t* pApiVersion;
8775 // Begin manual dispatchable handle unboxing for pApiVersion;
8776 vkReadStream->unsetHandleMapping();
8777 vkReadStream->alloc((void**)&pApiVersion, sizeof(uint32_t));
8778 memcpy((uint32_t*)pApiVersion, *readStreamPtrPtr, sizeof(uint32_t));
8779 *readStreamPtrPtr += sizeof(uint32_t);
8780 if (m_logCalls) {
8781 fprintf(stderr, "stream %p: call vkEnumerateInstanceVersion 0x%llx \n",
8782 ioStream, (unsigned long long)pApiVersion);
8783 }
8784 VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
8785 vkEnumerateInstanceVersion_VkResult_return =
8786 m_state->on_vkEnumerateInstanceVersion(&m_pool, pApiVersion);
8787 if ((vkEnumerateInstanceVersion_VkResult_return) == VK_ERROR_DEVICE_LOST)
8788 m_state->on_DeviceLost();
8789 m_state->on_CheckOutOfMemory(vkEnumerateInstanceVersion_VkResult_return, opcode,
8790 context);
8791 vkStream->unsetHandleMapping();
8792 vkStream->write((uint32_t*)pApiVersion, sizeof(uint32_t));
8793 vkStream->write(&vkEnumerateInstanceVersion_VkResult_return, sizeof(VkResult));
8794 vkStream->commitWrite();
8795 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8796 (uintptr_t)snapshotTraceBegin);
8797 size_t snapshotTraceBytes = vkReadStream->endTrace();
8798 if (m_state->snapshotsEnabled()) {
8799 m_state->snapshot()->vkEnumerateInstanceVersion(
8800 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
8801 vkEnumerateInstanceVersion_VkResult_return, pApiVersion);
8802 }
8803 vkReadStream->clearPool();
8804 if (m_queueSubmitWithCommandsEnabled)
8805 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8806 break;
8807 }
8808 case OP_vkBindBufferMemory2: {
8809 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8810 "VkDecoder vkBindBufferMemory2");
8811 VkDevice device;
8812 uint32_t bindInfoCount;
8813 const VkBindBufferMemoryInfo* pBindInfos;
8814 // Begin global wrapped dispatchable handle unboxing for device;
8815 uint64_t cgen_var_0;
8816 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8817 *readStreamPtrPtr += 1 * 8;
8818 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
8819 memcpy((uint32_t*)&bindInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
8820 *readStreamPtrPtr += sizeof(uint32_t);
8821 vkReadStream->alloc((void**)&pBindInfos,
8822 ((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
8823 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
8824 reservedunmarshal_VkBindBufferMemoryInfo(
8825 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
8826 (VkBindBufferMemoryInfo*)(pBindInfos + i), readStreamPtrPtr);
8827 }
8828 if (pBindInfos) {
8829 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
8830 transform_tohost_VkBindBufferMemoryInfo(
8831 m_state, (VkBindBufferMemoryInfo*)(pBindInfos + i));
8832 }
8833 }
8834 if (m_logCalls) {
8835 fprintf(stderr, "stream %p: call vkBindBufferMemory2 0x%llx 0x%llx 0x%llx \n",
8836 ioStream, (unsigned long long)device, (unsigned long long)bindInfoCount,
8837 (unsigned long long)pBindInfos);
8838 }
8839 VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
8840 vkBindBufferMemory2_VkResult_return =
8841 m_state->on_vkBindBufferMemory2(&m_pool, device, bindInfoCount, pBindInfos);
8842 if ((vkBindBufferMemory2_VkResult_return) == VK_ERROR_DEVICE_LOST)
8843 m_state->on_DeviceLost();
8844 m_state->on_CheckOutOfMemory(vkBindBufferMemory2_VkResult_return, opcode, context);
8845 vkStream->unsetHandleMapping();
8846 vkStream->write(&vkBindBufferMemory2_VkResult_return, sizeof(VkResult));
8847 vkStream->commitWrite();
8848 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8849 (uintptr_t)snapshotTraceBegin);
8850 size_t snapshotTraceBytes = vkReadStream->endTrace();
8851 if (m_state->snapshotsEnabled()) {
8852 m_state->snapshot()->vkBindBufferMemory2(
8853 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
8854 vkBindBufferMemory2_VkResult_return, device, bindInfoCount, pBindInfos);
8855 }
8856 vkReadStream->clearPool();
8857 if (m_queueSubmitWithCommandsEnabled)
8858 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8859 break;
8860 }
8861 case OP_vkBindImageMemory2: {
8862 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8863 "VkDecoder vkBindImageMemory2");
8864 VkDevice device;
8865 uint32_t bindInfoCount;
8866 const VkBindImageMemoryInfo* pBindInfos;
8867 // Begin global wrapped dispatchable handle unboxing for device;
8868 uint64_t cgen_var_0;
8869 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8870 *readStreamPtrPtr += 1 * 8;
8871 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
8872 memcpy((uint32_t*)&bindInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
8873 *readStreamPtrPtr += sizeof(uint32_t);
8874 vkReadStream->alloc((void**)&pBindInfos,
8875 ((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
8876 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
8877 reservedunmarshal_VkBindImageMemoryInfo(
8878 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
8879 (VkBindImageMemoryInfo*)(pBindInfos + i), readStreamPtrPtr);
8880 }
8881 if (pBindInfos) {
8882 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
8883 transform_tohost_VkBindImageMemoryInfo(
8884 m_state, (VkBindImageMemoryInfo*)(pBindInfos + i));
8885 }
8886 }
8887 if (m_logCalls) {
8888 fprintf(stderr, "stream %p: call vkBindImageMemory2 0x%llx 0x%llx 0x%llx \n",
8889 ioStream, (unsigned long long)device, (unsigned long long)bindInfoCount,
8890 (unsigned long long)pBindInfos);
8891 }
8892 VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
8893 vkBindImageMemory2_VkResult_return =
8894 m_state->on_vkBindImageMemory2(&m_pool, device, bindInfoCount, pBindInfos);
8895 if ((vkBindImageMemory2_VkResult_return) == VK_ERROR_DEVICE_LOST)
8896 m_state->on_DeviceLost();
8897 m_state->on_CheckOutOfMemory(vkBindImageMemory2_VkResult_return, opcode, context);
8898 vkStream->unsetHandleMapping();
8899 vkStream->write(&vkBindImageMemory2_VkResult_return, sizeof(VkResult));
8900 vkStream->commitWrite();
8901 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8902 (uintptr_t)snapshotTraceBegin);
8903 size_t snapshotTraceBytes = vkReadStream->endTrace();
8904 if (m_state->snapshotsEnabled()) {
8905 m_state->snapshot()->vkBindImageMemory2(
8906 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
8907 vkBindImageMemory2_VkResult_return, device, bindInfoCount, pBindInfos);
8908 }
8909 vkReadStream->clearPool();
8910 if (m_queueSubmitWithCommandsEnabled)
8911 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8912 break;
8913 }
8914 case OP_vkGetDeviceGroupPeerMemoryFeatures: {
8915 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8916 "VkDecoder vkGetDeviceGroupPeerMemoryFeatures");
8917 VkDevice device;
8918 uint32_t heapIndex;
8919 uint32_t localDeviceIndex;
8920 uint32_t remoteDeviceIndex;
8921 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures;
8922 // Begin non wrapped dispatchable handle unboxing for device;
8923 uint64_t cgen_var_0;
8924 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8925 *readStreamPtrPtr += 1 * 8;
8926 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
8927 auto unboxed_device = unbox_VkDevice(device);
8928 auto vk = dispatch_VkDevice(device);
8929 // End manual dispatchable handle unboxing for device;
8930 memcpy((uint32_t*)&heapIndex, *readStreamPtrPtr, sizeof(uint32_t));
8931 *readStreamPtrPtr += sizeof(uint32_t);
8932 memcpy((uint32_t*)&localDeviceIndex, *readStreamPtrPtr, sizeof(uint32_t));
8933 *readStreamPtrPtr += sizeof(uint32_t);
8934 memcpy((uint32_t*)&remoteDeviceIndex, *readStreamPtrPtr, sizeof(uint32_t));
8935 *readStreamPtrPtr += sizeof(uint32_t);
8936 // Begin manual dispatchable handle unboxing for pPeerMemoryFeatures;
8937 vkReadStream->unsetHandleMapping();
8938 vkReadStream->alloc((void**)&pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
8939 memcpy((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, *readStreamPtrPtr,
8940 sizeof(VkPeerMemoryFeatureFlags));
8941 *readStreamPtrPtr += sizeof(VkPeerMemoryFeatureFlags);
8942 if (m_logCalls) {
8943 fprintf(stderr,
8944 "stream %p: call vkGetDeviceGroupPeerMemoryFeatures 0x%llx 0x%llx "
8945 "0x%llx 0x%llx 0x%llx \n",
8946 ioStream, (unsigned long long)device, (unsigned long long)heapIndex,
8947 (unsigned long long)localDeviceIndex,
8948 (unsigned long long)remoteDeviceIndex,
8949 (unsigned long long)pPeerMemoryFeatures);
8950 }
8951 vk->vkGetDeviceGroupPeerMemoryFeatures(unboxed_device, heapIndex, localDeviceIndex,
8952 remoteDeviceIndex, pPeerMemoryFeatures);
8953 vkStream->unsetHandleMapping();
8954 vkStream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures,
8955 sizeof(VkPeerMemoryFeatureFlags));
8956 vkStream->commitWrite();
8957 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8958 (uintptr_t)snapshotTraceBegin);
8959 size_t snapshotTraceBytes = vkReadStream->endTrace();
8960 if (m_state->snapshotsEnabled()) {
8961 m_state->snapshot()->vkGetDeviceGroupPeerMemoryFeatures(
8962 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, heapIndex,
8963 localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
8964 }
8965 vkReadStream->clearPool();
8966 if (m_queueSubmitWithCommandsEnabled)
8967 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
8968 break;
8969 }
8970 case OP_vkCmdSetDeviceMask: {
8971 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
8972 "VkDecoder vkCmdSetDeviceMask");
8973 VkCommandBuffer commandBuffer;
8974 uint32_t deviceMask;
8975 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
8976 uint64_t cgen_var_0;
8977 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
8978 *readStreamPtrPtr += 1 * 8;
8979 *(VkCommandBuffer*)&commandBuffer =
8980 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
8981 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
8982 auto vk = dispatch_VkCommandBuffer(commandBuffer);
8983 // End manual dispatchable handle unboxing for commandBuffer;
8984 memcpy((uint32_t*)&deviceMask, *readStreamPtrPtr, sizeof(uint32_t));
8985 *readStreamPtrPtr += sizeof(uint32_t);
8986 if (m_logCalls) {
8987 fprintf(stderr, "stream %p: call vkCmdSetDeviceMask 0x%llx 0x%llx \n", ioStream,
8988 (unsigned long long)commandBuffer, (unsigned long long)deviceMask);
8989 }
8990 vk->vkCmdSetDeviceMask(unboxed_commandBuffer, deviceMask);
8991 vkStream->unsetHandleMapping();
8992 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
8993 (uintptr_t)snapshotTraceBegin);
8994 size_t snapshotTraceBytes = vkReadStream->endTrace();
8995 if (m_state->snapshotsEnabled()) {
8996 m_state->snapshot()->vkCmdSetDeviceMask(snapshotTraceBegin, snapshotTraceBytes,
8997 &m_pool, commandBuffer, deviceMask);
8998 }
8999 vkReadStream->clearPool();
9000 if (m_queueSubmitWithCommandsEnabled)
9001 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9002 break;
9003 }
9004 case OP_vkCmdDispatchBase: {
9005 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9006 "VkDecoder vkCmdDispatchBase");
9007 VkCommandBuffer commandBuffer;
9008 uint32_t baseGroupX;
9009 uint32_t baseGroupY;
9010 uint32_t baseGroupZ;
9011 uint32_t groupCountX;
9012 uint32_t groupCountY;
9013 uint32_t groupCountZ;
9014 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
9015 uint64_t cgen_var_0;
9016 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9017 *readStreamPtrPtr += 1 * 8;
9018 *(VkCommandBuffer*)&commandBuffer =
9019 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
9020 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
9021 auto vk = dispatch_VkCommandBuffer(commandBuffer);
9022 // End manual dispatchable handle unboxing for commandBuffer;
9023 memcpy((uint32_t*)&baseGroupX, *readStreamPtrPtr, sizeof(uint32_t));
9024 *readStreamPtrPtr += sizeof(uint32_t);
9025 memcpy((uint32_t*)&baseGroupY, *readStreamPtrPtr, sizeof(uint32_t));
9026 *readStreamPtrPtr += sizeof(uint32_t);
9027 memcpy((uint32_t*)&baseGroupZ, *readStreamPtrPtr, sizeof(uint32_t));
9028 *readStreamPtrPtr += sizeof(uint32_t);
9029 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
9030 *readStreamPtrPtr += sizeof(uint32_t);
9031 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
9032 *readStreamPtrPtr += sizeof(uint32_t);
9033 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
9034 *readStreamPtrPtr += sizeof(uint32_t);
9035 if (m_logCalls) {
9036 fprintf(stderr,
9037 "stream %p: call vkCmdDispatchBase 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
9038 "0x%llx 0x%llx \n",
9039 ioStream, (unsigned long long)commandBuffer,
9040 (unsigned long long)baseGroupX, (unsigned long long)baseGroupY,
9041 (unsigned long long)baseGroupZ, (unsigned long long)groupCountX,
9042 (unsigned long long)groupCountY, (unsigned long long)groupCountZ);
9043 }
9044 vk->vkCmdDispatchBase(unboxed_commandBuffer, baseGroupX, baseGroupY, baseGroupZ,
9045 groupCountX, groupCountY, groupCountZ);
9046 vkStream->unsetHandleMapping();
9047 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9048 (uintptr_t)snapshotTraceBegin);
9049 size_t snapshotTraceBytes = vkReadStream->endTrace();
9050 if (m_state->snapshotsEnabled()) {
9051 m_state->snapshot()->vkCmdDispatchBase(
9052 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, baseGroupX,
9053 baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
9054 }
9055 vkReadStream->clearPool();
9056 if (m_queueSubmitWithCommandsEnabled)
9057 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9058 break;
9059 }
9060 case OP_vkEnumeratePhysicalDeviceGroups: {
9061 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9062 "VkDecoder vkEnumeratePhysicalDeviceGroups");
9063 VkInstance instance;
9064 uint32_t* pPhysicalDeviceGroupCount;
9065 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties;
9066 // Begin global wrapped dispatchable handle unboxing for instance;
9067 uint64_t cgen_var_0;
9068 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9069 *readStreamPtrPtr += 1 * 8;
9070 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
9071 // Begin manual dispatchable handle unboxing for pPhysicalDeviceGroupCount;
9072 vkReadStream->unsetHandleMapping();
9073 // WARNING PTR CHECK
9074 memcpy((uint32_t**)&pPhysicalDeviceGroupCount, (*readStreamPtrPtr), 8);
9075 android::base::Stream::fromBe64((uint8_t*)&pPhysicalDeviceGroupCount);
9076 *readStreamPtrPtr += 8;
9077 if (pPhysicalDeviceGroupCount) {
9078 vkReadStream->alloc((void**)&pPhysicalDeviceGroupCount, sizeof(uint32_t));
9079 memcpy((uint32_t*)pPhysicalDeviceGroupCount, *readStreamPtrPtr,
9080 sizeof(uint32_t));
9081 *readStreamPtrPtr += sizeof(uint32_t);
9082 }
9083 // Begin manual dispatchable handle unboxing for pPhysicalDeviceGroupProperties;
9084 vkReadStream->unsetHandleMapping();
9085 // WARNING PTR CHECK
9086 memcpy((VkPhysicalDeviceGroupProperties**)&pPhysicalDeviceGroupProperties,
9087 (*readStreamPtrPtr), 8);
9088 android::base::Stream::fromBe64((uint8_t*)&pPhysicalDeviceGroupProperties);
9089 *readStreamPtrPtr += 8;
9090 if (pPhysicalDeviceGroupProperties) {
9091 vkReadStream->alloc(
9092 (void**)&pPhysicalDeviceGroupProperties,
9093 (*(pPhysicalDeviceGroupCount)) * sizeof(VkPhysicalDeviceGroupProperties));
9094 for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
9095 reservedunmarshal_VkPhysicalDeviceGroupProperties(
9096 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9097 (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i),
9098 readStreamPtrPtr);
9099 }
9100 }
9101 if (pPhysicalDeviceGroupCount) {
9102 if (pPhysicalDeviceGroupProperties) {
9103 for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
9104 transform_tohost_VkPhysicalDeviceGroupProperties(
9105 m_state,
9106 (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties +
9107 i));
9108 }
9109 }
9110 }
9111 if (m_logCalls) {
9112 fprintf(
9113 stderr,
9114 "stream %p: call vkEnumeratePhysicalDeviceGroups 0x%llx 0x%llx 0x%llx \n",
9115 ioStream, (unsigned long long)instance,
9116 (unsigned long long)pPhysicalDeviceGroupCount,
9117 (unsigned long long)pPhysicalDeviceGroupProperties);
9118 }
9119 VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
9120 vkEnumeratePhysicalDeviceGroups_VkResult_return =
9121 m_state->on_vkEnumeratePhysicalDeviceGroups(&m_pool, instance,
9122 pPhysicalDeviceGroupCount,
9123 pPhysicalDeviceGroupProperties);
9124 if ((vkEnumeratePhysicalDeviceGroups_VkResult_return) == VK_ERROR_DEVICE_LOST)
9125 m_state->on_DeviceLost();
9126 m_state->on_CheckOutOfMemory(vkEnumeratePhysicalDeviceGroups_VkResult_return,
9127 opcode, context);
9128 vkStream->unsetHandleMapping();
9129 // WARNING PTR CHECK
9130 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
9131 vkStream->putBe64(cgen_var_3);
9132 if (pPhysicalDeviceGroupCount) {
9133 vkStream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
9134 }
9135 if (pPhysicalDeviceGroupCount) {
9136 if (pPhysicalDeviceGroupProperties) {
9137 for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
9138 transform_fromhost_VkPhysicalDeviceGroupProperties(
9139 m_state,
9140 (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties +
9141 i));
9142 }
9143 }
9144 }
9145 // WARNING PTR CHECK
9146 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
9147 vkStream->putBe64(cgen_var_4);
9148 if (pPhysicalDeviceGroupProperties) {
9149 if (pPhysicalDeviceGroupCount) {
9150 for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
9151 marshal_VkPhysicalDeviceGroupProperties(
9152 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9153 (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties +
9154 i));
9155 }
9156 }
9157 }
9158 vkStream->write(&vkEnumeratePhysicalDeviceGroups_VkResult_return, sizeof(VkResult));
9159 vkStream->commitWrite();
9160 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9161 (uintptr_t)snapshotTraceBegin);
9162 size_t snapshotTraceBytes = vkReadStream->endTrace();
9163 if (m_state->snapshotsEnabled()) {
9164 m_state->snapshot()->vkEnumeratePhysicalDeviceGroups(
9165 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
9166 vkEnumeratePhysicalDeviceGroups_VkResult_return, instance,
9167 pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
9168 }
9169 vkReadStream->clearPool();
9170 if (m_queueSubmitWithCommandsEnabled)
9171 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9172 break;
9173 }
9174 case OP_vkGetImageMemoryRequirements2: {
9175 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9176 "VkDecoder vkGetImageMemoryRequirements2");
9177 VkDevice device;
9178 const VkImageMemoryRequirementsInfo2* pInfo;
9179 VkMemoryRequirements2* pMemoryRequirements;
9180 // Begin global wrapped dispatchable handle unboxing for device;
9181 uint64_t cgen_var_0;
9182 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9183 *readStreamPtrPtr += 1 * 8;
9184 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
9185 vkReadStream->alloc((void**)&pInfo, sizeof(const VkImageMemoryRequirementsInfo2));
9186 reservedunmarshal_VkImageMemoryRequirementsInfo2(
9187 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9188 (VkImageMemoryRequirementsInfo2*)(pInfo), readStreamPtrPtr);
9189 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
9190 vkReadStream->unsetHandleMapping();
9191 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
9192 reservedunmarshal_VkMemoryRequirements2(
9193 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9194 (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
9195 if (pInfo) {
9196 transform_tohost_VkImageMemoryRequirementsInfo2(
9197 m_state, (VkImageMemoryRequirementsInfo2*)(pInfo));
9198 }
9199 if (pMemoryRequirements) {
9200 transform_tohost_VkMemoryRequirements2(
9201 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
9202 }
9203 if (m_logCalls) {
9204 fprintf(stderr,
9205 "stream %p: call vkGetImageMemoryRequirements2 0x%llx 0x%llx 0x%llx \n",
9206 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
9207 (unsigned long long)pMemoryRequirements);
9208 }
9209 m_state->on_vkGetImageMemoryRequirements2(&m_pool, device, pInfo,
9210 pMemoryRequirements);
9211 vkStream->unsetHandleMapping();
9212 if (pMemoryRequirements) {
9213 transform_fromhost_VkMemoryRequirements2(
9214 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
9215 }
9216 marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9217 (VkMemoryRequirements2*)(pMemoryRequirements));
9218 vkStream->commitWrite();
9219 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9220 (uintptr_t)snapshotTraceBegin);
9221 size_t snapshotTraceBytes = vkReadStream->endTrace();
9222 if (m_state->snapshotsEnabled()) {
9223 m_state->snapshot()->vkGetImageMemoryRequirements2(
9224 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
9225 pMemoryRequirements);
9226 }
9227 vkReadStream->clearPool();
9228 if (m_queueSubmitWithCommandsEnabled)
9229 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9230 break;
9231 }
9232 case OP_vkGetBufferMemoryRequirements2: {
9233 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9234 "VkDecoder vkGetBufferMemoryRequirements2");
9235 VkDevice device;
9236 const VkBufferMemoryRequirementsInfo2* pInfo;
9237 VkMemoryRequirements2* pMemoryRequirements;
9238 // Begin global wrapped dispatchable handle unboxing for device;
9239 uint64_t cgen_var_0;
9240 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9241 *readStreamPtrPtr += 1 * 8;
9242 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
9243 vkReadStream->alloc((void**)&pInfo, sizeof(const VkBufferMemoryRequirementsInfo2));
9244 reservedunmarshal_VkBufferMemoryRequirementsInfo2(
9245 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9246 (VkBufferMemoryRequirementsInfo2*)(pInfo), readStreamPtrPtr);
9247 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
9248 vkReadStream->unsetHandleMapping();
9249 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
9250 reservedunmarshal_VkMemoryRequirements2(
9251 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9252 (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
9253 if (pInfo) {
9254 transform_tohost_VkBufferMemoryRequirementsInfo2(
9255 m_state, (VkBufferMemoryRequirementsInfo2*)(pInfo));
9256 }
9257 if (pMemoryRequirements) {
9258 transform_tohost_VkMemoryRequirements2(
9259 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
9260 }
9261 if (m_logCalls) {
9262 fprintf(
9263 stderr,
9264 "stream %p: call vkGetBufferMemoryRequirements2 0x%llx 0x%llx 0x%llx \n",
9265 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
9266 (unsigned long long)pMemoryRequirements);
9267 }
9268 m_state->on_vkGetBufferMemoryRequirements2(&m_pool, device, pInfo,
9269 pMemoryRequirements);
9270 vkStream->unsetHandleMapping();
9271 if (pMemoryRequirements) {
9272 transform_fromhost_VkMemoryRequirements2(
9273 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
9274 }
9275 marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9276 (VkMemoryRequirements2*)(pMemoryRequirements));
9277 vkStream->commitWrite();
9278 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9279 (uintptr_t)snapshotTraceBegin);
9280 size_t snapshotTraceBytes = vkReadStream->endTrace();
9281 if (m_state->snapshotsEnabled()) {
9282 m_state->snapshot()->vkGetBufferMemoryRequirements2(
9283 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
9284 pMemoryRequirements);
9285 }
9286 vkReadStream->clearPool();
9287 if (m_queueSubmitWithCommandsEnabled)
9288 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9289 break;
9290 }
9291 case OP_vkGetImageSparseMemoryRequirements2: {
9292 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9293 "VkDecoder vkGetImageSparseMemoryRequirements2");
9294 VkDevice device;
9295 const VkImageSparseMemoryRequirementsInfo2* pInfo;
9296 uint32_t* pSparseMemoryRequirementCount;
9297 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements;
9298 // Begin non wrapped dispatchable handle unboxing for device;
9299 uint64_t cgen_var_0;
9300 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9301 *readStreamPtrPtr += 1 * 8;
9302 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
9303 auto unboxed_device = unbox_VkDevice(device);
9304 auto vk = dispatch_VkDevice(device);
9305 // End manual dispatchable handle unboxing for device;
9306 vkReadStream->alloc((void**)&pInfo,
9307 sizeof(const VkImageSparseMemoryRequirementsInfo2));
9308 reservedunmarshal_VkImageSparseMemoryRequirementsInfo2(
9309 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9310 (VkImageSparseMemoryRequirementsInfo2*)(pInfo), readStreamPtrPtr);
9311 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirementCount;
9312 vkReadStream->unsetHandleMapping();
9313 // WARNING PTR CHECK
9314 memcpy((uint32_t**)&pSparseMemoryRequirementCount, (*readStreamPtrPtr), 8);
9315 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirementCount);
9316 *readStreamPtrPtr += 8;
9317 if (pSparseMemoryRequirementCount) {
9318 vkReadStream->alloc((void**)&pSparseMemoryRequirementCount, sizeof(uint32_t));
9319 memcpy((uint32_t*)pSparseMemoryRequirementCount, *readStreamPtrPtr,
9320 sizeof(uint32_t));
9321 *readStreamPtrPtr += sizeof(uint32_t);
9322 }
9323 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirements;
9324 vkReadStream->unsetHandleMapping();
9325 // WARNING PTR CHECK
9326 memcpy((VkSparseImageMemoryRequirements2**)&pSparseMemoryRequirements,
9327 (*readStreamPtrPtr), 8);
9328 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirements);
9329 *readStreamPtrPtr += 8;
9330 if (pSparseMemoryRequirements) {
9331 vkReadStream->alloc((void**)&pSparseMemoryRequirements,
9332 (*(pSparseMemoryRequirementCount)) *
9333 sizeof(VkSparseImageMemoryRequirements2));
9334 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
9335 reservedunmarshal_VkSparseImageMemoryRequirements2(
9336 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9337 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i),
9338 readStreamPtrPtr);
9339 }
9340 }
9341 if (pInfo) {
9342 transform_tohost_VkImageSparseMemoryRequirementsInfo2(
9343 m_state, (VkImageSparseMemoryRequirementsInfo2*)(pInfo));
9344 }
9345 if (pSparseMemoryRequirementCount) {
9346 if (pSparseMemoryRequirements) {
9347 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
9348 ++i) {
9349 transform_tohost_VkSparseImageMemoryRequirements2(
9350 m_state,
9351 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
9352 }
9353 }
9354 }
9355 if (m_logCalls) {
9356 fprintf(stderr,
9357 "stream %p: call vkGetImageSparseMemoryRequirements2 0x%llx 0x%llx "
9358 "0x%llx 0x%llx \n",
9359 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
9360 (unsigned long long)pSparseMemoryRequirementCount,
9361 (unsigned long long)pSparseMemoryRequirements);
9362 }
9363 vk->vkGetImageSparseMemoryRequirements2(unboxed_device, pInfo,
9364 pSparseMemoryRequirementCount,
9365 pSparseMemoryRequirements);
9366 vkStream->unsetHandleMapping();
9367 // WARNING PTR CHECK
9368 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
9369 vkStream->putBe64(cgen_var_3);
9370 if (pSparseMemoryRequirementCount) {
9371 vkStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
9372 }
9373 if (pSparseMemoryRequirementCount) {
9374 if (pSparseMemoryRequirements) {
9375 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
9376 ++i) {
9377 transform_fromhost_VkSparseImageMemoryRequirements2(
9378 m_state,
9379 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
9380 }
9381 }
9382 }
9383 // WARNING PTR CHECK
9384 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
9385 vkStream->putBe64(cgen_var_4);
9386 if (pSparseMemoryRequirements) {
9387 if (pSparseMemoryRequirementCount) {
9388 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
9389 ++i) {
9390 marshal_VkSparseImageMemoryRequirements2(
9391 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9392 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
9393 }
9394 }
9395 }
9396 vkStream->commitWrite();
9397 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9398 (uintptr_t)snapshotTraceBegin);
9399 size_t snapshotTraceBytes = vkReadStream->endTrace();
9400 if (m_state->snapshotsEnabled()) {
9401 m_state->snapshot()->vkGetImageSparseMemoryRequirements2(
9402 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
9403 pSparseMemoryRequirementCount, pSparseMemoryRequirements);
9404 }
9405 vkReadStream->clearPool();
9406 if (m_queueSubmitWithCommandsEnabled)
9407 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9408 break;
9409 }
9410 case OP_vkGetPhysicalDeviceFeatures2: {
9411 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9412 "VkDecoder vkGetPhysicalDeviceFeatures2");
9413 VkPhysicalDevice physicalDevice;
9414 VkPhysicalDeviceFeatures2* pFeatures;
9415 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
9416 uint64_t cgen_var_0;
9417 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9418 *readStreamPtrPtr += 1 * 8;
9419 *(VkPhysicalDevice*)&physicalDevice =
9420 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
9421 // Begin manual dispatchable handle unboxing for pFeatures;
9422 vkReadStream->unsetHandleMapping();
9423 vkReadStream->alloc((void**)&pFeatures, sizeof(VkPhysicalDeviceFeatures2));
9424 reservedunmarshal_VkPhysicalDeviceFeatures2(
9425 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9426 (VkPhysicalDeviceFeatures2*)(pFeatures), readStreamPtrPtr);
9427 if (pFeatures) {
9428 transform_tohost_VkPhysicalDeviceFeatures2(
9429 m_state, (VkPhysicalDeviceFeatures2*)(pFeatures));
9430 }
9431 if (m_logCalls) {
9432 fprintf(stderr, "stream %p: call vkGetPhysicalDeviceFeatures2 0x%llx 0x%llx \n",
9433 ioStream, (unsigned long long)physicalDevice,
9434 (unsigned long long)pFeatures);
9435 }
9436 m_state->on_vkGetPhysicalDeviceFeatures2(&m_pool, physicalDevice, pFeatures);
9437 vkStream->unsetHandleMapping();
9438 if (pFeatures) {
9439 transform_fromhost_VkPhysicalDeviceFeatures2(
9440 m_state, (VkPhysicalDeviceFeatures2*)(pFeatures));
9441 }
9442 marshal_VkPhysicalDeviceFeatures2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9443 (VkPhysicalDeviceFeatures2*)(pFeatures));
9444 vkStream->commitWrite();
9445 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9446 (uintptr_t)snapshotTraceBegin);
9447 size_t snapshotTraceBytes = vkReadStream->endTrace();
9448 if (m_state->snapshotsEnabled()) {
9449 m_state->snapshot()->vkGetPhysicalDeviceFeatures2(
9450 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice, pFeatures);
9451 }
9452 vkReadStream->clearPool();
9453 if (m_queueSubmitWithCommandsEnabled)
9454 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9455 break;
9456 }
9457 case OP_vkGetPhysicalDeviceProperties2: {
9458 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9459 "VkDecoder vkGetPhysicalDeviceProperties2");
9460 VkPhysicalDevice physicalDevice;
9461 VkPhysicalDeviceProperties2* pProperties;
9462 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
9463 uint64_t cgen_var_0;
9464 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9465 *readStreamPtrPtr += 1 * 8;
9466 *(VkPhysicalDevice*)&physicalDevice =
9467 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
9468 // Begin manual dispatchable handle unboxing for pProperties;
9469 vkReadStream->unsetHandleMapping();
9470 vkReadStream->alloc((void**)&pProperties, sizeof(VkPhysicalDeviceProperties2));
9471 reservedunmarshal_VkPhysicalDeviceProperties2(
9472 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9473 (VkPhysicalDeviceProperties2*)(pProperties), readStreamPtrPtr);
9474 if (pProperties) {
9475 transform_tohost_VkPhysicalDeviceProperties2(
9476 m_state, (VkPhysicalDeviceProperties2*)(pProperties));
9477 }
9478 if (m_logCalls) {
9479 fprintf(stderr,
9480 "stream %p: call vkGetPhysicalDeviceProperties2 0x%llx 0x%llx \n",
9481 ioStream, (unsigned long long)physicalDevice,
9482 (unsigned long long)pProperties);
9483 }
9484 m_state->on_vkGetPhysicalDeviceProperties2(&m_pool, physicalDevice, pProperties);
9485 vkStream->unsetHandleMapping();
9486 if (pProperties) {
9487 transform_fromhost_VkPhysicalDeviceProperties2(
9488 m_state, (VkPhysicalDeviceProperties2*)(pProperties));
9489 }
9490 marshal_VkPhysicalDeviceProperties2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9491 (VkPhysicalDeviceProperties2*)(pProperties));
9492 vkStream->commitWrite();
9493 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9494 (uintptr_t)snapshotTraceBegin);
9495 size_t snapshotTraceBytes = vkReadStream->endTrace();
9496 if (m_state->snapshotsEnabled()) {
9497 m_state->snapshot()->vkGetPhysicalDeviceProperties2(
9498 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
9499 pProperties);
9500 }
9501 vkReadStream->clearPool();
9502 if (m_queueSubmitWithCommandsEnabled)
9503 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9504 break;
9505 }
9506 case OP_vkGetPhysicalDeviceFormatProperties2: {
9507 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9508 "VkDecoder vkGetPhysicalDeviceFormatProperties2");
9509 VkPhysicalDevice physicalDevice;
9510 VkFormat format;
9511 VkFormatProperties2* pFormatProperties;
9512 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
9513 uint64_t cgen_var_0;
9514 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9515 *readStreamPtrPtr += 1 * 8;
9516 *(VkPhysicalDevice*)&physicalDevice =
9517 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
9518 memcpy((VkFormat*)&format, *readStreamPtrPtr, sizeof(VkFormat));
9519 *readStreamPtrPtr += sizeof(VkFormat);
9520 // Begin manual dispatchable handle unboxing for pFormatProperties;
9521 vkReadStream->unsetHandleMapping();
9522 vkReadStream->alloc((void**)&pFormatProperties, sizeof(VkFormatProperties2));
9523 reservedunmarshal_VkFormatProperties2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9524 (VkFormatProperties2*)(pFormatProperties),
9525 readStreamPtrPtr);
9526 if (pFormatProperties) {
9527 transform_tohost_VkFormatProperties2(m_state,
9528 (VkFormatProperties2*)(pFormatProperties));
9529 }
9530 if (m_logCalls) {
9531 fprintf(stderr,
9532 "stream %p: call vkGetPhysicalDeviceFormatProperties2 0x%llx 0x%llx "
9533 "0x%llx \n",
9534 ioStream, (unsigned long long)physicalDevice,
9535 (unsigned long long)format, (unsigned long long)pFormatProperties);
9536 }
9537 m_state->on_vkGetPhysicalDeviceFormatProperties2(&m_pool, physicalDevice, format,
9538 pFormatProperties);
9539 vkStream->unsetHandleMapping();
9540 if (pFormatProperties) {
9541 transform_fromhost_VkFormatProperties2(
9542 m_state, (VkFormatProperties2*)(pFormatProperties));
9543 }
9544 marshal_VkFormatProperties2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9545 (VkFormatProperties2*)(pFormatProperties));
9546 vkStream->commitWrite();
9547 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9548 (uintptr_t)snapshotTraceBegin);
9549 size_t snapshotTraceBytes = vkReadStream->endTrace();
9550 if (m_state->snapshotsEnabled()) {
9551 m_state->snapshot()->vkGetPhysicalDeviceFormatProperties2(
9552 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice, format,
9553 pFormatProperties);
9554 }
9555 vkReadStream->clearPool();
9556 if (m_queueSubmitWithCommandsEnabled)
9557 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9558 break;
9559 }
9560 case OP_vkGetPhysicalDeviceImageFormatProperties2: {
9561 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9562 "VkDecoder vkGetPhysicalDeviceImageFormatProperties2");
9563 VkPhysicalDevice physicalDevice;
9564 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo;
9565 VkImageFormatProperties2* pImageFormatProperties;
9566 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
9567 uint64_t cgen_var_0;
9568 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9569 *readStreamPtrPtr += 1 * 8;
9570 *(VkPhysicalDevice*)&physicalDevice =
9571 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
9572 vkReadStream->alloc((void**)&pImageFormatInfo,
9573 sizeof(const VkPhysicalDeviceImageFormatInfo2));
9574 reservedunmarshal_VkPhysicalDeviceImageFormatInfo2(
9575 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9576 (VkPhysicalDeviceImageFormatInfo2*)(pImageFormatInfo), readStreamPtrPtr);
9577 // Begin manual dispatchable handle unboxing for pImageFormatProperties;
9578 vkReadStream->unsetHandleMapping();
9579 vkReadStream->alloc((void**)&pImageFormatProperties,
9580 sizeof(VkImageFormatProperties2));
9581 reservedunmarshal_VkImageFormatProperties2(
9582 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9583 (VkImageFormatProperties2*)(pImageFormatProperties), readStreamPtrPtr);
9584 if (pImageFormatInfo) {
9585 transform_tohost_VkPhysicalDeviceImageFormatInfo2(
9586 m_state, (VkPhysicalDeviceImageFormatInfo2*)(pImageFormatInfo));
9587 }
9588 if (pImageFormatProperties) {
9589 transform_tohost_VkImageFormatProperties2(
9590 m_state, (VkImageFormatProperties2*)(pImageFormatProperties));
9591 }
9592 if (m_logCalls) {
9593 fprintf(stderr,
9594 "stream %p: call vkGetPhysicalDeviceImageFormatProperties2 0x%llx "
9595 "0x%llx 0x%llx \n",
9596 ioStream, (unsigned long long)physicalDevice,
9597 (unsigned long long)pImageFormatInfo,
9598 (unsigned long long)pImageFormatProperties);
9599 }
9600 VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
9601 vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
9602 m_state->on_vkGetPhysicalDeviceImageFormatProperties2(
9603 &m_pool, physicalDevice, pImageFormatInfo, pImageFormatProperties);
9604 if ((vkGetPhysicalDeviceImageFormatProperties2_VkResult_return) ==
9605 VK_ERROR_DEVICE_LOST)
9606 m_state->on_DeviceLost();
9607 m_state->on_CheckOutOfMemory(
9608 vkGetPhysicalDeviceImageFormatProperties2_VkResult_return, opcode, context);
9609 vkStream->unsetHandleMapping();
9610 if (pImageFormatProperties) {
9611 transform_fromhost_VkImageFormatProperties2(
9612 m_state, (VkImageFormatProperties2*)(pImageFormatProperties));
9613 }
9614 marshal_VkImageFormatProperties2(
9615 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9616 (VkImageFormatProperties2*)(pImageFormatProperties));
9617 vkStream->write(&vkGetPhysicalDeviceImageFormatProperties2_VkResult_return,
9618 sizeof(VkResult));
9619 vkStream->commitWrite();
9620 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9621 (uintptr_t)snapshotTraceBegin);
9622 size_t snapshotTraceBytes = vkReadStream->endTrace();
9623 if (m_state->snapshotsEnabled()) {
9624 m_state->snapshot()->vkGetPhysicalDeviceImageFormatProperties2(
9625 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
9626 vkGetPhysicalDeviceImageFormatProperties2_VkResult_return, physicalDevice,
9627 pImageFormatInfo, pImageFormatProperties);
9628 }
9629 vkReadStream->clearPool();
9630 if (m_queueSubmitWithCommandsEnabled)
9631 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9632 break;
9633 }
9634 case OP_vkGetPhysicalDeviceQueueFamilyProperties2: {
9635 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9636 "VkDecoder vkGetPhysicalDeviceQueueFamilyProperties2");
9637 VkPhysicalDevice physicalDevice;
9638 uint32_t* pQueueFamilyPropertyCount;
9639 VkQueueFamilyProperties2* pQueueFamilyProperties;
9640 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
9641 uint64_t cgen_var_0;
9642 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9643 *readStreamPtrPtr += 1 * 8;
9644 *(VkPhysicalDevice*)&physicalDevice =
9645 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
9646 // Begin manual dispatchable handle unboxing for pQueueFamilyPropertyCount;
9647 vkReadStream->unsetHandleMapping();
9648 // WARNING PTR CHECK
9649 memcpy((uint32_t**)&pQueueFamilyPropertyCount, (*readStreamPtrPtr), 8);
9650 android::base::Stream::fromBe64((uint8_t*)&pQueueFamilyPropertyCount);
9651 *readStreamPtrPtr += 8;
9652 if (pQueueFamilyPropertyCount) {
9653 vkReadStream->alloc((void**)&pQueueFamilyPropertyCount, sizeof(uint32_t));
9654 memcpy((uint32_t*)pQueueFamilyPropertyCount, *readStreamPtrPtr,
9655 sizeof(uint32_t));
9656 *readStreamPtrPtr += sizeof(uint32_t);
9657 }
9658 // Begin manual dispatchable handle unboxing for pQueueFamilyProperties;
9659 vkReadStream->unsetHandleMapping();
9660 // WARNING PTR CHECK
9661 memcpy((VkQueueFamilyProperties2**)&pQueueFamilyProperties, (*readStreamPtrPtr), 8);
9662 android::base::Stream::fromBe64((uint8_t*)&pQueueFamilyProperties);
9663 *readStreamPtrPtr += 8;
9664 if (pQueueFamilyProperties) {
9665 vkReadStream->alloc(
9666 (void**)&pQueueFamilyProperties,
9667 (*(pQueueFamilyPropertyCount)) * sizeof(VkQueueFamilyProperties2));
9668 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
9669 reservedunmarshal_VkQueueFamilyProperties2(
9670 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9671 (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i),
9672 readStreamPtrPtr);
9673 }
9674 }
9675 if (pQueueFamilyPropertyCount) {
9676 if (pQueueFamilyProperties) {
9677 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
9678 transform_tohost_VkQueueFamilyProperties2(
9679 m_state, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
9680 }
9681 }
9682 }
9683 if (m_logCalls) {
9684 fprintf(stderr,
9685 "stream %p: call vkGetPhysicalDeviceQueueFamilyProperties2 0x%llx "
9686 "0x%llx 0x%llx \n",
9687 ioStream, (unsigned long long)physicalDevice,
9688 (unsigned long long)pQueueFamilyPropertyCount,
9689 (unsigned long long)pQueueFamilyProperties);
9690 }
9691 m_state->on_vkGetPhysicalDeviceQueueFamilyProperties2(
9692 &m_pool, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
9693 vkStream->unsetHandleMapping();
9694 // WARNING PTR CHECK
9695 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
9696 vkStream->putBe64(cgen_var_3);
9697 if (pQueueFamilyPropertyCount) {
9698 vkStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
9699 }
9700 if (pQueueFamilyPropertyCount) {
9701 if (pQueueFamilyProperties) {
9702 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
9703 transform_fromhost_VkQueueFamilyProperties2(
9704 m_state, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
9705 }
9706 }
9707 }
9708 // WARNING PTR CHECK
9709 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
9710 vkStream->putBe64(cgen_var_4);
9711 if (pQueueFamilyProperties) {
9712 if (pQueueFamilyPropertyCount) {
9713 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
9714 marshal_VkQueueFamilyProperties2(
9715 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9716 (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
9717 }
9718 }
9719 }
9720 vkStream->commitWrite();
9721 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9722 (uintptr_t)snapshotTraceBegin);
9723 size_t snapshotTraceBytes = vkReadStream->endTrace();
9724 if (m_state->snapshotsEnabled()) {
9725 m_state->snapshot()->vkGetPhysicalDeviceQueueFamilyProperties2(
9726 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
9727 pQueueFamilyPropertyCount, pQueueFamilyProperties);
9728 }
9729 vkReadStream->clearPool();
9730 if (m_queueSubmitWithCommandsEnabled)
9731 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9732 break;
9733 }
9734 case OP_vkGetPhysicalDeviceMemoryProperties2: {
9735 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9736 "VkDecoder vkGetPhysicalDeviceMemoryProperties2");
9737 VkPhysicalDevice physicalDevice;
9738 VkPhysicalDeviceMemoryProperties2* pMemoryProperties;
9739 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
9740 uint64_t cgen_var_0;
9741 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9742 *readStreamPtrPtr += 1 * 8;
9743 *(VkPhysicalDevice*)&physicalDevice =
9744 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
9745 // Begin manual dispatchable handle unboxing for pMemoryProperties;
9746 vkReadStream->unsetHandleMapping();
9747 vkReadStream->alloc((void**)&pMemoryProperties,
9748 sizeof(VkPhysicalDeviceMemoryProperties2));
9749 reservedunmarshal_VkPhysicalDeviceMemoryProperties2(
9750 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9751 (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), readStreamPtrPtr);
9752 if (pMemoryProperties) {
9753 transform_tohost_VkPhysicalDeviceMemoryProperties2(
9754 m_state, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
9755 }
9756 if (m_logCalls) {
9757 fprintf(stderr,
9758 "stream %p: call vkGetPhysicalDeviceMemoryProperties2 0x%llx 0x%llx \n",
9759 ioStream, (unsigned long long)physicalDevice,
9760 (unsigned long long)pMemoryProperties);
9761 }
9762 m_state->on_vkGetPhysicalDeviceMemoryProperties2(&m_pool, physicalDevice,
9763 pMemoryProperties);
9764 vkStream->unsetHandleMapping();
9765 if (pMemoryProperties) {
9766 transform_fromhost_VkPhysicalDeviceMemoryProperties2(
9767 m_state, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
9768 }
9769 marshal_VkPhysicalDeviceMemoryProperties2(
9770 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9771 (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
9772 vkStream->commitWrite();
9773 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9774 (uintptr_t)snapshotTraceBegin);
9775 size_t snapshotTraceBytes = vkReadStream->endTrace();
9776 if (m_state->snapshotsEnabled()) {
9777 m_state->snapshot()->vkGetPhysicalDeviceMemoryProperties2(
9778 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
9779 pMemoryProperties);
9780 }
9781 vkReadStream->clearPool();
9782 if (m_queueSubmitWithCommandsEnabled)
9783 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9784 break;
9785 }
9786 case OP_vkGetPhysicalDeviceSparseImageFormatProperties2: {
9787 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9788 "VkDecoder vkGetPhysicalDeviceSparseImageFormatProperties2");
9789 VkPhysicalDevice physicalDevice;
9790 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo;
9791 uint32_t* pPropertyCount;
9792 VkSparseImageFormatProperties2* pProperties;
9793 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
9794 uint64_t cgen_var_0;
9795 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9796 *readStreamPtrPtr += 1 * 8;
9797 *(VkPhysicalDevice*)&physicalDevice =
9798 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
9799 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
9800 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
9801 // End manual dispatchable handle unboxing for physicalDevice;
9802 vkReadStream->alloc((void**)&pFormatInfo,
9803 sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
9804 reservedunmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
9805 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9806 (VkPhysicalDeviceSparseImageFormatInfo2*)(pFormatInfo), readStreamPtrPtr);
9807 // Begin manual dispatchable handle unboxing for pPropertyCount;
9808 vkReadStream->unsetHandleMapping();
9809 // WARNING PTR CHECK
9810 memcpy((uint32_t**)&pPropertyCount, (*readStreamPtrPtr), 8);
9811 android::base::Stream::fromBe64((uint8_t*)&pPropertyCount);
9812 *readStreamPtrPtr += 8;
9813 if (pPropertyCount) {
9814 vkReadStream->alloc((void**)&pPropertyCount, sizeof(uint32_t));
9815 memcpy((uint32_t*)pPropertyCount, *readStreamPtrPtr, sizeof(uint32_t));
9816 *readStreamPtrPtr += sizeof(uint32_t);
9817 }
9818 // Begin manual dispatchable handle unboxing for pProperties;
9819 vkReadStream->unsetHandleMapping();
9820 // WARNING PTR CHECK
9821 memcpy((VkSparseImageFormatProperties2**)&pProperties, (*readStreamPtrPtr), 8);
9822 android::base::Stream::fromBe64((uint8_t*)&pProperties);
9823 *readStreamPtrPtr += 8;
9824 if (pProperties) {
9825 vkReadStream->alloc(
9826 (void**)&pProperties,
9827 (*(pPropertyCount)) * sizeof(VkSparseImageFormatProperties2));
9828 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
9829 reservedunmarshal_VkSparseImageFormatProperties2(
9830 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9831 (VkSparseImageFormatProperties2*)(pProperties + i), readStreamPtrPtr);
9832 }
9833 }
9834 if (pFormatInfo) {
9835 transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2(
9836 m_state, (VkPhysicalDeviceSparseImageFormatInfo2*)(pFormatInfo));
9837 }
9838 if (pPropertyCount) {
9839 if (pProperties) {
9840 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
9841 transform_tohost_VkSparseImageFormatProperties2(
9842 m_state, (VkSparseImageFormatProperties2*)(pProperties + i));
9843 }
9844 }
9845 }
9846 if (m_logCalls) {
9847 fprintf(stderr,
9848 "stream %p: call vkGetPhysicalDeviceSparseImageFormatProperties2 "
9849 "0x%llx 0x%llx 0x%llx 0x%llx \n",
9850 ioStream, (unsigned long long)physicalDevice,
9851 (unsigned long long)pFormatInfo, (unsigned long long)pPropertyCount,
9852 (unsigned long long)pProperties);
9853 }
9854 vk->vkGetPhysicalDeviceSparseImageFormatProperties2(
9855 unboxed_physicalDevice, pFormatInfo, pPropertyCount, pProperties);
9856 vkStream->unsetHandleMapping();
9857 // WARNING PTR CHECK
9858 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pPropertyCount;
9859 vkStream->putBe64(cgen_var_3);
9860 if (pPropertyCount) {
9861 vkStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
9862 }
9863 if (pPropertyCount) {
9864 if (pProperties) {
9865 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
9866 transform_fromhost_VkSparseImageFormatProperties2(
9867 m_state, (VkSparseImageFormatProperties2*)(pProperties + i));
9868 }
9869 }
9870 }
9871 // WARNING PTR CHECK
9872 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pProperties;
9873 vkStream->putBe64(cgen_var_4);
9874 if (pProperties) {
9875 if (pPropertyCount) {
9876 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
9877 marshal_VkSparseImageFormatProperties2(
9878 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9879 (VkSparseImageFormatProperties2*)(pProperties + i));
9880 }
9881 }
9882 }
9883 vkStream->commitWrite();
9884 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9885 (uintptr_t)snapshotTraceBegin);
9886 size_t snapshotTraceBytes = vkReadStream->endTrace();
9887 if (m_state->snapshotsEnabled()) {
9888 m_state->snapshot()->vkGetPhysicalDeviceSparseImageFormatProperties2(
9889 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
9890 pFormatInfo, pPropertyCount, pProperties);
9891 }
9892 vkReadStream->clearPool();
9893 if (m_queueSubmitWithCommandsEnabled)
9894 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9895 break;
9896 }
9897 case OP_vkTrimCommandPool: {
9898 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9899 "VkDecoder vkTrimCommandPool");
9900 VkDevice device;
9901 VkCommandPool commandPool;
9902 VkCommandPoolTrimFlags flags;
9903 // Begin non wrapped dispatchable handle unboxing for device;
9904 uint64_t cgen_var_0;
9905 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9906 *readStreamPtrPtr += 1 * 8;
9907 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
9908 auto unboxed_device = unbox_VkDevice(device);
9909 auto vk = dispatch_VkDevice(device);
9910 // End manual dispatchable handle unboxing for device;
9911 uint64_t cgen_var_1;
9912 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
9913 *readStreamPtrPtr += 1 * 8;
9914 *(VkCommandPool*)&commandPool =
9915 (VkCommandPool)unbox_VkCommandPool((VkCommandPool)(*&cgen_var_1));
9916 memcpy((VkCommandPoolTrimFlags*)&flags, *readStreamPtrPtr,
9917 sizeof(VkCommandPoolTrimFlags));
9918 *readStreamPtrPtr += sizeof(VkCommandPoolTrimFlags);
9919 if (m_logCalls) {
9920 fprintf(stderr, "stream %p: call vkTrimCommandPool 0x%llx 0x%llx 0x%llx \n",
9921 ioStream, (unsigned long long)device, (unsigned long long)commandPool,
9922 (unsigned long long)flags);
9923 }
9924 vk->vkTrimCommandPool(unboxed_device, commandPool, flags);
9925 vkStream->unsetHandleMapping();
9926 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9927 (uintptr_t)snapshotTraceBegin);
9928 size_t snapshotTraceBytes = vkReadStream->endTrace();
9929 if (m_state->snapshotsEnabled()) {
9930 m_state->snapshot()->vkTrimCommandPool(snapshotTraceBegin, snapshotTraceBytes,
9931 &m_pool, device, commandPool, flags);
9932 }
9933 vkReadStream->clearPool();
9934 if (m_queueSubmitWithCommandsEnabled)
9935 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9936 break;
9937 }
9938 case OP_vkGetDeviceQueue2: {
9939 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9940 "VkDecoder vkGetDeviceQueue2");
9941 VkDevice device;
9942 const VkDeviceQueueInfo2* pQueueInfo;
9943 VkQueue* pQueue;
9944 // Begin global wrapped dispatchable handle unboxing for device;
9945 uint64_t cgen_var_0;
9946 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9947 *readStreamPtrPtr += 1 * 8;
9948 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
9949 vkReadStream->alloc((void**)&pQueueInfo, sizeof(const VkDeviceQueueInfo2));
9950 reservedunmarshal_VkDeviceQueueInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
9951 (VkDeviceQueueInfo2*)(pQueueInfo),
9952 readStreamPtrPtr);
9953 // Begin manual dispatchable handle unboxing for pQueue;
9954 vkReadStream->unsetHandleMapping();
9955 vkReadStream->alloc((void**)&pQueue, sizeof(VkQueue));
9956 uint64_t cgen_var_1;
9957 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 8);
9958 *readStreamPtrPtr += 8;
9959 *(VkQueue*)pQueue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_1));
9960 if (pQueueInfo) {
9961 transform_tohost_VkDeviceQueueInfo2(m_state, (VkDeviceQueueInfo2*)(pQueueInfo));
9962 }
9963 if (m_logCalls) {
9964 fprintf(stderr, "stream %p: call vkGetDeviceQueue2 0x%llx 0x%llx 0x%llx \n",
9965 ioStream, (unsigned long long)device, (unsigned long long)pQueueInfo,
9966 (unsigned long long)pQueue);
9967 }
9968 m_state->on_vkGetDeviceQueue2(&m_pool, device, pQueueInfo, pQueue);
9969 vkStream->unsetHandleMapping();
9970 uint64_t cgen_var_2;
9971 static_assert(8 == sizeof(VkQueue),
9972 "handle map overwrite requires VkQueue to be 8 bytes long");
9973 vkStream->handleMapping()->mapHandles_VkQueue((VkQueue*)pQueue, 1);
9974 vkStream->write((VkQueue*)pQueue, 8 * 1);
9975 vkStream->commitWrite();
9976 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
9977 (uintptr_t)snapshotTraceBegin);
9978 size_t snapshotTraceBytes = vkReadStream->endTrace();
9979 if (m_state->snapshotsEnabled()) {
9980 m_state->snapshot()->vkGetDeviceQueue2(snapshotTraceBegin, snapshotTraceBytes,
9981 &m_pool, device, pQueueInfo, pQueue);
9982 }
9983 vkReadStream->clearPool();
9984 if (m_queueSubmitWithCommandsEnabled)
9985 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
9986 break;
9987 }
9988 case OP_vkCreateSamplerYcbcrConversion: {
9989 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
9990 "VkDecoder vkCreateSamplerYcbcrConversion");
9991 VkDevice device;
9992 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo;
9993 const VkAllocationCallbacks* pAllocator;
9994 VkSamplerYcbcrConversion* pYcbcrConversion;
9995 // Begin global wrapped dispatchable handle unboxing for device;
9996 uint64_t cgen_var_0;
9997 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
9998 *readStreamPtrPtr += 1 * 8;
9999 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
10000 vkReadStream->alloc((void**)&pCreateInfo,
10001 sizeof(const VkSamplerYcbcrConversionCreateInfo));
10002 reservedunmarshal_VkSamplerYcbcrConversionCreateInfo(
10003 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10004 (VkSamplerYcbcrConversionCreateInfo*)(pCreateInfo), readStreamPtrPtr);
10005 // WARNING PTR CHECK
10006 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
10007 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
10008 *readStreamPtrPtr += 8;
10009 if (pAllocator) {
10010 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
10011 reservedunmarshal_VkAllocationCallbacks(
10012 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10013 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
10014 }
10015 // Begin manual dispatchable handle unboxing for pYcbcrConversion;
10016 vkReadStream->unsetHandleMapping();
10017 vkReadStream->alloc((void**)&pYcbcrConversion, sizeof(VkSamplerYcbcrConversion));
10018 uint64_t cgen_var_2;
10019 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
10020 *readStreamPtrPtr += 8;
10021 *(VkSamplerYcbcrConversion*)pYcbcrConversion =
10022 (VkSamplerYcbcrConversion)(VkSamplerYcbcrConversion)((
10023 VkSamplerYcbcrConversion)(*&cgen_var_2));
10024 if (pCreateInfo) {
10025 transform_tohost_VkSamplerYcbcrConversionCreateInfo(
10026 m_state, (VkSamplerYcbcrConversionCreateInfo*)(pCreateInfo));
10027 }
10028 if (pAllocator) {
10029 transform_tohost_VkAllocationCallbacks(m_state,
10030 (VkAllocationCallbacks*)(pAllocator));
10031 }
10032 if (m_logCalls) {
10033 fprintf(stderr,
10034 "stream %p: call vkCreateSamplerYcbcrConversion 0x%llx 0x%llx 0x%llx "
10035 "0x%llx \n",
10036 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
10037 (unsigned long long)pAllocator, (unsigned long long)pYcbcrConversion);
10038 }
10039 VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
10040 vkCreateSamplerYcbcrConversion_VkResult_return =
10041 m_state->on_vkCreateSamplerYcbcrConversion(&m_pool, device, pCreateInfo,
10042 pAllocator, pYcbcrConversion);
10043 if ((vkCreateSamplerYcbcrConversion_VkResult_return) == VK_ERROR_DEVICE_LOST)
10044 m_state->on_DeviceLost();
10045 m_state->on_CheckOutOfMemory(vkCreateSamplerYcbcrConversion_VkResult_return, opcode,
10046 context);
10047 vkStream->unsetHandleMapping();
10048 // Begin manual non dispatchable handle create for pYcbcrConversion;
10049 vkStream->unsetHandleMapping();
10050 uint64_t cgen_var_3;
10051 static_assert(
10052 8 == sizeof(VkSamplerYcbcrConversion),
10053 "handle map overwrite requires VkSamplerYcbcrConversion to be 8 bytes long");
10054 vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion(
10055 (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
10056 vkStream->write((VkSamplerYcbcrConversion*)pYcbcrConversion, 8 * 1);
10057 // Begin manual non dispatchable handle create for pYcbcrConversion;
10058 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
10059 vkStream->write(&vkCreateSamplerYcbcrConversion_VkResult_return, sizeof(VkResult));
10060 vkStream->commitWrite();
10061 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10062 (uintptr_t)snapshotTraceBegin);
10063 size_t snapshotTraceBytes = vkReadStream->endTrace();
10064 if (m_state->snapshotsEnabled()) {
10065 m_state->snapshot()->vkCreateSamplerYcbcrConversion(
10066 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
10067 vkCreateSamplerYcbcrConversion_VkResult_return, device, pCreateInfo,
10068 pAllocator, pYcbcrConversion);
10069 }
10070 vkReadStream->clearPool();
10071 if (m_queueSubmitWithCommandsEnabled)
10072 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10073 break;
10074 }
10075 case OP_vkDestroySamplerYcbcrConversion: {
10076 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10077 "VkDecoder vkDestroySamplerYcbcrConversion");
10078 VkDevice device;
10079 VkSamplerYcbcrConversion ycbcrConversion;
10080 const VkAllocationCallbacks* pAllocator;
10081 // Begin global wrapped dispatchable handle unboxing for device;
10082 uint64_t cgen_var_0;
10083 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10084 *readStreamPtrPtr += 1 * 8;
10085 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
10086 // Begin manual non dispatchable handle destroy unboxing for ycbcrConversion;
10087 VkSamplerYcbcrConversion boxed_ycbcrConversion_preserve;
10088 uint64_t cgen_var_1;
10089 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
10090 *readStreamPtrPtr += 1 * 8;
10091 *(VkSamplerYcbcrConversion*)&ycbcrConversion =
10092 (VkSamplerYcbcrConversion)(VkSamplerYcbcrConversion)((
10093 VkSamplerYcbcrConversion)(*&cgen_var_1));
10094 boxed_ycbcrConversion_preserve = ycbcrConversion;
10095 ycbcrConversion = try_unbox_VkSamplerYcbcrConversion(ycbcrConversion);
10096 // WARNING PTR CHECK
10097 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
10098 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
10099 *readStreamPtrPtr += 8;
10100 if (pAllocator) {
10101 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
10102 reservedunmarshal_VkAllocationCallbacks(
10103 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10104 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
10105 }
10106 if (pAllocator) {
10107 transform_tohost_VkAllocationCallbacks(m_state,
10108 (VkAllocationCallbacks*)(pAllocator));
10109 }
10110 if (m_logCalls) {
10111 fprintf(
10112 stderr,
10113 "stream %p: call vkDestroySamplerYcbcrConversion 0x%llx 0x%llx 0x%llx \n",
10114 ioStream, (unsigned long long)device, (unsigned long long)ycbcrConversion,
10115 (unsigned long long)pAllocator);
10116 }
10117 m_state->on_vkDestroySamplerYcbcrConversion(&m_pool, device, ycbcrConversion,
10118 pAllocator);
10119 vkStream->unsetHandleMapping();
10120 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10121 (uintptr_t)snapshotTraceBegin);
10122 size_t snapshotTraceBytes = vkReadStream->endTrace();
10123 if (m_state->snapshotsEnabled()) {
10124 m_state->snapshot()->vkDestroySamplerYcbcrConversion(
10125 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
10126 boxed_ycbcrConversion_preserve, pAllocator);
10127 }
10128 delete_VkSamplerYcbcrConversion(boxed_ycbcrConversion_preserve);
10129 vkReadStream->clearPool();
10130 if (m_queueSubmitWithCommandsEnabled)
10131 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10132 break;
10133 }
10134 case OP_vkCreateDescriptorUpdateTemplate: {
10135 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10136 "VkDecoder vkCreateDescriptorUpdateTemplate");
10137 VkDevice device;
10138 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo;
10139 const VkAllocationCallbacks* pAllocator;
10140 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate;
10141 // Begin global wrapped dispatchable handle unboxing for device;
10142 uint64_t cgen_var_0;
10143 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10144 *readStreamPtrPtr += 1 * 8;
10145 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
10146 vkReadStream->alloc((void**)&pCreateInfo,
10147 sizeof(const VkDescriptorUpdateTemplateCreateInfo));
10148 reservedunmarshal_VkDescriptorUpdateTemplateCreateInfo(
10149 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10150 (VkDescriptorUpdateTemplateCreateInfo*)(pCreateInfo), readStreamPtrPtr);
10151 // WARNING PTR CHECK
10152 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
10153 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
10154 *readStreamPtrPtr += 8;
10155 if (pAllocator) {
10156 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
10157 reservedunmarshal_VkAllocationCallbacks(
10158 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10159 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
10160 }
10161 // Begin manual dispatchable handle unboxing for pDescriptorUpdateTemplate;
10162 vkReadStream->unsetHandleMapping();
10163 vkReadStream->alloc((void**)&pDescriptorUpdateTemplate,
10164 sizeof(VkDescriptorUpdateTemplate));
10165 uint64_t cgen_var_2;
10166 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
10167 *readStreamPtrPtr += 8;
10168 *(VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate =
10169 (VkDescriptorUpdateTemplate)(VkDescriptorUpdateTemplate)((
10170 VkDescriptorUpdateTemplate)(*&cgen_var_2));
10171 if (pCreateInfo) {
10172 transform_tohost_VkDescriptorUpdateTemplateCreateInfo(
10173 m_state, (VkDescriptorUpdateTemplateCreateInfo*)(pCreateInfo));
10174 }
10175 if (pAllocator) {
10176 transform_tohost_VkAllocationCallbacks(m_state,
10177 (VkAllocationCallbacks*)(pAllocator));
10178 }
10179 if (m_logCalls) {
10180 fprintf(stderr,
10181 "stream %p: call vkCreateDescriptorUpdateTemplate 0x%llx 0x%llx 0x%llx "
10182 "0x%llx \n",
10183 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
10184 (unsigned long long)pAllocator,
10185 (unsigned long long)pDescriptorUpdateTemplate);
10186 }
10187 VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
10188 vkCreateDescriptorUpdateTemplate_VkResult_return =
10189 m_state->on_vkCreateDescriptorUpdateTemplate(
10190 &m_pool, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
10191 if ((vkCreateDescriptorUpdateTemplate_VkResult_return) == VK_ERROR_DEVICE_LOST)
10192 m_state->on_DeviceLost();
10193 m_state->on_CheckOutOfMemory(vkCreateDescriptorUpdateTemplate_VkResult_return,
10194 opcode, context);
10195 vkStream->unsetHandleMapping();
10196 // Begin manual non dispatchable handle create for pDescriptorUpdateTemplate;
10197 vkStream->unsetHandleMapping();
10198 uint64_t cgen_var_3;
10199 static_assert(
10200 8 == sizeof(VkDescriptorUpdateTemplate),
10201 "handle map overwrite requires VkDescriptorUpdateTemplate to be 8 bytes long");
10202 vkStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate(
10203 (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
10204 vkStream->write((VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 8 * 1);
10205 // Begin manual non dispatchable handle create for pDescriptorUpdateTemplate;
10206 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
10207 vkStream->write(&vkCreateDescriptorUpdateTemplate_VkResult_return,
10208 sizeof(VkResult));
10209 vkStream->commitWrite();
10210 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10211 (uintptr_t)snapshotTraceBegin);
10212 size_t snapshotTraceBytes = vkReadStream->endTrace();
10213 if (m_state->snapshotsEnabled()) {
10214 m_state->snapshot()->vkCreateDescriptorUpdateTemplate(
10215 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
10216 vkCreateDescriptorUpdateTemplate_VkResult_return, device, pCreateInfo,
10217 pAllocator, pDescriptorUpdateTemplate);
10218 }
10219 vkReadStream->clearPool();
10220 if (m_queueSubmitWithCommandsEnabled)
10221 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10222 break;
10223 }
10224 case OP_vkDestroyDescriptorUpdateTemplate: {
10225 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10226 "VkDecoder vkDestroyDescriptorUpdateTemplate");
10227 VkDevice device;
10228 VkDescriptorUpdateTemplate descriptorUpdateTemplate;
10229 const VkAllocationCallbacks* pAllocator;
10230 // Begin global wrapped dispatchable handle unboxing for device;
10231 uint64_t cgen_var_0;
10232 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10233 *readStreamPtrPtr += 1 * 8;
10234 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
10235 // Begin manual non dispatchable handle destroy unboxing for
10236 // descriptorUpdateTemplate;
10237 VkDescriptorUpdateTemplate boxed_descriptorUpdateTemplate_preserve;
10238 uint64_t cgen_var_1;
10239 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
10240 *readStreamPtrPtr += 1 * 8;
10241 *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate =
10242 (VkDescriptorUpdateTemplate)(VkDescriptorUpdateTemplate)((
10243 VkDescriptorUpdateTemplate)(*&cgen_var_1));
10244 boxed_descriptorUpdateTemplate_preserve = descriptorUpdateTemplate;
10245 descriptorUpdateTemplate =
10246 try_unbox_VkDescriptorUpdateTemplate(descriptorUpdateTemplate);
10247 // WARNING PTR CHECK
10248 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
10249 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
10250 *readStreamPtrPtr += 8;
10251 if (pAllocator) {
10252 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
10253 reservedunmarshal_VkAllocationCallbacks(
10254 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10255 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
10256 }
10257 if (pAllocator) {
10258 transform_tohost_VkAllocationCallbacks(m_state,
10259 (VkAllocationCallbacks*)(pAllocator));
10260 }
10261 if (m_logCalls) {
10262 fprintf(
10263 stderr,
10264 "stream %p: call vkDestroyDescriptorUpdateTemplate 0x%llx 0x%llx 0x%llx \n",
10265 ioStream, (unsigned long long)device,
10266 (unsigned long long)descriptorUpdateTemplate,
10267 (unsigned long long)pAllocator);
10268 }
10269 m_state->on_vkDestroyDescriptorUpdateTemplate(&m_pool, device,
10270 descriptorUpdateTemplate, pAllocator);
10271 vkStream->unsetHandleMapping();
10272 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10273 (uintptr_t)snapshotTraceBegin);
10274 size_t snapshotTraceBytes = vkReadStream->endTrace();
10275 if (m_state->snapshotsEnabled()) {
10276 m_state->snapshot()->vkDestroyDescriptorUpdateTemplate(
10277 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
10278 boxed_descriptorUpdateTemplate_preserve, pAllocator);
10279 }
10280 delete_VkDescriptorUpdateTemplate(boxed_descriptorUpdateTemplate_preserve);
10281 vkReadStream->clearPool();
10282 if (m_queueSubmitWithCommandsEnabled)
10283 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10284 break;
10285 }
10286 case OP_vkUpdateDescriptorSetWithTemplate: {
10287 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10288 "VkDecoder vkUpdateDescriptorSetWithTemplate");
10289 VkDevice device;
10290 VkDescriptorSet descriptorSet;
10291 VkDescriptorUpdateTemplate descriptorUpdateTemplate;
10292 const void* pData;
10293 // Begin non wrapped dispatchable handle unboxing for device;
10294 uint64_t cgen_var_0;
10295 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10296 *readStreamPtrPtr += 1 * 8;
10297 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
10298 auto unboxed_device = unbox_VkDevice(device);
10299 auto vk = dispatch_VkDevice(device);
10300 // End manual dispatchable handle unboxing for device;
10301 uint64_t cgen_var_1;
10302 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
10303 *readStreamPtrPtr += 1 * 8;
10304 *(VkDescriptorSet*)&descriptorSet =
10305 (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)(*&cgen_var_1));
10306 uint64_t cgen_var_2;
10307 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
10308 *readStreamPtrPtr += 1 * 8;
10309 *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate =
10310 (VkDescriptorUpdateTemplate)unbox_VkDescriptorUpdateTemplate(
10311 (VkDescriptorUpdateTemplate)(*&cgen_var_2));
10312 // WARNING PTR CHECK
10313 memcpy((void**)&pData, (*readStreamPtrPtr), 8);
10314 android::base::Stream::fromBe64((uint8_t*)&pData);
10315 *readStreamPtrPtr += 8;
10316 if (pData) {
10317 vkReadStream->alloc((void**)&pData, sizeof(const uint8_t));
10318 memcpy((void*)pData, *readStreamPtrPtr, sizeof(const uint8_t));
10319 *readStreamPtrPtr += sizeof(const uint8_t);
10320 }
10321 if (m_logCalls) {
10322 fprintf(stderr,
10323 "stream %p: call vkUpdateDescriptorSetWithTemplate 0x%llx 0x%llx "
10324 "0x%llx 0x%llx \n",
10325 ioStream, (unsigned long long)device, (unsigned long long)descriptorSet,
10326 (unsigned long long)descriptorUpdateTemplate,
10327 (unsigned long long)pData);
10328 }
10329 vk->vkUpdateDescriptorSetWithTemplate(unboxed_device, descriptorSet,
10330 descriptorUpdateTemplate, pData);
10331 vkStream->unsetHandleMapping();
10332 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10333 (uintptr_t)snapshotTraceBegin);
10334 size_t snapshotTraceBytes = vkReadStream->endTrace();
10335 if (m_state->snapshotsEnabled()) {
10336 m_state->snapshot()->vkUpdateDescriptorSetWithTemplate(
10337 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, descriptorSet,
10338 descriptorUpdateTemplate, pData);
10339 }
10340 vkReadStream->clearPool();
10341 if (m_queueSubmitWithCommandsEnabled)
10342 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10343 break;
10344 }
10345 case OP_vkGetPhysicalDeviceExternalBufferProperties: {
10346 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10347 "VkDecoder vkGetPhysicalDeviceExternalBufferProperties");
10348 VkPhysicalDevice physicalDevice;
10349 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo;
10350 VkExternalBufferProperties* pExternalBufferProperties;
10351 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
10352 uint64_t cgen_var_0;
10353 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10354 *readStreamPtrPtr += 1 * 8;
10355 *(VkPhysicalDevice*)&physicalDevice =
10356 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
10357 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
10358 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
10359 // End manual dispatchable handle unboxing for physicalDevice;
10360 vkReadStream->alloc((void**)&pExternalBufferInfo,
10361 sizeof(const VkPhysicalDeviceExternalBufferInfo));
10362 reservedunmarshal_VkPhysicalDeviceExternalBufferInfo(
10363 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10364 (VkPhysicalDeviceExternalBufferInfo*)(pExternalBufferInfo), readStreamPtrPtr);
10365 // Begin manual dispatchable handle unboxing for pExternalBufferProperties;
10366 vkReadStream->unsetHandleMapping();
10367 vkReadStream->alloc((void**)&pExternalBufferProperties,
10368 sizeof(VkExternalBufferProperties));
10369 reservedunmarshal_VkExternalBufferProperties(
10370 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10371 (VkExternalBufferProperties*)(pExternalBufferProperties), readStreamPtrPtr);
10372 if (pExternalBufferInfo) {
10373 m_state->transformImpl_VkPhysicalDeviceExternalBufferInfo_tohost(
10374 pExternalBufferInfo, 1);
10375 transform_tohost_VkPhysicalDeviceExternalBufferInfo(
10376 m_state, (VkPhysicalDeviceExternalBufferInfo*)(pExternalBufferInfo));
10377 }
10378 if (pExternalBufferProperties) {
10379 m_state->transformImpl_VkExternalBufferProperties_tohost(
10380 pExternalBufferProperties, 1);
10381 transform_tohost_VkExternalBufferProperties(
10382 m_state, (VkExternalBufferProperties*)(pExternalBufferProperties));
10383 }
10384 if (m_logCalls) {
10385 fprintf(stderr,
10386 "stream %p: call vkGetPhysicalDeviceExternalBufferProperties 0x%llx "
10387 "0x%llx 0x%llx \n",
10388 ioStream, (unsigned long long)physicalDevice,
10389 (unsigned long long)pExternalBufferInfo,
10390 (unsigned long long)pExternalBufferProperties);
10391 }
10392 vk->vkGetPhysicalDeviceExternalBufferProperties(
10393 unboxed_physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
10394 vkStream->unsetHandleMapping();
10395 if (pExternalBufferProperties) {
10396 m_state->transformImpl_VkExternalBufferProperties_fromhost(
10397 pExternalBufferProperties, 1);
10398 transform_fromhost_VkExternalBufferProperties(
10399 m_state, (VkExternalBufferProperties*)(pExternalBufferProperties));
10400 }
10401 marshal_VkExternalBufferProperties(
10402 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10403 (VkExternalBufferProperties*)(pExternalBufferProperties));
10404 vkStream->commitWrite();
10405 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10406 (uintptr_t)snapshotTraceBegin);
10407 size_t snapshotTraceBytes = vkReadStream->endTrace();
10408 if (m_state->snapshotsEnabled()) {
10409 m_state->snapshot()->vkGetPhysicalDeviceExternalBufferProperties(
10410 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
10411 pExternalBufferInfo, pExternalBufferProperties);
10412 }
10413 vkReadStream->clearPool();
10414 if (m_queueSubmitWithCommandsEnabled)
10415 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10416 break;
10417 }
10418 case OP_vkGetPhysicalDeviceExternalFenceProperties: {
10419 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10420 "VkDecoder vkGetPhysicalDeviceExternalFenceProperties");
10421 VkPhysicalDevice physicalDevice;
10422 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo;
10423 VkExternalFenceProperties* pExternalFenceProperties;
10424 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
10425 uint64_t cgen_var_0;
10426 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10427 *readStreamPtrPtr += 1 * 8;
10428 *(VkPhysicalDevice*)&physicalDevice =
10429 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
10430 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
10431 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
10432 // End manual dispatchable handle unboxing for physicalDevice;
10433 vkReadStream->alloc((void**)&pExternalFenceInfo,
10434 sizeof(const VkPhysicalDeviceExternalFenceInfo));
10435 reservedunmarshal_VkPhysicalDeviceExternalFenceInfo(
10436 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10437 (VkPhysicalDeviceExternalFenceInfo*)(pExternalFenceInfo), readStreamPtrPtr);
10438 // Begin manual dispatchable handle unboxing for pExternalFenceProperties;
10439 vkReadStream->unsetHandleMapping();
10440 vkReadStream->alloc((void**)&pExternalFenceProperties,
10441 sizeof(VkExternalFenceProperties));
10442 reservedunmarshal_VkExternalFenceProperties(
10443 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10444 (VkExternalFenceProperties*)(pExternalFenceProperties), readStreamPtrPtr);
10445 if (pExternalFenceInfo) {
10446 transform_tohost_VkPhysicalDeviceExternalFenceInfo(
10447 m_state, (VkPhysicalDeviceExternalFenceInfo*)(pExternalFenceInfo));
10448 }
10449 if (pExternalFenceProperties) {
10450 transform_tohost_VkExternalFenceProperties(
10451 m_state, (VkExternalFenceProperties*)(pExternalFenceProperties));
10452 }
10453 if (m_logCalls) {
10454 fprintf(stderr,
10455 "stream %p: call vkGetPhysicalDeviceExternalFenceProperties 0x%llx "
10456 "0x%llx 0x%llx \n",
10457 ioStream, (unsigned long long)physicalDevice,
10458 (unsigned long long)pExternalFenceInfo,
10459 (unsigned long long)pExternalFenceProperties);
10460 }
10461 vk->vkGetPhysicalDeviceExternalFenceProperties(
10462 unboxed_physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
10463 vkStream->unsetHandleMapping();
10464 if (pExternalFenceProperties) {
10465 transform_fromhost_VkExternalFenceProperties(
10466 m_state, (VkExternalFenceProperties*)(pExternalFenceProperties));
10467 }
10468 marshal_VkExternalFenceProperties(
10469 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10470 (VkExternalFenceProperties*)(pExternalFenceProperties));
10471 vkStream->commitWrite();
10472 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10473 (uintptr_t)snapshotTraceBegin);
10474 size_t snapshotTraceBytes = vkReadStream->endTrace();
10475 if (m_state->snapshotsEnabled()) {
10476 m_state->snapshot()->vkGetPhysicalDeviceExternalFenceProperties(
10477 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
10478 pExternalFenceInfo, pExternalFenceProperties);
10479 }
10480 vkReadStream->clearPool();
10481 if (m_queueSubmitWithCommandsEnabled)
10482 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10483 break;
10484 }
10485 case OP_vkGetPhysicalDeviceExternalSemaphoreProperties: {
10486 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10487 "VkDecoder vkGetPhysicalDeviceExternalSemaphoreProperties");
10488 VkPhysicalDevice physicalDevice;
10489 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo;
10490 VkExternalSemaphoreProperties* pExternalSemaphoreProperties;
10491 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
10492 uint64_t cgen_var_0;
10493 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10494 *readStreamPtrPtr += 1 * 8;
10495 *(VkPhysicalDevice*)&physicalDevice =
10496 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
10497 vkReadStream->alloc((void**)&pExternalSemaphoreInfo,
10498 sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
10499 reservedunmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
10500 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10501 (VkPhysicalDeviceExternalSemaphoreInfo*)(pExternalSemaphoreInfo),
10502 readStreamPtrPtr);
10503 // Begin manual dispatchable handle unboxing for pExternalSemaphoreProperties;
10504 vkReadStream->unsetHandleMapping();
10505 vkReadStream->alloc((void**)&pExternalSemaphoreProperties,
10506 sizeof(VkExternalSemaphoreProperties));
10507 reservedunmarshal_VkExternalSemaphoreProperties(
10508 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10509 (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties),
10510 readStreamPtrPtr);
10511 if (pExternalSemaphoreInfo) {
10512 transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo(
10513 m_state, (VkPhysicalDeviceExternalSemaphoreInfo*)(pExternalSemaphoreInfo));
10514 }
10515 if (pExternalSemaphoreProperties) {
10516 transform_tohost_VkExternalSemaphoreProperties(
10517 m_state, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
10518 }
10519 if (m_logCalls) {
10520 fprintf(stderr,
10521 "stream %p: call vkGetPhysicalDeviceExternalSemaphoreProperties 0x%llx "
10522 "0x%llx 0x%llx \n",
10523 ioStream, (unsigned long long)physicalDevice,
10524 (unsigned long long)pExternalSemaphoreInfo,
10525 (unsigned long long)pExternalSemaphoreProperties);
10526 }
10527 m_state->on_vkGetPhysicalDeviceExternalSemaphoreProperties(
10528 &m_pool, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
10529 vkStream->unsetHandleMapping();
10530 if (pExternalSemaphoreProperties) {
10531 transform_fromhost_VkExternalSemaphoreProperties(
10532 m_state, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
10533 }
10534 marshal_VkExternalSemaphoreProperties(
10535 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10536 (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
10537 vkStream->commitWrite();
10538 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10539 (uintptr_t)snapshotTraceBegin);
10540 size_t snapshotTraceBytes = vkReadStream->endTrace();
10541 if (m_state->snapshotsEnabled()) {
10542 m_state->snapshot()->vkGetPhysicalDeviceExternalSemaphoreProperties(
10543 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
10544 pExternalSemaphoreInfo, pExternalSemaphoreProperties);
10545 }
10546 vkReadStream->clearPool();
10547 if (m_queueSubmitWithCommandsEnabled)
10548 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10549 break;
10550 }
10551 case OP_vkGetDescriptorSetLayoutSupport: {
10552 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10553 "VkDecoder vkGetDescriptorSetLayoutSupport");
10554 VkDevice device;
10555 const VkDescriptorSetLayoutCreateInfo* pCreateInfo;
10556 VkDescriptorSetLayoutSupport* pSupport;
10557 // Begin non wrapped dispatchable handle unboxing for device;
10558 uint64_t cgen_var_0;
10559 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10560 *readStreamPtrPtr += 1 * 8;
10561 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
10562 auto unboxed_device = unbox_VkDevice(device);
10563 auto vk = dispatch_VkDevice(device);
10564 // End manual dispatchable handle unboxing for device;
10565 vkReadStream->alloc((void**)&pCreateInfo,
10566 sizeof(const VkDescriptorSetLayoutCreateInfo));
10567 reservedunmarshal_VkDescriptorSetLayoutCreateInfo(
10568 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10569 (VkDescriptorSetLayoutCreateInfo*)(pCreateInfo), readStreamPtrPtr);
10570 // Begin manual dispatchable handle unboxing for pSupport;
10571 vkReadStream->unsetHandleMapping();
10572 vkReadStream->alloc((void**)&pSupport, sizeof(VkDescriptorSetLayoutSupport));
10573 reservedunmarshal_VkDescriptorSetLayoutSupport(
10574 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10575 (VkDescriptorSetLayoutSupport*)(pSupport), readStreamPtrPtr);
10576 if (pCreateInfo) {
10577 transform_tohost_VkDescriptorSetLayoutCreateInfo(
10578 m_state, (VkDescriptorSetLayoutCreateInfo*)(pCreateInfo));
10579 }
10580 if (pSupport) {
10581 transform_tohost_VkDescriptorSetLayoutSupport(
10582 m_state, (VkDescriptorSetLayoutSupport*)(pSupport));
10583 }
10584 if (m_logCalls) {
10585 fprintf(
10586 stderr,
10587 "stream %p: call vkGetDescriptorSetLayoutSupport 0x%llx 0x%llx 0x%llx \n",
10588 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
10589 (unsigned long long)pSupport);
10590 }
10591 vk->vkGetDescriptorSetLayoutSupport(unboxed_device, pCreateInfo, pSupport);
10592 vkStream->unsetHandleMapping();
10593 if (pSupport) {
10594 transform_fromhost_VkDescriptorSetLayoutSupport(
10595 m_state, (VkDescriptorSetLayoutSupport*)(pSupport));
10596 }
10597 marshal_VkDescriptorSetLayoutSupport(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10598 (VkDescriptorSetLayoutSupport*)(pSupport));
10599 vkStream->commitWrite();
10600 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10601 (uintptr_t)snapshotTraceBegin);
10602 size_t snapshotTraceBytes = vkReadStream->endTrace();
10603 if (m_state->snapshotsEnabled()) {
10604 m_state->snapshot()->vkGetDescriptorSetLayoutSupport(
10605 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pCreateInfo,
10606 pSupport);
10607 }
10608 vkReadStream->clearPool();
10609 if (m_queueSubmitWithCommandsEnabled)
10610 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10611 break;
10612 }
10613 #endif
10614 #ifdef VK_VERSION_1_2
10615 case OP_vkCmdDrawIndirectCount: {
10616 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10617 "VkDecoder vkCmdDrawIndirectCount");
10618 VkCommandBuffer commandBuffer;
10619 VkBuffer buffer;
10620 VkDeviceSize offset;
10621 VkBuffer countBuffer;
10622 VkDeviceSize countBufferOffset;
10623 uint32_t maxDrawCount;
10624 uint32_t stride;
10625 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
10626 uint64_t cgen_var_0;
10627 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10628 *readStreamPtrPtr += 1 * 8;
10629 *(VkCommandBuffer*)&commandBuffer =
10630 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
10631 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
10632 auto vk = dispatch_VkCommandBuffer(commandBuffer);
10633 // End manual dispatchable handle unboxing for commandBuffer;
10634 uint64_t cgen_var_1;
10635 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
10636 *readStreamPtrPtr += 1 * 8;
10637 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
10638 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
10639 *readStreamPtrPtr += sizeof(VkDeviceSize);
10640 uint64_t cgen_var_2;
10641 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
10642 *readStreamPtrPtr += 1 * 8;
10643 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_2));
10644 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
10645 *readStreamPtrPtr += sizeof(VkDeviceSize);
10646 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
10647 *readStreamPtrPtr += sizeof(uint32_t);
10648 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
10649 *readStreamPtrPtr += sizeof(uint32_t);
10650 if (m_logCalls) {
10651 fprintf(stderr,
10652 "stream %p: call vkCmdDrawIndirectCount 0x%llx 0x%llx 0x%llx 0x%llx "
10653 "0x%llx 0x%llx 0x%llx \n",
10654 ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
10655 (unsigned long long)offset, (unsigned long long)countBuffer,
10656 (unsigned long long)countBufferOffset, (unsigned long long)maxDrawCount,
10657 (unsigned long long)stride);
10658 }
10659 vk->vkCmdDrawIndirectCount(unboxed_commandBuffer, buffer, offset, countBuffer,
10660 countBufferOffset, maxDrawCount, stride);
10661 vkStream->unsetHandleMapping();
10662 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10663 (uintptr_t)snapshotTraceBegin);
10664 size_t snapshotTraceBytes = vkReadStream->endTrace();
10665 if (m_state->snapshotsEnabled()) {
10666 m_state->snapshot()->vkCmdDrawIndirectCount(
10667 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, buffer,
10668 offset, countBuffer, countBufferOffset, maxDrawCount, stride);
10669 }
10670 vkReadStream->clearPool();
10671 if (m_queueSubmitWithCommandsEnabled)
10672 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10673 break;
10674 }
10675 case OP_vkCmdDrawIndexedIndirectCount: {
10676 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10677 "VkDecoder vkCmdDrawIndexedIndirectCount");
10678 VkCommandBuffer commandBuffer;
10679 VkBuffer buffer;
10680 VkDeviceSize offset;
10681 VkBuffer countBuffer;
10682 VkDeviceSize countBufferOffset;
10683 uint32_t maxDrawCount;
10684 uint32_t stride;
10685 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
10686 uint64_t cgen_var_0;
10687 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10688 *readStreamPtrPtr += 1 * 8;
10689 *(VkCommandBuffer*)&commandBuffer =
10690 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
10691 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
10692 auto vk = dispatch_VkCommandBuffer(commandBuffer);
10693 // End manual dispatchable handle unboxing for commandBuffer;
10694 uint64_t cgen_var_1;
10695 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
10696 *readStreamPtrPtr += 1 * 8;
10697 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
10698 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
10699 *readStreamPtrPtr += sizeof(VkDeviceSize);
10700 uint64_t cgen_var_2;
10701 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
10702 *readStreamPtrPtr += 1 * 8;
10703 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_2));
10704 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
10705 *readStreamPtrPtr += sizeof(VkDeviceSize);
10706 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
10707 *readStreamPtrPtr += sizeof(uint32_t);
10708 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
10709 *readStreamPtrPtr += sizeof(uint32_t);
10710 if (m_logCalls) {
10711 fprintf(stderr,
10712 "stream %p: call vkCmdDrawIndexedIndirectCount 0x%llx 0x%llx 0x%llx "
10713 "0x%llx 0x%llx 0x%llx 0x%llx \n",
10714 ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
10715 (unsigned long long)offset, (unsigned long long)countBuffer,
10716 (unsigned long long)countBufferOffset, (unsigned long long)maxDrawCount,
10717 (unsigned long long)stride);
10718 }
10719 vk->vkCmdDrawIndexedIndirectCount(unboxed_commandBuffer, buffer, offset,
10720 countBuffer, countBufferOffset, maxDrawCount,
10721 stride);
10722 vkStream->unsetHandleMapping();
10723 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10724 (uintptr_t)snapshotTraceBegin);
10725 size_t snapshotTraceBytes = vkReadStream->endTrace();
10726 if (m_state->snapshotsEnabled()) {
10727 m_state->snapshot()->vkCmdDrawIndexedIndirectCount(
10728 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, buffer,
10729 offset, countBuffer, countBufferOffset, maxDrawCount, stride);
10730 }
10731 vkReadStream->clearPool();
10732 if (m_queueSubmitWithCommandsEnabled)
10733 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10734 break;
10735 }
10736 case OP_vkCreateRenderPass2: {
10737 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10738 "VkDecoder vkCreateRenderPass2");
10739 VkDevice device;
10740 const VkRenderPassCreateInfo2* pCreateInfo;
10741 const VkAllocationCallbacks* pAllocator;
10742 VkRenderPass* pRenderPass;
10743 // Begin global wrapped dispatchable handle unboxing for device;
10744 uint64_t cgen_var_0;
10745 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10746 *readStreamPtrPtr += 1 * 8;
10747 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
10748 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkRenderPassCreateInfo2));
10749 reservedunmarshal_VkRenderPassCreateInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10750 (VkRenderPassCreateInfo2*)(pCreateInfo),
10751 readStreamPtrPtr);
10752 // WARNING PTR CHECK
10753 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
10754 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
10755 *readStreamPtrPtr += 8;
10756 if (pAllocator) {
10757 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
10758 reservedunmarshal_VkAllocationCallbacks(
10759 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10760 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
10761 }
10762 // Begin manual dispatchable handle unboxing for pRenderPass;
10763 vkReadStream->unsetHandleMapping();
10764 vkReadStream->alloc((void**)&pRenderPass, sizeof(VkRenderPass));
10765 uint64_t cgen_var_2;
10766 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
10767 *readStreamPtrPtr += 8;
10768 *(VkRenderPass*)pRenderPass =
10769 (VkRenderPass)(VkRenderPass)((VkRenderPass)(*&cgen_var_2));
10770 if (pCreateInfo) {
10771 transform_tohost_VkRenderPassCreateInfo2(
10772 m_state, (VkRenderPassCreateInfo2*)(pCreateInfo));
10773 }
10774 if (pAllocator) {
10775 transform_tohost_VkAllocationCallbacks(m_state,
10776 (VkAllocationCallbacks*)(pAllocator));
10777 }
10778 if (m_logCalls) {
10779 fprintf(stderr,
10780 "stream %p: call vkCreateRenderPass2 0x%llx 0x%llx 0x%llx 0x%llx \n",
10781 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
10782 (unsigned long long)pAllocator, (unsigned long long)pRenderPass);
10783 }
10784 VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
10785 vkCreateRenderPass2_VkResult_return = m_state->on_vkCreateRenderPass2(
10786 &m_pool, device, pCreateInfo, pAllocator, pRenderPass);
10787 if ((vkCreateRenderPass2_VkResult_return) == VK_ERROR_DEVICE_LOST)
10788 m_state->on_DeviceLost();
10789 m_state->on_CheckOutOfMemory(vkCreateRenderPass2_VkResult_return, opcode, context);
10790 vkStream->unsetHandleMapping();
10791 // Begin manual non dispatchable handle create for pRenderPass;
10792 vkStream->unsetHandleMapping();
10793 uint64_t cgen_var_3;
10794 static_assert(8 == sizeof(VkRenderPass),
10795 "handle map overwrite requires VkRenderPass to be 8 bytes long");
10796 vkStream->handleMapping()->mapHandles_VkRenderPass((VkRenderPass*)pRenderPass, 1);
10797 vkStream->write((VkRenderPass*)pRenderPass, 8 * 1);
10798 // Begin manual non dispatchable handle create for pRenderPass;
10799 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
10800 vkStream->write(&vkCreateRenderPass2_VkResult_return, sizeof(VkResult));
10801 vkStream->commitWrite();
10802 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10803 (uintptr_t)snapshotTraceBegin);
10804 size_t snapshotTraceBytes = vkReadStream->endTrace();
10805 if (m_state->snapshotsEnabled()) {
10806 m_state->snapshot()->vkCreateRenderPass2(
10807 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
10808 vkCreateRenderPass2_VkResult_return, device, pCreateInfo, pAllocator,
10809 pRenderPass);
10810 }
10811 vkReadStream->clearPool();
10812 if (m_queueSubmitWithCommandsEnabled)
10813 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10814 break;
10815 }
10816 case OP_vkCmdBeginRenderPass2: {
10817 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10818 "VkDecoder vkCmdBeginRenderPass2");
10819 VkCommandBuffer commandBuffer;
10820 const VkRenderPassBeginInfo* pRenderPassBegin;
10821 const VkSubpassBeginInfo* pSubpassBeginInfo;
10822 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
10823 uint64_t cgen_var_0;
10824 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10825 *readStreamPtrPtr += 1 * 8;
10826 *(VkCommandBuffer*)&commandBuffer =
10827 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
10828 vkReadStream->alloc((void**)&pRenderPassBegin, sizeof(const VkRenderPassBeginInfo));
10829 reservedunmarshal_VkRenderPassBeginInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10830 (VkRenderPassBeginInfo*)(pRenderPassBegin),
10831 readStreamPtrPtr);
10832 vkReadStream->alloc((void**)&pSubpassBeginInfo, sizeof(const VkSubpassBeginInfo));
10833 reservedunmarshal_VkSubpassBeginInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10834 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
10835 readStreamPtrPtr);
10836 if (pRenderPassBegin) {
10837 transform_tohost_VkRenderPassBeginInfo(
10838 m_state, (VkRenderPassBeginInfo*)(pRenderPassBegin));
10839 }
10840 if (pSubpassBeginInfo) {
10841 transform_tohost_VkSubpassBeginInfo(m_state,
10842 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
10843 }
10844 if (m_logCalls) {
10845 fprintf(stderr, "stream %p: call vkCmdBeginRenderPass2 0x%llx 0x%llx 0x%llx \n",
10846 ioStream, (unsigned long long)commandBuffer,
10847 (unsigned long long)pRenderPassBegin,
10848 (unsigned long long)pSubpassBeginInfo);
10849 }
10850 m_state->on_vkCmdBeginRenderPass2(&m_pool, commandBuffer, pRenderPassBegin,
10851 pSubpassBeginInfo);
10852 vkStream->unsetHandleMapping();
10853 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10854 (uintptr_t)snapshotTraceBegin);
10855 size_t snapshotTraceBytes = vkReadStream->endTrace();
10856 if (m_state->snapshotsEnabled()) {
10857 m_state->snapshot()->vkCmdBeginRenderPass2(
10858 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
10859 pRenderPassBegin, pSubpassBeginInfo);
10860 }
10861 vkReadStream->clearPool();
10862 if (m_queueSubmitWithCommandsEnabled)
10863 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10864 break;
10865 }
10866 case OP_vkCmdNextSubpass2: {
10867 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10868 "VkDecoder vkCmdNextSubpass2");
10869 VkCommandBuffer commandBuffer;
10870 const VkSubpassBeginInfo* pSubpassBeginInfo;
10871 const VkSubpassEndInfo* pSubpassEndInfo;
10872 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
10873 uint64_t cgen_var_0;
10874 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10875 *readStreamPtrPtr += 1 * 8;
10876 *(VkCommandBuffer*)&commandBuffer =
10877 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
10878 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
10879 auto vk = dispatch_VkCommandBuffer(commandBuffer);
10880 // End manual dispatchable handle unboxing for commandBuffer;
10881 vkReadStream->alloc((void**)&pSubpassBeginInfo, sizeof(const VkSubpassBeginInfo));
10882 reservedunmarshal_VkSubpassBeginInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10883 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
10884 readStreamPtrPtr);
10885 vkReadStream->alloc((void**)&pSubpassEndInfo, sizeof(const VkSubpassEndInfo));
10886 reservedunmarshal_VkSubpassEndInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10887 (VkSubpassEndInfo*)(pSubpassEndInfo),
10888 readStreamPtrPtr);
10889 if (pSubpassBeginInfo) {
10890 transform_tohost_VkSubpassBeginInfo(m_state,
10891 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
10892 }
10893 if (pSubpassEndInfo) {
10894 transform_tohost_VkSubpassEndInfo(m_state,
10895 (VkSubpassEndInfo*)(pSubpassEndInfo));
10896 }
10897 if (m_logCalls) {
10898 fprintf(stderr, "stream %p: call vkCmdNextSubpass2 0x%llx 0x%llx 0x%llx \n",
10899 ioStream, (unsigned long long)commandBuffer,
10900 (unsigned long long)pSubpassBeginInfo,
10901 (unsigned long long)pSubpassEndInfo);
10902 }
10903 vk->vkCmdNextSubpass2(unboxed_commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
10904 vkStream->unsetHandleMapping();
10905 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10906 (uintptr_t)snapshotTraceBegin);
10907 size_t snapshotTraceBytes = vkReadStream->endTrace();
10908 if (m_state->snapshotsEnabled()) {
10909 m_state->snapshot()->vkCmdNextSubpass2(snapshotTraceBegin, snapshotTraceBytes,
10910 &m_pool, commandBuffer,
10911 pSubpassBeginInfo, pSubpassEndInfo);
10912 }
10913 vkReadStream->clearPool();
10914 if (m_queueSubmitWithCommandsEnabled)
10915 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10916 break;
10917 }
10918 case OP_vkCmdEndRenderPass2: {
10919 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10920 "VkDecoder vkCmdEndRenderPass2");
10921 VkCommandBuffer commandBuffer;
10922 const VkSubpassEndInfo* pSubpassEndInfo;
10923 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
10924 uint64_t cgen_var_0;
10925 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10926 *readStreamPtrPtr += 1 * 8;
10927 *(VkCommandBuffer*)&commandBuffer =
10928 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
10929 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
10930 auto vk = dispatch_VkCommandBuffer(commandBuffer);
10931 // End manual dispatchable handle unboxing for commandBuffer;
10932 vkReadStream->alloc((void**)&pSubpassEndInfo, sizeof(const VkSubpassEndInfo));
10933 reservedunmarshal_VkSubpassEndInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
10934 (VkSubpassEndInfo*)(pSubpassEndInfo),
10935 readStreamPtrPtr);
10936 if (pSubpassEndInfo) {
10937 transform_tohost_VkSubpassEndInfo(m_state,
10938 (VkSubpassEndInfo*)(pSubpassEndInfo));
10939 }
10940 if (m_logCalls) {
10941 fprintf(stderr, "stream %p: call vkCmdEndRenderPass2 0x%llx 0x%llx \n",
10942 ioStream, (unsigned long long)commandBuffer,
10943 (unsigned long long)pSubpassEndInfo);
10944 }
10945 vk->vkCmdEndRenderPass2(unboxed_commandBuffer, pSubpassEndInfo);
10946 vkStream->unsetHandleMapping();
10947 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10948 (uintptr_t)snapshotTraceBegin);
10949 size_t snapshotTraceBytes = vkReadStream->endTrace();
10950 if (m_state->snapshotsEnabled()) {
10951 m_state->snapshot()->vkCmdEndRenderPass2(snapshotTraceBegin, snapshotTraceBytes,
10952 &m_pool, commandBuffer,
10953 pSubpassEndInfo);
10954 }
10955 vkReadStream->clearPool();
10956 if (m_queueSubmitWithCommandsEnabled)
10957 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
10958 break;
10959 }
10960 case OP_vkResetQueryPool: {
10961 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
10962 "VkDecoder vkResetQueryPool");
10963 VkDevice device;
10964 VkQueryPool queryPool;
10965 uint32_t firstQuery;
10966 uint32_t queryCount;
10967 // Begin non wrapped dispatchable handle unboxing for device;
10968 uint64_t cgen_var_0;
10969 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
10970 *readStreamPtrPtr += 1 * 8;
10971 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
10972 auto unboxed_device = unbox_VkDevice(device);
10973 auto vk = dispatch_VkDevice(device);
10974 // End manual dispatchable handle unboxing for device;
10975 uint64_t cgen_var_1;
10976 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
10977 *readStreamPtrPtr += 1 * 8;
10978 *(VkQueryPool*)&queryPool =
10979 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
10980 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
10981 *readStreamPtrPtr += sizeof(uint32_t);
10982 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
10983 *readStreamPtrPtr += sizeof(uint32_t);
10984 if (m_logCalls) {
10985 fprintf(stderr,
10986 "stream %p: call vkResetQueryPool 0x%llx 0x%llx 0x%llx 0x%llx \n",
10987 ioStream, (unsigned long long)device, (unsigned long long)queryPool,
10988 (unsigned long long)firstQuery, (unsigned long long)queryCount);
10989 }
10990 vk->vkResetQueryPool(unboxed_device, queryPool, firstQuery, queryCount);
10991 vkStream->unsetHandleMapping();
10992 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
10993 (uintptr_t)snapshotTraceBegin);
10994 size_t snapshotTraceBytes = vkReadStream->endTrace();
10995 if (m_state->snapshotsEnabled()) {
10996 m_state->snapshot()->vkResetQueryPool(snapshotTraceBegin, snapshotTraceBytes,
10997 &m_pool, device, queryPool, firstQuery,
10998 queryCount);
10999 }
11000 vkReadStream->clearPool();
11001 if (m_queueSubmitWithCommandsEnabled)
11002 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11003 break;
11004 }
11005 case OP_vkGetSemaphoreCounterValue: {
11006 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11007 "VkDecoder vkGetSemaphoreCounterValue");
11008 VkDevice device;
11009 VkSemaphore semaphore;
11010 uint64_t* pValue;
11011 // Begin non wrapped dispatchable handle unboxing for device;
11012 uint64_t cgen_var_0;
11013 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11014 *readStreamPtrPtr += 1 * 8;
11015 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11016 auto unboxed_device = unbox_VkDevice(device);
11017 auto vk = dispatch_VkDevice(device);
11018 // End manual dispatchable handle unboxing for device;
11019 uint64_t cgen_var_1;
11020 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
11021 *readStreamPtrPtr += 1 * 8;
11022 *(VkSemaphore*)&semaphore =
11023 (VkSemaphore)unbox_VkSemaphore((VkSemaphore)(*&cgen_var_1));
11024 // Begin manual dispatchable handle unboxing for pValue;
11025 vkReadStream->unsetHandleMapping();
11026 vkReadStream->alloc((void**)&pValue, sizeof(uint64_t));
11027 memcpy((uint64_t*)pValue, *readStreamPtrPtr, sizeof(uint64_t));
11028 *readStreamPtrPtr += sizeof(uint64_t);
11029 if (m_logCalls) {
11030 fprintf(stderr,
11031 "stream %p: call vkGetSemaphoreCounterValue 0x%llx 0x%llx 0x%llx \n",
11032 ioStream, (unsigned long long)device, (unsigned long long)semaphore,
11033 (unsigned long long)pValue);
11034 }
11035 VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
11036 vkGetSemaphoreCounterValue_VkResult_return =
11037 vk->vkGetSemaphoreCounterValue(unboxed_device, semaphore, pValue);
11038 if ((vkGetSemaphoreCounterValue_VkResult_return) == VK_ERROR_DEVICE_LOST)
11039 m_state->on_DeviceLost();
11040 m_state->on_CheckOutOfMemory(vkGetSemaphoreCounterValue_VkResult_return, opcode,
11041 context);
11042 vkStream->unsetHandleMapping();
11043 vkStream->write((uint64_t*)pValue, sizeof(uint64_t));
11044 vkStream->write(&vkGetSemaphoreCounterValue_VkResult_return, sizeof(VkResult));
11045 vkStream->commitWrite();
11046 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11047 (uintptr_t)snapshotTraceBegin);
11048 size_t snapshotTraceBytes = vkReadStream->endTrace();
11049 if (m_state->snapshotsEnabled()) {
11050 m_state->snapshot()->vkGetSemaphoreCounterValue(
11051 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
11052 vkGetSemaphoreCounterValue_VkResult_return, device, semaphore, pValue);
11053 }
11054 vkReadStream->clearPool();
11055 if (m_queueSubmitWithCommandsEnabled)
11056 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11057 break;
11058 }
11059 case OP_vkWaitSemaphores: {
11060 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11061 "VkDecoder vkWaitSemaphores");
11062 VkDevice device;
11063 const VkSemaphoreWaitInfo* pWaitInfo;
11064 uint64_t timeout;
11065 // Begin non wrapped dispatchable handle unboxing for device;
11066 uint64_t cgen_var_0;
11067 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11068 *readStreamPtrPtr += 1 * 8;
11069 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11070 auto unboxed_device = unbox_VkDevice(device);
11071 auto vk = dispatch_VkDevice(device);
11072 // End manual dispatchable handle unboxing for device;
11073 vkReadStream->alloc((void**)&pWaitInfo, sizeof(const VkSemaphoreWaitInfo));
11074 reservedunmarshal_VkSemaphoreWaitInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11075 (VkSemaphoreWaitInfo*)(pWaitInfo),
11076 readStreamPtrPtr);
11077 memcpy((uint64_t*)&timeout, *readStreamPtrPtr, sizeof(uint64_t));
11078 *readStreamPtrPtr += sizeof(uint64_t);
11079 if (pWaitInfo) {
11080 transform_tohost_VkSemaphoreWaitInfo(m_state,
11081 (VkSemaphoreWaitInfo*)(pWaitInfo));
11082 }
11083 if (m_logCalls) {
11084 fprintf(stderr, "stream %p: call vkWaitSemaphores 0x%llx 0x%llx 0x%llx \n",
11085 ioStream, (unsigned long long)device, (unsigned long long)pWaitInfo,
11086 (unsigned long long)timeout);
11087 }
11088 if (m_queueSubmitWithCommandsEnabled)
11089 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11090 VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
11091 vkWaitSemaphores_VkResult_return =
11092 vk->vkWaitSemaphores(unboxed_device, pWaitInfo, timeout);
11093 if ((vkWaitSemaphores_VkResult_return) == VK_ERROR_DEVICE_LOST)
11094 m_state->on_DeviceLost();
11095 m_state->on_CheckOutOfMemory(vkWaitSemaphores_VkResult_return, opcode, context);
11096 vkStream->unsetHandleMapping();
11097 vkStream->write(&vkWaitSemaphores_VkResult_return, sizeof(VkResult));
11098 vkStream->commitWrite();
11099 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11100 (uintptr_t)snapshotTraceBegin);
11101 size_t snapshotTraceBytes = vkReadStream->endTrace();
11102 if (m_state->snapshotsEnabled()) {
11103 m_state->snapshot()->vkWaitSemaphores(snapshotTraceBegin, snapshotTraceBytes,
11104 &m_pool, vkWaitSemaphores_VkResult_return,
11105 device, pWaitInfo, timeout);
11106 }
11107 vkReadStream->clearPool();
11108 break;
11109 }
11110 case OP_vkSignalSemaphore: {
11111 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11112 "VkDecoder vkSignalSemaphore");
11113 VkDevice device;
11114 const VkSemaphoreSignalInfo* pSignalInfo;
11115 // Begin non wrapped dispatchable handle unboxing for device;
11116 uint64_t cgen_var_0;
11117 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11118 *readStreamPtrPtr += 1 * 8;
11119 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11120 auto unboxed_device = unbox_VkDevice(device);
11121 auto vk = dispatch_VkDevice(device);
11122 // End manual dispatchable handle unboxing for device;
11123 vkReadStream->alloc((void**)&pSignalInfo, sizeof(const VkSemaphoreSignalInfo));
11124 reservedunmarshal_VkSemaphoreSignalInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11125 (VkSemaphoreSignalInfo*)(pSignalInfo),
11126 readStreamPtrPtr);
11127 if (pSignalInfo) {
11128 transform_tohost_VkSemaphoreSignalInfo(m_state,
11129 (VkSemaphoreSignalInfo*)(pSignalInfo));
11130 }
11131 if (m_logCalls) {
11132 fprintf(stderr, "stream %p: call vkSignalSemaphore 0x%llx 0x%llx \n", ioStream,
11133 (unsigned long long)device, (unsigned long long)pSignalInfo);
11134 }
11135 VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
11136 vkSignalSemaphore_VkResult_return =
11137 vk->vkSignalSemaphore(unboxed_device, pSignalInfo);
11138 if ((vkSignalSemaphore_VkResult_return) == VK_ERROR_DEVICE_LOST)
11139 m_state->on_DeviceLost();
11140 m_state->on_CheckOutOfMemory(vkSignalSemaphore_VkResult_return, opcode, context);
11141 vkStream->unsetHandleMapping();
11142 vkStream->write(&vkSignalSemaphore_VkResult_return, sizeof(VkResult));
11143 vkStream->commitWrite();
11144 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11145 (uintptr_t)snapshotTraceBegin);
11146 size_t snapshotTraceBytes = vkReadStream->endTrace();
11147 if (m_state->snapshotsEnabled()) {
11148 m_state->snapshot()->vkSignalSemaphore(
11149 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
11150 vkSignalSemaphore_VkResult_return, device, pSignalInfo);
11151 }
11152 vkReadStream->clearPool();
11153 if (m_queueSubmitWithCommandsEnabled)
11154 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11155 break;
11156 }
11157 case OP_vkGetBufferDeviceAddress: {
11158 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11159 "VkDecoder vkGetBufferDeviceAddress");
11160 VkDevice device;
11161 const VkBufferDeviceAddressInfo* pInfo;
11162 // Begin non wrapped dispatchable handle unboxing for device;
11163 uint64_t cgen_var_0;
11164 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11165 *readStreamPtrPtr += 1 * 8;
11166 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11167 auto unboxed_device = unbox_VkDevice(device);
11168 auto vk = dispatch_VkDevice(device);
11169 // End manual dispatchable handle unboxing for device;
11170 vkReadStream->alloc((void**)&pInfo, sizeof(const VkBufferDeviceAddressInfo));
11171 reservedunmarshal_VkBufferDeviceAddressInfo(
11172 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(pInfo),
11173 readStreamPtrPtr);
11174 if (pInfo) {
11175 transform_tohost_VkBufferDeviceAddressInfo(m_state,
11176 (VkBufferDeviceAddressInfo*)(pInfo));
11177 }
11178 if (m_logCalls) {
11179 fprintf(stderr, "stream %p: call vkGetBufferDeviceAddress 0x%llx 0x%llx \n",
11180 ioStream, (unsigned long long)device, (unsigned long long)pInfo);
11181 }
11182 VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return =
11183 (VkDeviceAddress)0;
11184 vkGetBufferDeviceAddress_VkDeviceAddress_return =
11185 vk->vkGetBufferDeviceAddress(unboxed_device, pInfo);
11186 vkStream->unsetHandleMapping();
11187 vkStream->write(&vkGetBufferDeviceAddress_VkDeviceAddress_return,
11188 sizeof(VkDeviceAddress));
11189 vkStream->commitWrite();
11190 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11191 (uintptr_t)snapshotTraceBegin);
11192 size_t snapshotTraceBytes = vkReadStream->endTrace();
11193 if (m_state->snapshotsEnabled()) {
11194 m_state->snapshot()->vkGetBufferDeviceAddress(
11195 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
11196 vkGetBufferDeviceAddress_VkDeviceAddress_return, device, pInfo);
11197 }
11198 vkReadStream->clearPool();
11199 if (m_queueSubmitWithCommandsEnabled)
11200 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11201 break;
11202 }
11203 case OP_vkGetBufferOpaqueCaptureAddress: {
11204 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11205 "VkDecoder vkGetBufferOpaqueCaptureAddress");
11206 VkDevice device;
11207 const VkBufferDeviceAddressInfo* pInfo;
11208 // Begin non wrapped dispatchable handle unboxing for device;
11209 uint64_t cgen_var_0;
11210 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11211 *readStreamPtrPtr += 1 * 8;
11212 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11213 auto unboxed_device = unbox_VkDevice(device);
11214 auto vk = dispatch_VkDevice(device);
11215 // End manual dispatchable handle unboxing for device;
11216 vkReadStream->alloc((void**)&pInfo, sizeof(const VkBufferDeviceAddressInfo));
11217 reservedunmarshal_VkBufferDeviceAddressInfo(
11218 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(pInfo),
11219 readStreamPtrPtr);
11220 if (pInfo) {
11221 transform_tohost_VkBufferDeviceAddressInfo(m_state,
11222 (VkBufferDeviceAddressInfo*)(pInfo));
11223 }
11224 if (m_logCalls) {
11225 fprintf(stderr,
11226 "stream %p: call vkGetBufferOpaqueCaptureAddress 0x%llx 0x%llx \n",
11227 ioStream, (unsigned long long)device, (unsigned long long)pInfo);
11228 }
11229 uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
11230 vkGetBufferOpaqueCaptureAddress_uint64_t_return =
11231 vk->vkGetBufferOpaqueCaptureAddress(unboxed_device, pInfo);
11232 vkStream->unsetHandleMapping();
11233 vkStream->write(&vkGetBufferOpaqueCaptureAddress_uint64_t_return, sizeof(uint64_t));
11234 vkStream->commitWrite();
11235 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11236 (uintptr_t)snapshotTraceBegin);
11237 size_t snapshotTraceBytes = vkReadStream->endTrace();
11238 if (m_state->snapshotsEnabled()) {
11239 m_state->snapshot()->vkGetBufferOpaqueCaptureAddress(
11240 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
11241 vkGetBufferOpaqueCaptureAddress_uint64_t_return, device, pInfo);
11242 }
11243 vkReadStream->clearPool();
11244 if (m_queueSubmitWithCommandsEnabled)
11245 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11246 break;
11247 }
11248 case OP_vkGetDeviceMemoryOpaqueCaptureAddress: {
11249 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11250 "VkDecoder vkGetDeviceMemoryOpaqueCaptureAddress");
11251 VkDevice device;
11252 const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo;
11253 // Begin non wrapped dispatchable handle unboxing for device;
11254 uint64_t cgen_var_0;
11255 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11256 *readStreamPtrPtr += 1 * 8;
11257 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11258 auto unboxed_device = unbox_VkDevice(device);
11259 auto vk = dispatch_VkDevice(device);
11260 // End manual dispatchable handle unboxing for device;
11261 vkReadStream->alloc((void**)&pInfo,
11262 sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo));
11263 reservedunmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
11264 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11265 (VkDeviceMemoryOpaqueCaptureAddressInfo*)(pInfo), readStreamPtrPtr);
11266 if (pInfo) {
11267 transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo(
11268 m_state, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(pInfo));
11269 }
11270 if (m_logCalls) {
11271 fprintf(
11272 stderr,
11273 "stream %p: call vkGetDeviceMemoryOpaqueCaptureAddress 0x%llx 0x%llx \n",
11274 ioStream, (unsigned long long)device, (unsigned long long)pInfo);
11275 }
11276 uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
11277 vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
11278 vk->vkGetDeviceMemoryOpaqueCaptureAddress(unboxed_device, pInfo);
11279 vkStream->unsetHandleMapping();
11280 vkStream->write(&vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return,
11281 sizeof(uint64_t));
11282 vkStream->commitWrite();
11283 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11284 (uintptr_t)snapshotTraceBegin);
11285 size_t snapshotTraceBytes = vkReadStream->endTrace();
11286 if (m_state->snapshotsEnabled()) {
11287 m_state->snapshot()->vkGetDeviceMemoryOpaqueCaptureAddress(
11288 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
11289 vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return, device, pInfo);
11290 }
11291 vkReadStream->clearPool();
11292 if (m_queueSubmitWithCommandsEnabled)
11293 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11294 break;
11295 }
11296 #endif
11297 #ifdef VK_VERSION_1_3
11298 case OP_vkGetPhysicalDeviceToolProperties: {
11299 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11300 "VkDecoder vkGetPhysicalDeviceToolProperties");
11301 VkPhysicalDevice physicalDevice;
11302 uint32_t* pToolCount;
11303 VkPhysicalDeviceToolProperties* pToolProperties;
11304 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
11305 uint64_t cgen_var_0;
11306 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11307 *readStreamPtrPtr += 1 * 8;
11308 *(VkPhysicalDevice*)&physicalDevice =
11309 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
11310 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
11311 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
11312 // End manual dispatchable handle unboxing for physicalDevice;
11313 // Begin manual dispatchable handle unboxing for pToolCount;
11314 vkReadStream->unsetHandleMapping();
11315 // WARNING PTR CHECK
11316 memcpy((uint32_t**)&pToolCount, (*readStreamPtrPtr), 8);
11317 android::base::Stream::fromBe64((uint8_t*)&pToolCount);
11318 *readStreamPtrPtr += 8;
11319 if (pToolCount) {
11320 vkReadStream->alloc((void**)&pToolCount, sizeof(uint32_t));
11321 memcpy((uint32_t*)pToolCount, *readStreamPtrPtr, sizeof(uint32_t));
11322 *readStreamPtrPtr += sizeof(uint32_t);
11323 }
11324 // Begin manual dispatchable handle unboxing for pToolProperties;
11325 vkReadStream->unsetHandleMapping();
11326 // WARNING PTR CHECK
11327 memcpy((VkPhysicalDeviceToolProperties**)&pToolProperties, (*readStreamPtrPtr), 8);
11328 android::base::Stream::fromBe64((uint8_t*)&pToolProperties);
11329 *readStreamPtrPtr += 8;
11330 if (pToolProperties) {
11331 vkReadStream->alloc((void**)&pToolProperties,
11332 (*(pToolCount)) * sizeof(VkPhysicalDeviceToolProperties));
11333 for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
11334 reservedunmarshal_VkPhysicalDeviceToolProperties(
11335 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11336 (VkPhysicalDeviceToolProperties*)(pToolProperties + i),
11337 readStreamPtrPtr);
11338 }
11339 }
11340 if (pToolCount) {
11341 if (pToolProperties) {
11342 for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
11343 transform_tohost_VkPhysicalDeviceToolProperties(
11344 m_state, (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
11345 }
11346 }
11347 }
11348 if (m_logCalls) {
11349 fprintf(
11350 stderr,
11351 "stream %p: call vkGetPhysicalDeviceToolProperties 0x%llx 0x%llx 0x%llx \n",
11352 ioStream, (unsigned long long)physicalDevice,
11353 (unsigned long long)pToolCount, (unsigned long long)pToolProperties);
11354 }
11355 VkResult vkGetPhysicalDeviceToolProperties_VkResult_return = (VkResult)0;
11356 vkGetPhysicalDeviceToolProperties_VkResult_return =
11357 vk->vkGetPhysicalDeviceToolProperties(unboxed_physicalDevice, pToolCount,
11358 pToolProperties);
11359 if ((vkGetPhysicalDeviceToolProperties_VkResult_return) == VK_ERROR_DEVICE_LOST)
11360 m_state->on_DeviceLost();
11361 m_state->on_CheckOutOfMemory(vkGetPhysicalDeviceToolProperties_VkResult_return,
11362 opcode, context);
11363 vkStream->unsetHandleMapping();
11364 // WARNING PTR CHECK
11365 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pToolCount;
11366 vkStream->putBe64(cgen_var_3);
11367 if (pToolCount) {
11368 vkStream->write((uint32_t*)pToolCount, sizeof(uint32_t));
11369 }
11370 if (pToolCount) {
11371 if (pToolProperties) {
11372 for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
11373 transform_fromhost_VkPhysicalDeviceToolProperties(
11374 m_state, (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
11375 }
11376 }
11377 }
11378 // WARNING PTR CHECK
11379 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pToolProperties;
11380 vkStream->putBe64(cgen_var_4);
11381 if (pToolProperties) {
11382 if (pToolCount) {
11383 for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
11384 marshal_VkPhysicalDeviceToolProperties(
11385 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11386 (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
11387 }
11388 }
11389 }
11390 vkStream->write(&vkGetPhysicalDeviceToolProperties_VkResult_return,
11391 sizeof(VkResult));
11392 vkStream->commitWrite();
11393 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11394 (uintptr_t)snapshotTraceBegin);
11395 size_t snapshotTraceBytes = vkReadStream->endTrace();
11396 if (m_state->snapshotsEnabled()) {
11397 m_state->snapshot()->vkGetPhysicalDeviceToolProperties(
11398 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
11399 vkGetPhysicalDeviceToolProperties_VkResult_return, physicalDevice,
11400 pToolCount, pToolProperties);
11401 }
11402 vkReadStream->clearPool();
11403 if (m_queueSubmitWithCommandsEnabled)
11404 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11405 break;
11406 }
11407 case OP_vkCreatePrivateDataSlot: {
11408 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11409 "VkDecoder vkCreatePrivateDataSlot");
11410 VkDevice device;
11411 const VkPrivateDataSlotCreateInfo* pCreateInfo;
11412 const VkAllocationCallbacks* pAllocator;
11413 VkPrivateDataSlot* pPrivateDataSlot;
11414 // Begin non wrapped dispatchable handle unboxing for device;
11415 uint64_t cgen_var_0;
11416 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11417 *readStreamPtrPtr += 1 * 8;
11418 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11419 auto unboxed_device = unbox_VkDevice(device);
11420 auto vk = dispatch_VkDevice(device);
11421 // End manual dispatchable handle unboxing for device;
11422 vkReadStream->alloc((void**)&pCreateInfo,
11423 sizeof(const VkPrivateDataSlotCreateInfo));
11424 reservedunmarshal_VkPrivateDataSlotCreateInfo(
11425 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11426 (VkPrivateDataSlotCreateInfo*)(pCreateInfo), readStreamPtrPtr);
11427 // WARNING PTR CHECK
11428 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
11429 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
11430 *readStreamPtrPtr += 8;
11431 if (pAllocator) {
11432 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
11433 reservedunmarshal_VkAllocationCallbacks(
11434 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11435 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
11436 }
11437 // Begin manual dispatchable handle unboxing for pPrivateDataSlot;
11438 vkReadStream->unsetHandleMapping();
11439 vkReadStream->alloc((void**)&pPrivateDataSlot, sizeof(VkPrivateDataSlot));
11440 uint64_t cgen_var_2;
11441 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
11442 *readStreamPtrPtr += 8;
11443 *(VkPrivateDataSlot*)pPrivateDataSlot =
11444 (VkPrivateDataSlot)(VkPrivateDataSlot)((VkPrivateDataSlot)(*&cgen_var_2));
11445 if (pCreateInfo) {
11446 transform_tohost_VkPrivateDataSlotCreateInfo(
11447 m_state, (VkPrivateDataSlotCreateInfo*)(pCreateInfo));
11448 }
11449 if (pAllocator) {
11450 transform_tohost_VkAllocationCallbacks(m_state,
11451 (VkAllocationCallbacks*)(pAllocator));
11452 }
11453 if (m_logCalls) {
11454 fprintf(
11455 stderr,
11456 "stream %p: call vkCreatePrivateDataSlot 0x%llx 0x%llx 0x%llx 0x%llx \n",
11457 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
11458 (unsigned long long)pAllocator, (unsigned long long)pPrivateDataSlot);
11459 }
11460 VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
11461 vkCreatePrivateDataSlot_VkResult_return = vk->vkCreatePrivateDataSlot(
11462 unboxed_device, pCreateInfo, pAllocator, pPrivateDataSlot);
11463 if ((vkCreatePrivateDataSlot_VkResult_return) == VK_ERROR_DEVICE_LOST)
11464 m_state->on_DeviceLost();
11465 m_state->on_CheckOutOfMemory(vkCreatePrivateDataSlot_VkResult_return, opcode,
11466 context);
11467 vkStream->unsetHandleMapping();
11468 // Begin auto non dispatchable handle create for pPrivateDataSlot;
11469 if (vkCreatePrivateDataSlot_VkResult_return == VK_SUCCESS)
11470 vkStream->setHandleMapping(&m_boxedHandleCreateMapping);
11471 uint64_t cgen_var_3;
11472 static_assert(8 == sizeof(VkPrivateDataSlot),
11473 "handle map overwrite requires VkPrivateDataSlot to be 8 bytes long");
11474 vkStream->handleMapping()->mapHandles_VkPrivateDataSlot(
11475 (VkPrivateDataSlot*)pPrivateDataSlot, 1);
11476 vkStream->write((VkPrivateDataSlot*)pPrivateDataSlot, 8 * 1);
11477 // Begin auto non dispatchable handle create for pPrivateDataSlot;
11478 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
11479 vkStream->write(&vkCreatePrivateDataSlot_VkResult_return, sizeof(VkResult));
11480 vkStream->commitWrite();
11481 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11482 (uintptr_t)snapshotTraceBegin);
11483 size_t snapshotTraceBytes = vkReadStream->endTrace();
11484 if (m_state->snapshotsEnabled()) {
11485 m_state->snapshot()->vkCreatePrivateDataSlot(
11486 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
11487 vkCreatePrivateDataSlot_VkResult_return, device, pCreateInfo, pAllocator,
11488 pPrivateDataSlot);
11489 }
11490 vkReadStream->clearPool();
11491 if (m_queueSubmitWithCommandsEnabled)
11492 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11493 break;
11494 }
11495 case OP_vkDestroyPrivateDataSlot: {
11496 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11497 "VkDecoder vkDestroyPrivateDataSlot");
11498 VkDevice device;
11499 VkPrivateDataSlot privateDataSlot;
11500 const VkAllocationCallbacks* pAllocator;
11501 // Begin non wrapped dispatchable handle unboxing for device;
11502 uint64_t cgen_var_0;
11503 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11504 *readStreamPtrPtr += 1 * 8;
11505 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11506 auto unboxed_device = unbox_VkDevice(device);
11507 auto vk = dispatch_VkDevice(device);
11508 // End manual dispatchable handle unboxing for device;
11509 // Begin manual non dispatchable handle destroy unboxing for privateDataSlot;
11510 VkPrivateDataSlot boxed_privateDataSlot_preserve;
11511 uint64_t cgen_var_1;
11512 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
11513 *readStreamPtrPtr += 1 * 8;
11514 *(VkPrivateDataSlot*)&privateDataSlot =
11515 (VkPrivateDataSlot)(VkPrivateDataSlot)((VkPrivateDataSlot)(*&cgen_var_1));
11516 boxed_privateDataSlot_preserve = privateDataSlot;
11517 privateDataSlot = try_unbox_VkPrivateDataSlot(privateDataSlot);
11518 // WARNING PTR CHECK
11519 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
11520 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
11521 *readStreamPtrPtr += 8;
11522 if (pAllocator) {
11523 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
11524 reservedunmarshal_VkAllocationCallbacks(
11525 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11526 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
11527 }
11528 if (pAllocator) {
11529 transform_tohost_VkAllocationCallbacks(m_state,
11530 (VkAllocationCallbacks*)(pAllocator));
11531 }
11532 if (m_logCalls) {
11533 fprintf(stderr,
11534 "stream %p: call vkDestroyPrivateDataSlot 0x%llx 0x%llx 0x%llx \n",
11535 ioStream, (unsigned long long)device,
11536 (unsigned long long)privateDataSlot, (unsigned long long)pAllocator);
11537 }
11538 vk->vkDestroyPrivateDataSlot(unboxed_device, privateDataSlot, pAllocator);
11539 vkStream->unsetHandleMapping();
11540 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11541 (uintptr_t)snapshotTraceBegin);
11542 size_t snapshotTraceBytes = vkReadStream->endTrace();
11543 if (m_state->snapshotsEnabled()) {
11544 m_state->snapshot()->vkDestroyPrivateDataSlot(
11545 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
11546 boxed_privateDataSlot_preserve, pAllocator);
11547 }
11548 delete_VkPrivateDataSlot(boxed_privateDataSlot_preserve);
11549 vkReadStream->clearPool();
11550 if (m_queueSubmitWithCommandsEnabled)
11551 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11552 break;
11553 }
11554 case OP_vkSetPrivateData: {
11555 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11556 "VkDecoder vkSetPrivateData");
11557 VkDevice device;
11558 VkObjectType objectType;
11559 uint64_t objectHandle;
11560 VkPrivateDataSlot privateDataSlot;
11561 uint64_t data;
11562 // Begin non wrapped dispatchable handle unboxing for device;
11563 uint64_t cgen_var_0;
11564 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11565 *readStreamPtrPtr += 1 * 8;
11566 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11567 auto unboxed_device = unbox_VkDevice(device);
11568 auto vk = dispatch_VkDevice(device);
11569 // End manual dispatchable handle unboxing for device;
11570 memcpy((VkObjectType*)&objectType, *readStreamPtrPtr, sizeof(VkObjectType));
11571 *readStreamPtrPtr += sizeof(VkObjectType);
11572 memcpy((uint64_t*)&objectHandle, *readStreamPtrPtr, sizeof(uint64_t));
11573 *readStreamPtrPtr += sizeof(uint64_t);
11574 uint64_t cgen_var_1;
11575 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
11576 *readStreamPtrPtr += 1 * 8;
11577 *(VkPrivateDataSlot*)&privateDataSlot =
11578 (VkPrivateDataSlot)unbox_VkPrivateDataSlot((VkPrivateDataSlot)(*&cgen_var_1));
11579 memcpy((uint64_t*)&data, *readStreamPtrPtr, sizeof(uint64_t));
11580 *readStreamPtrPtr += sizeof(uint64_t);
11581 if (m_logCalls) {
11582 fprintf(
11583 stderr,
11584 "stream %p: call vkSetPrivateData 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
11585 ioStream, (unsigned long long)device, (unsigned long long)objectType,
11586 (unsigned long long)objectHandle, (unsigned long long)privateDataSlot,
11587 (unsigned long long)data);
11588 }
11589 VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
11590 vkSetPrivateData_VkResult_return = vk->vkSetPrivateData(
11591 unboxed_device, objectType, objectHandle, privateDataSlot, data);
11592 if ((vkSetPrivateData_VkResult_return) == VK_ERROR_DEVICE_LOST)
11593 m_state->on_DeviceLost();
11594 m_state->on_CheckOutOfMemory(vkSetPrivateData_VkResult_return, opcode, context);
11595 vkStream->unsetHandleMapping();
11596 vkStream->write(&vkSetPrivateData_VkResult_return, sizeof(VkResult));
11597 vkStream->commitWrite();
11598 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11599 (uintptr_t)snapshotTraceBegin);
11600 size_t snapshotTraceBytes = vkReadStream->endTrace();
11601 if (m_state->snapshotsEnabled()) {
11602 m_state->snapshot()->vkSetPrivateData(snapshotTraceBegin, snapshotTraceBytes,
11603 &m_pool, vkSetPrivateData_VkResult_return,
11604 device, objectType, objectHandle,
11605 privateDataSlot, data);
11606 }
11607 vkReadStream->clearPool();
11608 if (m_queueSubmitWithCommandsEnabled)
11609 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11610 break;
11611 }
11612 case OP_vkGetPrivateData: {
11613 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11614 "VkDecoder vkGetPrivateData");
11615 VkDevice device;
11616 VkObjectType objectType;
11617 uint64_t objectHandle;
11618 VkPrivateDataSlot privateDataSlot;
11619 uint64_t* pData;
11620 // Begin non wrapped dispatchable handle unboxing for device;
11621 uint64_t cgen_var_0;
11622 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11623 *readStreamPtrPtr += 1 * 8;
11624 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
11625 auto unboxed_device = unbox_VkDevice(device);
11626 auto vk = dispatch_VkDevice(device);
11627 // End manual dispatchable handle unboxing for device;
11628 memcpy((VkObjectType*)&objectType, *readStreamPtrPtr, sizeof(VkObjectType));
11629 *readStreamPtrPtr += sizeof(VkObjectType);
11630 memcpy((uint64_t*)&objectHandle, *readStreamPtrPtr, sizeof(uint64_t));
11631 *readStreamPtrPtr += sizeof(uint64_t);
11632 uint64_t cgen_var_1;
11633 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
11634 *readStreamPtrPtr += 1 * 8;
11635 *(VkPrivateDataSlot*)&privateDataSlot =
11636 (VkPrivateDataSlot)unbox_VkPrivateDataSlot((VkPrivateDataSlot)(*&cgen_var_1));
11637 // Begin manual dispatchable handle unboxing for pData;
11638 vkReadStream->unsetHandleMapping();
11639 vkReadStream->alloc((void**)&pData, sizeof(uint64_t));
11640 memcpy((uint64_t*)pData, *readStreamPtrPtr, sizeof(uint64_t));
11641 *readStreamPtrPtr += sizeof(uint64_t);
11642 if (m_logCalls) {
11643 fprintf(
11644 stderr,
11645 "stream %p: call vkGetPrivateData 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
11646 ioStream, (unsigned long long)device, (unsigned long long)objectType,
11647 (unsigned long long)objectHandle, (unsigned long long)privateDataSlot,
11648 (unsigned long long)pData);
11649 }
11650 vk->vkGetPrivateData(unboxed_device, objectType, objectHandle, privateDataSlot,
11651 pData);
11652 vkStream->unsetHandleMapping();
11653 vkStream->write((uint64_t*)pData, sizeof(uint64_t));
11654 vkStream->commitWrite();
11655 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11656 (uintptr_t)snapshotTraceBegin);
11657 size_t snapshotTraceBytes = vkReadStream->endTrace();
11658 if (m_state->snapshotsEnabled()) {
11659 m_state->snapshot()->vkGetPrivateData(snapshotTraceBegin, snapshotTraceBytes,
11660 &m_pool, device, objectType, objectHandle,
11661 privateDataSlot, pData);
11662 }
11663 vkReadStream->clearPool();
11664 if (m_queueSubmitWithCommandsEnabled)
11665 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11666 break;
11667 }
11668 case OP_vkCmdSetEvent2: {
11669 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkCmdSetEvent2");
11670 VkCommandBuffer commandBuffer;
11671 VkEvent event;
11672 const VkDependencyInfo* pDependencyInfo;
11673 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
11674 uint64_t cgen_var_0;
11675 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11676 *readStreamPtrPtr += 1 * 8;
11677 *(VkCommandBuffer*)&commandBuffer =
11678 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
11679 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
11680 auto vk = dispatch_VkCommandBuffer(commandBuffer);
11681 // End manual dispatchable handle unboxing for commandBuffer;
11682 uint64_t cgen_var_1;
11683 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
11684 *readStreamPtrPtr += 1 * 8;
11685 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
11686 vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfo));
11687 reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11688 (VkDependencyInfo*)(pDependencyInfo),
11689 readStreamPtrPtr);
11690 if (pDependencyInfo) {
11691 transform_tohost_VkDependencyInfo(m_state,
11692 (VkDependencyInfo*)(pDependencyInfo));
11693 }
11694 if (m_logCalls) {
11695 fprintf(stderr, "stream %p: call vkCmdSetEvent2 0x%llx 0x%llx 0x%llx \n",
11696 ioStream, (unsigned long long)commandBuffer, (unsigned long long)event,
11697 (unsigned long long)pDependencyInfo);
11698 }
11699 vk->vkCmdSetEvent2(unboxed_commandBuffer, event, pDependencyInfo);
11700 vkStream->unsetHandleMapping();
11701 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11702 (uintptr_t)snapshotTraceBegin);
11703 size_t snapshotTraceBytes = vkReadStream->endTrace();
11704 if (m_state->snapshotsEnabled()) {
11705 m_state->snapshot()->vkCmdSetEvent2(snapshotTraceBegin, snapshotTraceBytes,
11706 &m_pool, commandBuffer, event,
11707 pDependencyInfo);
11708 }
11709 vkReadStream->clearPool();
11710 if (m_queueSubmitWithCommandsEnabled)
11711 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11712 break;
11713 }
11714 case OP_vkCmdResetEvent2: {
11715 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11716 "VkDecoder vkCmdResetEvent2");
11717 VkCommandBuffer commandBuffer;
11718 VkEvent event;
11719 VkPipelineStageFlags2 stageMask;
11720 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
11721 uint64_t cgen_var_0;
11722 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11723 *readStreamPtrPtr += 1 * 8;
11724 *(VkCommandBuffer*)&commandBuffer =
11725 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
11726 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
11727 auto vk = dispatch_VkCommandBuffer(commandBuffer);
11728 // End manual dispatchable handle unboxing for commandBuffer;
11729 uint64_t cgen_var_1;
11730 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
11731 *readStreamPtrPtr += 1 * 8;
11732 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
11733 memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
11734 sizeof(VkPipelineStageFlags2));
11735 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
11736 if (m_logCalls) {
11737 fprintf(stderr, "stream %p: call vkCmdResetEvent2 0x%llx 0x%llx 0x%llx \n",
11738 ioStream, (unsigned long long)commandBuffer, (unsigned long long)event,
11739 (unsigned long long)stageMask);
11740 }
11741 vk->vkCmdResetEvent2(unboxed_commandBuffer, event, stageMask);
11742 vkStream->unsetHandleMapping();
11743 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11744 (uintptr_t)snapshotTraceBegin);
11745 size_t snapshotTraceBytes = vkReadStream->endTrace();
11746 if (m_state->snapshotsEnabled()) {
11747 m_state->snapshot()->vkCmdResetEvent2(snapshotTraceBegin, snapshotTraceBytes,
11748 &m_pool, commandBuffer, event, stageMask);
11749 }
11750 vkReadStream->clearPool();
11751 if (m_queueSubmitWithCommandsEnabled)
11752 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11753 break;
11754 }
11755 case OP_vkCmdWaitEvents2: {
11756 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11757 "VkDecoder vkCmdWaitEvents2");
11758 VkCommandBuffer commandBuffer;
11759 uint32_t eventCount;
11760 const VkEvent* pEvents;
11761 const VkDependencyInfo* pDependencyInfos;
11762 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
11763 uint64_t cgen_var_0;
11764 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11765 *readStreamPtrPtr += 1 * 8;
11766 *(VkCommandBuffer*)&commandBuffer =
11767 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
11768 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
11769 auto vk = dispatch_VkCommandBuffer(commandBuffer);
11770 // End manual dispatchable handle unboxing for commandBuffer;
11771 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
11772 *readStreamPtrPtr += sizeof(uint32_t);
11773 vkReadStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
11774 if (((eventCount))) {
11775 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
11776 *readStreamPtrPtr += 8 * ((eventCount));
11777 for (uint32_t k = 0; k < ((eventCount)); ++k) {
11778 uint64_t tmpval;
11779 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
11780 *(((VkEvent*)pEvents) + k) =
11781 tmpval ? (VkEvent)unbox_VkEvent((VkEvent)tmpval) : VK_NULL_HANDLE;
11782 }
11783 }
11784 vkReadStream->alloc((void**)&pDependencyInfos,
11785 ((eventCount)) * sizeof(const VkDependencyInfo));
11786 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
11787 reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11788 (VkDependencyInfo*)(pDependencyInfos + i),
11789 readStreamPtrPtr);
11790 }
11791 if (pDependencyInfos) {
11792 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
11793 transform_tohost_VkDependencyInfo(
11794 m_state, (VkDependencyInfo*)(pDependencyInfos + i));
11795 }
11796 }
11797 if (m_logCalls) {
11798 fprintf(
11799 stderr, "stream %p: call vkCmdWaitEvents2 0x%llx 0x%llx 0x%llx 0x%llx \n",
11800 ioStream, (unsigned long long)commandBuffer, (unsigned long long)eventCount,
11801 (unsigned long long)pEvents, (unsigned long long)pDependencyInfos);
11802 }
11803 vk->vkCmdWaitEvents2(unboxed_commandBuffer, eventCount, pEvents, pDependencyInfos);
11804 vkStream->unsetHandleMapping();
11805 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11806 (uintptr_t)snapshotTraceBegin);
11807 size_t snapshotTraceBytes = vkReadStream->endTrace();
11808 if (m_state->snapshotsEnabled()) {
11809 m_state->snapshot()->vkCmdWaitEvents2(snapshotTraceBegin, snapshotTraceBytes,
11810 &m_pool, commandBuffer, eventCount,
11811 pEvents, pDependencyInfos);
11812 }
11813 vkReadStream->clearPool();
11814 if (m_queueSubmitWithCommandsEnabled)
11815 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11816 break;
11817 }
11818 case OP_vkCmdPipelineBarrier2: {
11819 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11820 "VkDecoder vkCmdPipelineBarrier2");
11821 VkCommandBuffer commandBuffer;
11822 const VkDependencyInfo* pDependencyInfo;
11823 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
11824 uint64_t cgen_var_0;
11825 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11826 *readStreamPtrPtr += 1 * 8;
11827 *(VkCommandBuffer*)&commandBuffer =
11828 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
11829 vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfo));
11830 reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11831 (VkDependencyInfo*)(pDependencyInfo),
11832 readStreamPtrPtr);
11833 if (pDependencyInfo) {
11834 transform_tohost_VkDependencyInfo(m_state,
11835 (VkDependencyInfo*)(pDependencyInfo));
11836 }
11837 if (m_logCalls) {
11838 fprintf(stderr, "stream %p: call vkCmdPipelineBarrier2 0x%llx 0x%llx \n",
11839 ioStream, (unsigned long long)commandBuffer,
11840 (unsigned long long)pDependencyInfo);
11841 }
11842 m_state->on_vkCmdPipelineBarrier2(&m_pool, commandBuffer, pDependencyInfo);
11843 vkStream->unsetHandleMapping();
11844 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11845 (uintptr_t)snapshotTraceBegin);
11846 size_t snapshotTraceBytes = vkReadStream->endTrace();
11847 if (m_state->snapshotsEnabled()) {
11848 m_state->snapshot()->vkCmdPipelineBarrier2(snapshotTraceBegin,
11849 snapshotTraceBytes, &m_pool,
11850 commandBuffer, pDependencyInfo);
11851 }
11852 vkReadStream->clearPool();
11853 if (m_queueSubmitWithCommandsEnabled)
11854 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11855 break;
11856 }
11857 case OP_vkCmdWriteTimestamp2: {
11858 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11859 "VkDecoder vkCmdWriteTimestamp2");
11860 VkCommandBuffer commandBuffer;
11861 VkPipelineStageFlags2 stage;
11862 VkQueryPool queryPool;
11863 uint32_t query;
11864 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
11865 uint64_t cgen_var_0;
11866 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11867 *readStreamPtrPtr += 1 * 8;
11868 *(VkCommandBuffer*)&commandBuffer =
11869 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
11870 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
11871 auto vk = dispatch_VkCommandBuffer(commandBuffer);
11872 // End manual dispatchable handle unboxing for commandBuffer;
11873 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
11874 sizeof(VkPipelineStageFlags2));
11875 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
11876 uint64_t cgen_var_1;
11877 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
11878 *readStreamPtrPtr += 1 * 8;
11879 *(VkQueryPool*)&queryPool =
11880 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
11881 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
11882 *readStreamPtrPtr += sizeof(uint32_t);
11883 if (m_logCalls) {
11884 fprintf(stderr,
11885 "stream %p: call vkCmdWriteTimestamp2 0x%llx 0x%llx 0x%llx 0x%llx \n",
11886 ioStream, (unsigned long long)commandBuffer, (unsigned long long)stage,
11887 (unsigned long long)queryPool, (unsigned long long)query);
11888 }
11889 vk->vkCmdWriteTimestamp2(unboxed_commandBuffer, stage, queryPool, query);
11890 vkStream->unsetHandleMapping();
11891 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11892 (uintptr_t)snapshotTraceBegin);
11893 size_t snapshotTraceBytes = vkReadStream->endTrace();
11894 if (m_state->snapshotsEnabled()) {
11895 m_state->snapshot()->vkCmdWriteTimestamp2(
11896 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, stage,
11897 queryPool, query);
11898 }
11899 vkReadStream->clearPool();
11900 if (m_queueSubmitWithCommandsEnabled)
11901 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11902 break;
11903 }
11904 case OP_vkQueueSubmit2: {
11905 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkDecoder vkQueueSubmit2");
11906 VkQueue queue;
11907 uint32_t submitCount;
11908 const VkSubmitInfo2* pSubmits;
11909 VkFence fence;
11910 // Begin global wrapped dispatchable handle unboxing for queue;
11911 uint64_t cgen_var_0;
11912 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11913 *readStreamPtrPtr += 1 * 8;
11914 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
11915 memcpy((uint32_t*)&submitCount, *readStreamPtrPtr, sizeof(uint32_t));
11916 *readStreamPtrPtr += sizeof(uint32_t);
11917 vkReadStream->alloc((void**)&pSubmits,
11918 ((submitCount)) * sizeof(const VkSubmitInfo2));
11919 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
11920 reservedunmarshal_VkSubmitInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11921 (VkSubmitInfo2*)(pSubmits + i),
11922 readStreamPtrPtr);
11923 }
11924 uint64_t cgen_var_1;
11925 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
11926 *readStreamPtrPtr += 1 * 8;
11927 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
11928 if (pSubmits) {
11929 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
11930 transform_tohost_VkSubmitInfo2(m_state, (VkSubmitInfo2*)(pSubmits + i));
11931 }
11932 }
11933 if (m_logCalls) {
11934 fprintf(stderr, "stream %p: call vkQueueSubmit2 0x%llx 0x%llx 0x%llx 0x%llx \n",
11935 ioStream, (unsigned long long)queue, (unsigned long long)submitCount,
11936 (unsigned long long)pSubmits, (unsigned long long)fence);
11937 }
11938 VkResult vkQueueSubmit2_VkResult_return = (VkResult)0;
11939 vkQueueSubmit2_VkResult_return =
11940 m_state->on_vkQueueSubmit2(&m_pool, queue, submitCount, pSubmits, fence);
11941 if ((vkQueueSubmit2_VkResult_return) == VK_ERROR_DEVICE_LOST)
11942 m_state->on_DeviceLost();
11943 m_state->on_CheckOutOfMemory(vkQueueSubmit2_VkResult_return, opcode, context);
11944 vkStream->unsetHandleMapping();
11945 vkStream->write(&vkQueueSubmit2_VkResult_return, sizeof(VkResult));
11946 vkStream->commitWrite();
11947 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11948 (uintptr_t)snapshotTraceBegin);
11949 size_t snapshotTraceBytes = vkReadStream->endTrace();
11950 if (m_state->snapshotsEnabled()) {
11951 m_state->snapshot()->vkQueueSubmit2(snapshotTraceBegin, snapshotTraceBytes,
11952 &m_pool, vkQueueSubmit2_VkResult_return,
11953 queue, submitCount, pSubmits, fence);
11954 }
11955 vkReadStream->clearPool();
11956 if (m_queueSubmitWithCommandsEnabled)
11957 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11958 break;
11959 }
11960 case OP_vkCmdCopyBuffer2: {
11961 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
11962 "VkDecoder vkCmdCopyBuffer2");
11963 VkCommandBuffer commandBuffer;
11964 const VkCopyBufferInfo2* pCopyBufferInfo;
11965 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
11966 uint64_t cgen_var_0;
11967 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
11968 *readStreamPtrPtr += 1 * 8;
11969 *(VkCommandBuffer*)&commandBuffer =
11970 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
11971 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
11972 auto vk = dispatch_VkCommandBuffer(commandBuffer);
11973 // End manual dispatchable handle unboxing for commandBuffer;
11974 vkReadStream->alloc((void**)&pCopyBufferInfo, sizeof(const VkCopyBufferInfo2));
11975 reservedunmarshal_VkCopyBufferInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
11976 (VkCopyBufferInfo2*)(pCopyBufferInfo),
11977 readStreamPtrPtr);
11978 if (pCopyBufferInfo) {
11979 transform_tohost_VkCopyBufferInfo2(m_state,
11980 (VkCopyBufferInfo2*)(pCopyBufferInfo));
11981 }
11982 if (m_logCalls) {
11983 fprintf(stderr, "stream %p: call vkCmdCopyBuffer2 0x%llx 0x%llx \n", ioStream,
11984 (unsigned long long)commandBuffer, (unsigned long long)pCopyBufferInfo);
11985 }
11986 vk->vkCmdCopyBuffer2(unboxed_commandBuffer, pCopyBufferInfo);
11987 vkStream->unsetHandleMapping();
11988 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
11989 (uintptr_t)snapshotTraceBegin);
11990 size_t snapshotTraceBytes = vkReadStream->endTrace();
11991 if (m_state->snapshotsEnabled()) {
11992 m_state->snapshot()->vkCmdCopyBuffer2(snapshotTraceBegin, snapshotTraceBytes,
11993 &m_pool, commandBuffer, pCopyBufferInfo);
11994 }
11995 vkReadStream->clearPool();
11996 if (m_queueSubmitWithCommandsEnabled)
11997 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
11998 break;
11999 }
12000 case OP_vkCmdCopyImage2: {
12001 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12002 "VkDecoder vkCmdCopyImage2");
12003 VkCommandBuffer commandBuffer;
12004 const VkCopyImageInfo2* pCopyImageInfo;
12005 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
12006 uint64_t cgen_var_0;
12007 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12008 *readStreamPtrPtr += 1 * 8;
12009 *(VkCommandBuffer*)&commandBuffer =
12010 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12011 vkReadStream->alloc((void**)&pCopyImageInfo, sizeof(const VkCopyImageInfo2));
12012 reservedunmarshal_VkCopyImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12013 (VkCopyImageInfo2*)(pCopyImageInfo),
12014 readStreamPtrPtr);
12015 if (pCopyImageInfo) {
12016 transform_tohost_VkCopyImageInfo2(m_state, (VkCopyImageInfo2*)(pCopyImageInfo));
12017 }
12018 if (m_logCalls) {
12019 fprintf(stderr, "stream %p: call vkCmdCopyImage2 0x%llx 0x%llx \n", ioStream,
12020 (unsigned long long)commandBuffer, (unsigned long long)pCopyImageInfo);
12021 }
12022 m_state->on_vkCmdCopyImage2(&m_pool, commandBuffer, pCopyImageInfo);
12023 vkStream->unsetHandleMapping();
12024 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12025 (uintptr_t)snapshotTraceBegin);
12026 size_t snapshotTraceBytes = vkReadStream->endTrace();
12027 if (m_state->snapshotsEnabled()) {
12028 m_state->snapshot()->vkCmdCopyImage2(snapshotTraceBegin, snapshotTraceBytes,
12029 &m_pool, commandBuffer, pCopyImageInfo);
12030 }
12031 vkReadStream->clearPool();
12032 if (m_queueSubmitWithCommandsEnabled)
12033 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12034 break;
12035 }
12036 case OP_vkCmdCopyBufferToImage2: {
12037 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12038 "VkDecoder vkCmdCopyBufferToImage2");
12039 VkCommandBuffer commandBuffer;
12040 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
12041 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
12042 uint64_t cgen_var_0;
12043 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12044 *readStreamPtrPtr += 1 * 8;
12045 *(VkCommandBuffer*)&commandBuffer =
12046 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12047 vkReadStream->alloc((void**)&pCopyBufferToImageInfo,
12048 sizeof(const VkCopyBufferToImageInfo2));
12049 reservedunmarshal_VkCopyBufferToImageInfo2(
12050 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12051 (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
12052 if (pCopyBufferToImageInfo) {
12053 transform_tohost_VkCopyBufferToImageInfo2(
12054 m_state, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
12055 }
12056 if (m_logCalls) {
12057 fprintf(stderr, "stream %p: call vkCmdCopyBufferToImage2 0x%llx 0x%llx \n",
12058 ioStream, (unsigned long long)commandBuffer,
12059 (unsigned long long)pCopyBufferToImageInfo);
12060 }
12061 m_state->on_vkCmdCopyBufferToImage2(&m_pool, commandBuffer, pCopyBufferToImageInfo,
12062 context);
12063 vkStream->unsetHandleMapping();
12064 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12065 (uintptr_t)snapshotTraceBegin);
12066 size_t snapshotTraceBytes = vkReadStream->endTrace();
12067 if (m_state->snapshotsEnabled()) {
12068 m_state->snapshot()->vkCmdCopyBufferToImage2(
12069 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12070 pCopyBufferToImageInfo);
12071 }
12072 vkReadStream->clearPool();
12073 if (m_queueSubmitWithCommandsEnabled)
12074 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12075 break;
12076 }
12077 case OP_vkCmdCopyImageToBuffer2: {
12078 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12079 "VkDecoder vkCmdCopyImageToBuffer2");
12080 VkCommandBuffer commandBuffer;
12081 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
12082 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
12083 uint64_t cgen_var_0;
12084 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12085 *readStreamPtrPtr += 1 * 8;
12086 *(VkCommandBuffer*)&commandBuffer =
12087 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12088 vkReadStream->alloc((void**)&pCopyImageToBufferInfo,
12089 sizeof(const VkCopyImageToBufferInfo2));
12090 reservedunmarshal_VkCopyImageToBufferInfo2(
12091 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12092 (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
12093 if (pCopyImageToBufferInfo) {
12094 transform_tohost_VkCopyImageToBufferInfo2(
12095 m_state, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
12096 }
12097 if (m_logCalls) {
12098 fprintf(stderr, "stream %p: call vkCmdCopyImageToBuffer2 0x%llx 0x%llx \n",
12099 ioStream, (unsigned long long)commandBuffer,
12100 (unsigned long long)pCopyImageToBufferInfo);
12101 }
12102 m_state->on_vkCmdCopyImageToBuffer2(&m_pool, commandBuffer, pCopyImageToBufferInfo);
12103 vkStream->unsetHandleMapping();
12104 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12105 (uintptr_t)snapshotTraceBegin);
12106 size_t snapshotTraceBytes = vkReadStream->endTrace();
12107 if (m_state->snapshotsEnabled()) {
12108 m_state->snapshot()->vkCmdCopyImageToBuffer2(
12109 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12110 pCopyImageToBufferInfo);
12111 }
12112 vkReadStream->clearPool();
12113 if (m_queueSubmitWithCommandsEnabled)
12114 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12115 break;
12116 }
12117 case OP_vkCmdBlitImage2: {
12118 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12119 "VkDecoder vkCmdBlitImage2");
12120 VkCommandBuffer commandBuffer;
12121 const VkBlitImageInfo2* pBlitImageInfo;
12122 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12123 uint64_t cgen_var_0;
12124 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12125 *readStreamPtrPtr += 1 * 8;
12126 *(VkCommandBuffer*)&commandBuffer =
12127 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12128 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12129 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12130 // End manual dispatchable handle unboxing for commandBuffer;
12131 vkReadStream->alloc((void**)&pBlitImageInfo, sizeof(const VkBlitImageInfo2));
12132 reservedunmarshal_VkBlitImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12133 (VkBlitImageInfo2*)(pBlitImageInfo),
12134 readStreamPtrPtr);
12135 if (pBlitImageInfo) {
12136 transform_tohost_VkBlitImageInfo2(m_state, (VkBlitImageInfo2*)(pBlitImageInfo));
12137 }
12138 if (m_logCalls) {
12139 fprintf(stderr, "stream %p: call vkCmdBlitImage2 0x%llx 0x%llx \n", ioStream,
12140 (unsigned long long)commandBuffer, (unsigned long long)pBlitImageInfo);
12141 }
12142 vk->vkCmdBlitImage2(unboxed_commandBuffer, pBlitImageInfo);
12143 vkStream->unsetHandleMapping();
12144 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12145 (uintptr_t)snapshotTraceBegin);
12146 size_t snapshotTraceBytes = vkReadStream->endTrace();
12147 if (m_state->snapshotsEnabled()) {
12148 m_state->snapshot()->vkCmdBlitImage2(snapshotTraceBegin, snapshotTraceBytes,
12149 &m_pool, commandBuffer, pBlitImageInfo);
12150 }
12151 vkReadStream->clearPool();
12152 if (m_queueSubmitWithCommandsEnabled)
12153 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12154 break;
12155 }
12156 case OP_vkCmdResolveImage2: {
12157 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12158 "VkDecoder vkCmdResolveImage2");
12159 VkCommandBuffer commandBuffer;
12160 const VkResolveImageInfo2* pResolveImageInfo;
12161 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12162 uint64_t cgen_var_0;
12163 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12164 *readStreamPtrPtr += 1 * 8;
12165 *(VkCommandBuffer*)&commandBuffer =
12166 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12167 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12168 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12169 // End manual dispatchable handle unboxing for commandBuffer;
12170 vkReadStream->alloc((void**)&pResolveImageInfo, sizeof(const VkResolveImageInfo2));
12171 reservedunmarshal_VkResolveImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12172 (VkResolveImageInfo2*)(pResolveImageInfo),
12173 readStreamPtrPtr);
12174 if (pResolveImageInfo) {
12175 transform_tohost_VkResolveImageInfo2(m_state,
12176 (VkResolveImageInfo2*)(pResolveImageInfo));
12177 }
12178 if (m_logCalls) {
12179 fprintf(stderr, "stream %p: call vkCmdResolveImage2 0x%llx 0x%llx \n", ioStream,
12180 (unsigned long long)commandBuffer,
12181 (unsigned long long)pResolveImageInfo);
12182 }
12183 vk->vkCmdResolveImage2(unboxed_commandBuffer, pResolveImageInfo);
12184 vkStream->unsetHandleMapping();
12185 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12186 (uintptr_t)snapshotTraceBegin);
12187 size_t snapshotTraceBytes = vkReadStream->endTrace();
12188 if (m_state->snapshotsEnabled()) {
12189 m_state->snapshot()->vkCmdResolveImage2(snapshotTraceBegin, snapshotTraceBytes,
12190 &m_pool, commandBuffer,
12191 pResolveImageInfo);
12192 }
12193 vkReadStream->clearPool();
12194 if (m_queueSubmitWithCommandsEnabled)
12195 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12196 break;
12197 }
12198 case OP_vkCmdBeginRendering: {
12199 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12200 "VkDecoder vkCmdBeginRendering");
12201 VkCommandBuffer commandBuffer;
12202 const VkRenderingInfo* pRenderingInfo;
12203 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12204 uint64_t cgen_var_0;
12205 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12206 *readStreamPtrPtr += 1 * 8;
12207 *(VkCommandBuffer*)&commandBuffer =
12208 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12209 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12210 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12211 // End manual dispatchable handle unboxing for commandBuffer;
12212 vkReadStream->alloc((void**)&pRenderingInfo, sizeof(const VkRenderingInfo));
12213 reservedunmarshal_VkRenderingInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12214 (VkRenderingInfo*)(pRenderingInfo),
12215 readStreamPtrPtr);
12216 if (pRenderingInfo) {
12217 transform_tohost_VkRenderingInfo(m_state, (VkRenderingInfo*)(pRenderingInfo));
12218 }
12219 if (m_logCalls) {
12220 fprintf(stderr, "stream %p: call vkCmdBeginRendering 0x%llx 0x%llx \n",
12221 ioStream, (unsigned long long)commandBuffer,
12222 (unsigned long long)pRenderingInfo);
12223 }
12224 vk->vkCmdBeginRendering(unboxed_commandBuffer, pRenderingInfo);
12225 vkStream->unsetHandleMapping();
12226 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12227 (uintptr_t)snapshotTraceBegin);
12228 size_t snapshotTraceBytes = vkReadStream->endTrace();
12229 if (m_state->snapshotsEnabled()) {
12230 m_state->snapshot()->vkCmdBeginRendering(snapshotTraceBegin, snapshotTraceBytes,
12231 &m_pool, commandBuffer,
12232 pRenderingInfo);
12233 }
12234 vkReadStream->clearPool();
12235 if (m_queueSubmitWithCommandsEnabled)
12236 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12237 break;
12238 }
12239 case OP_vkCmdEndRendering: {
12240 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12241 "VkDecoder vkCmdEndRendering");
12242 VkCommandBuffer commandBuffer;
12243 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12244 uint64_t cgen_var_0;
12245 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12246 *readStreamPtrPtr += 1 * 8;
12247 *(VkCommandBuffer*)&commandBuffer =
12248 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12249 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12250 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12251 // End manual dispatchable handle unboxing for commandBuffer;
12252 if (m_logCalls) {
12253 fprintf(stderr, "stream %p: call vkCmdEndRendering 0x%llx \n", ioStream,
12254 (unsigned long long)commandBuffer);
12255 }
12256 vk->vkCmdEndRendering(unboxed_commandBuffer);
12257 vkStream->unsetHandleMapping();
12258 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12259 (uintptr_t)snapshotTraceBegin);
12260 size_t snapshotTraceBytes = vkReadStream->endTrace();
12261 if (m_state->snapshotsEnabled()) {
12262 m_state->snapshot()->vkCmdEndRendering(snapshotTraceBegin, snapshotTraceBytes,
12263 &m_pool, commandBuffer);
12264 }
12265 vkReadStream->clearPool();
12266 if (m_queueSubmitWithCommandsEnabled)
12267 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12268 break;
12269 }
12270 case OP_vkCmdSetCullMode: {
12271 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12272 "VkDecoder vkCmdSetCullMode");
12273 VkCommandBuffer commandBuffer;
12274 VkCullModeFlags cullMode;
12275 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12276 uint64_t cgen_var_0;
12277 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12278 *readStreamPtrPtr += 1 * 8;
12279 *(VkCommandBuffer*)&commandBuffer =
12280 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12281 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12282 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12283 // End manual dispatchable handle unboxing for commandBuffer;
12284 memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
12285 *readStreamPtrPtr += sizeof(VkCullModeFlags);
12286 if (m_logCalls) {
12287 fprintf(stderr, "stream %p: call vkCmdSetCullMode 0x%llx 0x%llx \n", ioStream,
12288 (unsigned long long)commandBuffer, (unsigned long long)cullMode);
12289 }
12290 vk->vkCmdSetCullMode(unboxed_commandBuffer, cullMode);
12291 vkStream->unsetHandleMapping();
12292 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12293 (uintptr_t)snapshotTraceBegin);
12294 size_t snapshotTraceBytes = vkReadStream->endTrace();
12295 if (m_state->snapshotsEnabled()) {
12296 m_state->snapshot()->vkCmdSetCullMode(snapshotTraceBegin, snapshotTraceBytes,
12297 &m_pool, commandBuffer, cullMode);
12298 }
12299 vkReadStream->clearPool();
12300 if (m_queueSubmitWithCommandsEnabled)
12301 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12302 break;
12303 }
12304 case OP_vkCmdSetFrontFace: {
12305 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12306 "VkDecoder vkCmdSetFrontFace");
12307 VkCommandBuffer commandBuffer;
12308 VkFrontFace frontFace;
12309 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12310 uint64_t cgen_var_0;
12311 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12312 *readStreamPtrPtr += 1 * 8;
12313 *(VkCommandBuffer*)&commandBuffer =
12314 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12315 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12316 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12317 // End manual dispatchable handle unboxing for commandBuffer;
12318 memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
12319 *readStreamPtrPtr += sizeof(VkFrontFace);
12320 if (m_logCalls) {
12321 fprintf(stderr, "stream %p: call vkCmdSetFrontFace 0x%llx 0x%llx \n", ioStream,
12322 (unsigned long long)commandBuffer, (unsigned long long)frontFace);
12323 }
12324 vk->vkCmdSetFrontFace(unboxed_commandBuffer, frontFace);
12325 vkStream->unsetHandleMapping();
12326 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12327 (uintptr_t)snapshotTraceBegin);
12328 size_t snapshotTraceBytes = vkReadStream->endTrace();
12329 if (m_state->snapshotsEnabled()) {
12330 m_state->snapshot()->vkCmdSetFrontFace(snapshotTraceBegin, snapshotTraceBytes,
12331 &m_pool, commandBuffer, frontFace);
12332 }
12333 vkReadStream->clearPool();
12334 if (m_queueSubmitWithCommandsEnabled)
12335 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12336 break;
12337 }
12338 case OP_vkCmdSetPrimitiveTopology: {
12339 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12340 "VkDecoder vkCmdSetPrimitiveTopology");
12341 VkCommandBuffer commandBuffer;
12342 VkPrimitiveTopology primitiveTopology;
12343 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12344 uint64_t cgen_var_0;
12345 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12346 *readStreamPtrPtr += 1 * 8;
12347 *(VkCommandBuffer*)&commandBuffer =
12348 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12349 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12350 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12351 // End manual dispatchable handle unboxing for commandBuffer;
12352 memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
12353 sizeof(VkPrimitiveTopology));
12354 *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
12355 if (m_logCalls) {
12356 fprintf(stderr, "stream %p: call vkCmdSetPrimitiveTopology 0x%llx 0x%llx \n",
12357 ioStream, (unsigned long long)commandBuffer,
12358 (unsigned long long)primitiveTopology);
12359 }
12360 vk->vkCmdSetPrimitiveTopology(unboxed_commandBuffer, primitiveTopology);
12361 vkStream->unsetHandleMapping();
12362 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12363 (uintptr_t)snapshotTraceBegin);
12364 size_t snapshotTraceBytes = vkReadStream->endTrace();
12365 if (m_state->snapshotsEnabled()) {
12366 m_state->snapshot()->vkCmdSetPrimitiveTopology(
12367 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12368 primitiveTopology);
12369 }
12370 vkReadStream->clearPool();
12371 if (m_queueSubmitWithCommandsEnabled)
12372 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12373 break;
12374 }
12375 case OP_vkCmdSetViewportWithCount: {
12376 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12377 "VkDecoder vkCmdSetViewportWithCount");
12378 VkCommandBuffer commandBuffer;
12379 uint32_t viewportCount;
12380 const VkViewport* pViewports;
12381 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12382 uint64_t cgen_var_0;
12383 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12384 *readStreamPtrPtr += 1 * 8;
12385 *(VkCommandBuffer*)&commandBuffer =
12386 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12387 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12388 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12389 // End manual dispatchable handle unboxing for commandBuffer;
12390 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
12391 *readStreamPtrPtr += sizeof(uint32_t);
12392 vkReadStream->alloc((void**)&pViewports,
12393 ((viewportCount)) * sizeof(const VkViewport));
12394 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
12395 reservedunmarshal_VkViewport(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12396 (VkViewport*)(pViewports + i), readStreamPtrPtr);
12397 }
12398 if (pViewports) {
12399 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
12400 transform_tohost_VkViewport(m_state, (VkViewport*)(pViewports + i));
12401 }
12402 }
12403 if (m_logCalls) {
12404 fprintf(stderr,
12405 "stream %p: call vkCmdSetViewportWithCount 0x%llx 0x%llx 0x%llx \n",
12406 ioStream, (unsigned long long)commandBuffer,
12407 (unsigned long long)viewportCount, (unsigned long long)pViewports);
12408 }
12409 vk->vkCmdSetViewportWithCount(unboxed_commandBuffer, viewportCount, pViewports);
12410 vkStream->unsetHandleMapping();
12411 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12412 (uintptr_t)snapshotTraceBegin);
12413 size_t snapshotTraceBytes = vkReadStream->endTrace();
12414 if (m_state->snapshotsEnabled()) {
12415 m_state->snapshot()->vkCmdSetViewportWithCount(
12416 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12417 viewportCount, pViewports);
12418 }
12419 vkReadStream->clearPool();
12420 if (m_queueSubmitWithCommandsEnabled)
12421 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12422 break;
12423 }
12424 case OP_vkCmdSetScissorWithCount: {
12425 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12426 "VkDecoder vkCmdSetScissorWithCount");
12427 VkCommandBuffer commandBuffer;
12428 uint32_t scissorCount;
12429 const VkRect2D* pScissors;
12430 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12431 uint64_t cgen_var_0;
12432 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12433 *readStreamPtrPtr += 1 * 8;
12434 *(VkCommandBuffer*)&commandBuffer =
12435 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12436 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12437 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12438 // End manual dispatchable handle unboxing for commandBuffer;
12439 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
12440 *readStreamPtrPtr += sizeof(uint32_t);
12441 vkReadStream->alloc((void**)&pScissors, ((scissorCount)) * sizeof(const VkRect2D));
12442 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
12443 reservedunmarshal_VkRect2D(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12444 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
12445 }
12446 if (pScissors) {
12447 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
12448 transform_tohost_VkRect2D(m_state, (VkRect2D*)(pScissors + i));
12449 }
12450 }
12451 if (m_logCalls) {
12452 fprintf(stderr,
12453 "stream %p: call vkCmdSetScissorWithCount 0x%llx 0x%llx 0x%llx \n",
12454 ioStream, (unsigned long long)commandBuffer,
12455 (unsigned long long)scissorCount, (unsigned long long)pScissors);
12456 }
12457 vk->vkCmdSetScissorWithCount(unboxed_commandBuffer, scissorCount, pScissors);
12458 vkStream->unsetHandleMapping();
12459 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12460 (uintptr_t)snapshotTraceBegin);
12461 size_t snapshotTraceBytes = vkReadStream->endTrace();
12462 if (m_state->snapshotsEnabled()) {
12463 m_state->snapshot()->vkCmdSetScissorWithCount(
12464 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12465 scissorCount, pScissors);
12466 }
12467 vkReadStream->clearPool();
12468 if (m_queueSubmitWithCommandsEnabled)
12469 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12470 break;
12471 }
12472 case OP_vkCmdBindVertexBuffers2: {
12473 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12474 "VkDecoder vkCmdBindVertexBuffers2");
12475 VkCommandBuffer commandBuffer;
12476 uint32_t firstBinding;
12477 uint32_t bindingCount;
12478 const VkBuffer* pBuffers;
12479 const VkDeviceSize* pOffsets;
12480 const VkDeviceSize* pSizes;
12481 const VkDeviceSize* pStrides;
12482 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12483 uint64_t cgen_var_0;
12484 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12485 *readStreamPtrPtr += 1 * 8;
12486 *(VkCommandBuffer*)&commandBuffer =
12487 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12488 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12489 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12490 // End manual dispatchable handle unboxing for commandBuffer;
12491 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
12492 *readStreamPtrPtr += sizeof(uint32_t);
12493 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
12494 *readStreamPtrPtr += sizeof(uint32_t);
12495 // WARNING PTR CHECK
12496 memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
12497 android::base::Stream::fromBe64((uint8_t*)&pBuffers);
12498 *readStreamPtrPtr += 8;
12499 if (pBuffers) {
12500 vkReadStream->alloc((void**)&pBuffers,
12501 ((bindingCount)) * sizeof(const VkBuffer));
12502 if (((bindingCount))) {
12503 uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*readStreamPtrPtr);
12504 *readStreamPtrPtr += 8 * ((bindingCount));
12505 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
12506 uint64_t tmpval;
12507 memcpy(&tmpval, cgen_var_1_0_ptr + k * 8, sizeof(uint64_t));
12508 *(((VkBuffer*)pBuffers) + k) =
12509 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
12510 : VK_NULL_HANDLE;
12511 }
12512 }
12513 }
12514 vkReadStream->alloc((void**)&pOffsets,
12515 ((bindingCount)) * sizeof(const VkDeviceSize));
12516 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
12517 ((bindingCount)) * sizeof(const VkDeviceSize));
12518 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
12519 // WARNING PTR CHECK
12520 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
12521 android::base::Stream::fromBe64((uint8_t*)&pSizes);
12522 *readStreamPtrPtr += 8;
12523 if (pSizes) {
12524 vkReadStream->alloc((void**)&pSizes,
12525 ((bindingCount)) * sizeof(const VkDeviceSize));
12526 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
12527 ((bindingCount)) * sizeof(const VkDeviceSize));
12528 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
12529 }
12530 // WARNING PTR CHECK
12531 memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
12532 android::base::Stream::fromBe64((uint8_t*)&pStrides);
12533 *readStreamPtrPtr += 8;
12534 if (pStrides) {
12535 vkReadStream->alloc((void**)&pStrides,
12536 ((bindingCount)) * sizeof(const VkDeviceSize));
12537 memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
12538 ((bindingCount)) * sizeof(const VkDeviceSize));
12539 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
12540 }
12541 if (m_logCalls) {
12542 fprintf(stderr,
12543 "stream %p: call vkCmdBindVertexBuffers2 0x%llx 0x%llx 0x%llx 0x%llx "
12544 "0x%llx 0x%llx 0x%llx \n",
12545 ioStream, (unsigned long long)commandBuffer,
12546 (unsigned long long)firstBinding, (unsigned long long)bindingCount,
12547 (unsigned long long)pBuffers, (unsigned long long)pOffsets,
12548 (unsigned long long)pSizes, (unsigned long long)pStrides);
12549 }
12550 vk->vkCmdBindVertexBuffers2(unboxed_commandBuffer, firstBinding, bindingCount,
12551 pBuffers, pOffsets, pSizes, pStrides);
12552 vkStream->unsetHandleMapping();
12553 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12554 (uintptr_t)snapshotTraceBegin);
12555 size_t snapshotTraceBytes = vkReadStream->endTrace();
12556 if (m_state->snapshotsEnabled()) {
12557 m_state->snapshot()->vkCmdBindVertexBuffers2(
12558 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12559 firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
12560 }
12561 vkReadStream->clearPool();
12562 if (m_queueSubmitWithCommandsEnabled)
12563 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12564 break;
12565 }
12566 case OP_vkCmdSetDepthTestEnable: {
12567 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12568 "VkDecoder vkCmdSetDepthTestEnable");
12569 VkCommandBuffer commandBuffer;
12570 VkBool32 depthTestEnable;
12571 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12572 uint64_t cgen_var_0;
12573 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12574 *readStreamPtrPtr += 1 * 8;
12575 *(VkCommandBuffer*)&commandBuffer =
12576 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12577 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12578 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12579 // End manual dispatchable handle unboxing for commandBuffer;
12580 memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
12581 *readStreamPtrPtr += sizeof(VkBool32);
12582 if (m_logCalls) {
12583 fprintf(stderr, "stream %p: call vkCmdSetDepthTestEnable 0x%llx 0x%llx \n",
12584 ioStream, (unsigned long long)commandBuffer,
12585 (unsigned long long)depthTestEnable);
12586 }
12587 vk->vkCmdSetDepthTestEnable(unboxed_commandBuffer, depthTestEnable);
12588 vkStream->unsetHandleMapping();
12589 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12590 (uintptr_t)snapshotTraceBegin);
12591 size_t snapshotTraceBytes = vkReadStream->endTrace();
12592 if (m_state->snapshotsEnabled()) {
12593 m_state->snapshot()->vkCmdSetDepthTestEnable(snapshotTraceBegin,
12594 snapshotTraceBytes, &m_pool,
12595 commandBuffer, depthTestEnable);
12596 }
12597 vkReadStream->clearPool();
12598 if (m_queueSubmitWithCommandsEnabled)
12599 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12600 break;
12601 }
12602 case OP_vkCmdSetDepthWriteEnable: {
12603 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12604 "VkDecoder vkCmdSetDepthWriteEnable");
12605 VkCommandBuffer commandBuffer;
12606 VkBool32 depthWriteEnable;
12607 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12608 uint64_t cgen_var_0;
12609 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12610 *readStreamPtrPtr += 1 * 8;
12611 *(VkCommandBuffer*)&commandBuffer =
12612 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12613 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12614 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12615 // End manual dispatchable handle unboxing for commandBuffer;
12616 memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
12617 *readStreamPtrPtr += sizeof(VkBool32);
12618 if (m_logCalls) {
12619 fprintf(stderr, "stream %p: call vkCmdSetDepthWriteEnable 0x%llx 0x%llx \n",
12620 ioStream, (unsigned long long)commandBuffer,
12621 (unsigned long long)depthWriteEnable);
12622 }
12623 vk->vkCmdSetDepthWriteEnable(unboxed_commandBuffer, depthWriteEnable);
12624 vkStream->unsetHandleMapping();
12625 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12626 (uintptr_t)snapshotTraceBegin);
12627 size_t snapshotTraceBytes = vkReadStream->endTrace();
12628 if (m_state->snapshotsEnabled()) {
12629 m_state->snapshot()->vkCmdSetDepthWriteEnable(snapshotTraceBegin,
12630 snapshotTraceBytes, &m_pool,
12631 commandBuffer, depthWriteEnable);
12632 }
12633 vkReadStream->clearPool();
12634 if (m_queueSubmitWithCommandsEnabled)
12635 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12636 break;
12637 }
12638 case OP_vkCmdSetDepthCompareOp: {
12639 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12640 "VkDecoder vkCmdSetDepthCompareOp");
12641 VkCommandBuffer commandBuffer;
12642 VkCompareOp depthCompareOp;
12643 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12644 uint64_t cgen_var_0;
12645 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12646 *readStreamPtrPtr += 1 * 8;
12647 *(VkCommandBuffer*)&commandBuffer =
12648 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12649 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12650 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12651 // End manual dispatchable handle unboxing for commandBuffer;
12652 memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
12653 *readStreamPtrPtr += sizeof(VkCompareOp);
12654 if (m_logCalls) {
12655 fprintf(stderr, "stream %p: call vkCmdSetDepthCompareOp 0x%llx 0x%llx \n",
12656 ioStream, (unsigned long long)commandBuffer,
12657 (unsigned long long)depthCompareOp);
12658 }
12659 vk->vkCmdSetDepthCompareOp(unboxed_commandBuffer, depthCompareOp);
12660 vkStream->unsetHandleMapping();
12661 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12662 (uintptr_t)snapshotTraceBegin);
12663 size_t snapshotTraceBytes = vkReadStream->endTrace();
12664 if (m_state->snapshotsEnabled()) {
12665 m_state->snapshot()->vkCmdSetDepthCompareOp(snapshotTraceBegin,
12666 snapshotTraceBytes, &m_pool,
12667 commandBuffer, depthCompareOp);
12668 }
12669 vkReadStream->clearPool();
12670 if (m_queueSubmitWithCommandsEnabled)
12671 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12672 break;
12673 }
12674 case OP_vkCmdSetDepthBoundsTestEnable: {
12675 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12676 "VkDecoder vkCmdSetDepthBoundsTestEnable");
12677 VkCommandBuffer commandBuffer;
12678 VkBool32 depthBoundsTestEnable;
12679 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12680 uint64_t cgen_var_0;
12681 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12682 *readStreamPtrPtr += 1 * 8;
12683 *(VkCommandBuffer*)&commandBuffer =
12684 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12685 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12686 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12687 // End manual dispatchable handle unboxing for commandBuffer;
12688 memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
12689 *readStreamPtrPtr += sizeof(VkBool32);
12690 if (m_logCalls) {
12691 fprintf(stderr,
12692 "stream %p: call vkCmdSetDepthBoundsTestEnable 0x%llx 0x%llx \n",
12693 ioStream, (unsigned long long)commandBuffer,
12694 (unsigned long long)depthBoundsTestEnable);
12695 }
12696 vk->vkCmdSetDepthBoundsTestEnable(unboxed_commandBuffer, depthBoundsTestEnable);
12697 vkStream->unsetHandleMapping();
12698 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12699 (uintptr_t)snapshotTraceBegin);
12700 size_t snapshotTraceBytes = vkReadStream->endTrace();
12701 if (m_state->snapshotsEnabled()) {
12702 m_state->snapshot()->vkCmdSetDepthBoundsTestEnable(
12703 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12704 depthBoundsTestEnable);
12705 }
12706 vkReadStream->clearPool();
12707 if (m_queueSubmitWithCommandsEnabled)
12708 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12709 break;
12710 }
12711 case OP_vkCmdSetStencilTestEnable: {
12712 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12713 "VkDecoder vkCmdSetStencilTestEnable");
12714 VkCommandBuffer commandBuffer;
12715 VkBool32 stencilTestEnable;
12716 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12717 uint64_t cgen_var_0;
12718 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12719 *readStreamPtrPtr += 1 * 8;
12720 *(VkCommandBuffer*)&commandBuffer =
12721 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12722 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12723 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12724 // End manual dispatchable handle unboxing for commandBuffer;
12725 memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
12726 *readStreamPtrPtr += sizeof(VkBool32);
12727 if (m_logCalls) {
12728 fprintf(stderr, "stream %p: call vkCmdSetStencilTestEnable 0x%llx 0x%llx \n",
12729 ioStream, (unsigned long long)commandBuffer,
12730 (unsigned long long)stencilTestEnable);
12731 }
12732 vk->vkCmdSetStencilTestEnable(unboxed_commandBuffer, stencilTestEnable);
12733 vkStream->unsetHandleMapping();
12734 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12735 (uintptr_t)snapshotTraceBegin);
12736 size_t snapshotTraceBytes = vkReadStream->endTrace();
12737 if (m_state->snapshotsEnabled()) {
12738 m_state->snapshot()->vkCmdSetStencilTestEnable(
12739 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12740 stencilTestEnable);
12741 }
12742 vkReadStream->clearPool();
12743 if (m_queueSubmitWithCommandsEnabled)
12744 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12745 break;
12746 }
12747 case OP_vkCmdSetStencilOp: {
12748 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12749 "VkDecoder vkCmdSetStencilOp");
12750 VkCommandBuffer commandBuffer;
12751 VkStencilFaceFlags faceMask;
12752 VkStencilOp failOp;
12753 VkStencilOp passOp;
12754 VkStencilOp depthFailOp;
12755 VkCompareOp compareOp;
12756 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12757 uint64_t cgen_var_0;
12758 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12759 *readStreamPtrPtr += 1 * 8;
12760 *(VkCommandBuffer*)&commandBuffer =
12761 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12762 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12763 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12764 // End manual dispatchable handle unboxing for commandBuffer;
12765 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
12766 sizeof(VkStencilFaceFlags));
12767 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
12768 memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
12769 *readStreamPtrPtr += sizeof(VkStencilOp);
12770 memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
12771 *readStreamPtrPtr += sizeof(VkStencilOp);
12772 memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
12773 *readStreamPtrPtr += sizeof(VkStencilOp);
12774 memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
12775 *readStreamPtrPtr += sizeof(VkCompareOp);
12776 if (m_logCalls) {
12777 fprintf(stderr,
12778 "stream %p: call vkCmdSetStencilOp 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
12779 "0x%llx \n",
12780 ioStream, (unsigned long long)commandBuffer,
12781 (unsigned long long)faceMask, (unsigned long long)failOp,
12782 (unsigned long long)passOp, (unsigned long long)depthFailOp,
12783 (unsigned long long)compareOp);
12784 }
12785 vk->vkCmdSetStencilOp(unboxed_commandBuffer, faceMask, failOp, passOp, depthFailOp,
12786 compareOp);
12787 vkStream->unsetHandleMapping();
12788 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12789 (uintptr_t)snapshotTraceBegin);
12790 size_t snapshotTraceBytes = vkReadStream->endTrace();
12791 if (m_state->snapshotsEnabled()) {
12792 m_state->snapshot()->vkCmdSetStencilOp(snapshotTraceBegin, snapshotTraceBytes,
12793 &m_pool, commandBuffer, faceMask, failOp,
12794 passOp, depthFailOp, compareOp);
12795 }
12796 vkReadStream->clearPool();
12797 if (m_queueSubmitWithCommandsEnabled)
12798 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12799 break;
12800 }
12801 case OP_vkCmdSetRasterizerDiscardEnable: {
12802 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12803 "VkDecoder vkCmdSetRasterizerDiscardEnable");
12804 VkCommandBuffer commandBuffer;
12805 VkBool32 rasterizerDiscardEnable;
12806 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12807 uint64_t cgen_var_0;
12808 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12809 *readStreamPtrPtr += 1 * 8;
12810 *(VkCommandBuffer*)&commandBuffer =
12811 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12812 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12813 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12814 // End manual dispatchable handle unboxing for commandBuffer;
12815 memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
12816 *readStreamPtrPtr += sizeof(VkBool32);
12817 if (m_logCalls) {
12818 fprintf(stderr,
12819 "stream %p: call vkCmdSetRasterizerDiscardEnable 0x%llx 0x%llx \n",
12820 ioStream, (unsigned long long)commandBuffer,
12821 (unsigned long long)rasterizerDiscardEnable);
12822 }
12823 vk->vkCmdSetRasterizerDiscardEnable(unboxed_commandBuffer, rasterizerDiscardEnable);
12824 vkStream->unsetHandleMapping();
12825 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12826 (uintptr_t)snapshotTraceBegin);
12827 size_t snapshotTraceBytes = vkReadStream->endTrace();
12828 if (m_state->snapshotsEnabled()) {
12829 m_state->snapshot()->vkCmdSetRasterizerDiscardEnable(
12830 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12831 rasterizerDiscardEnable);
12832 }
12833 vkReadStream->clearPool();
12834 if (m_queueSubmitWithCommandsEnabled)
12835 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12836 break;
12837 }
12838 case OP_vkCmdSetDepthBiasEnable: {
12839 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12840 "VkDecoder vkCmdSetDepthBiasEnable");
12841 VkCommandBuffer commandBuffer;
12842 VkBool32 depthBiasEnable;
12843 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12844 uint64_t cgen_var_0;
12845 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12846 *readStreamPtrPtr += 1 * 8;
12847 *(VkCommandBuffer*)&commandBuffer =
12848 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12849 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12850 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12851 // End manual dispatchable handle unboxing for commandBuffer;
12852 memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
12853 *readStreamPtrPtr += sizeof(VkBool32);
12854 if (m_logCalls) {
12855 fprintf(stderr, "stream %p: call vkCmdSetDepthBiasEnable 0x%llx 0x%llx \n",
12856 ioStream, (unsigned long long)commandBuffer,
12857 (unsigned long long)depthBiasEnable);
12858 }
12859 vk->vkCmdSetDepthBiasEnable(unboxed_commandBuffer, depthBiasEnable);
12860 vkStream->unsetHandleMapping();
12861 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12862 (uintptr_t)snapshotTraceBegin);
12863 size_t snapshotTraceBytes = vkReadStream->endTrace();
12864 if (m_state->snapshotsEnabled()) {
12865 m_state->snapshot()->vkCmdSetDepthBiasEnable(snapshotTraceBegin,
12866 snapshotTraceBytes, &m_pool,
12867 commandBuffer, depthBiasEnable);
12868 }
12869 vkReadStream->clearPool();
12870 if (m_queueSubmitWithCommandsEnabled)
12871 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12872 break;
12873 }
12874 case OP_vkCmdSetPrimitiveRestartEnable: {
12875 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12876 "VkDecoder vkCmdSetPrimitiveRestartEnable");
12877 VkCommandBuffer commandBuffer;
12878 VkBool32 primitiveRestartEnable;
12879 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
12880 uint64_t cgen_var_0;
12881 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12882 *readStreamPtrPtr += 1 * 8;
12883 *(VkCommandBuffer*)&commandBuffer =
12884 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
12885 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
12886 auto vk = dispatch_VkCommandBuffer(commandBuffer);
12887 // End manual dispatchable handle unboxing for commandBuffer;
12888 memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
12889 *readStreamPtrPtr += sizeof(VkBool32);
12890 if (m_logCalls) {
12891 fprintf(stderr,
12892 "stream %p: call vkCmdSetPrimitiveRestartEnable 0x%llx 0x%llx \n",
12893 ioStream, (unsigned long long)commandBuffer,
12894 (unsigned long long)primitiveRestartEnable);
12895 }
12896 vk->vkCmdSetPrimitiveRestartEnable(unboxed_commandBuffer, primitiveRestartEnable);
12897 vkStream->unsetHandleMapping();
12898 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12899 (uintptr_t)snapshotTraceBegin);
12900 size_t snapshotTraceBytes = vkReadStream->endTrace();
12901 if (m_state->snapshotsEnabled()) {
12902 m_state->snapshot()->vkCmdSetPrimitiveRestartEnable(
12903 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
12904 primitiveRestartEnable);
12905 }
12906 vkReadStream->clearPool();
12907 if (m_queueSubmitWithCommandsEnabled)
12908 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12909 break;
12910 }
12911 case OP_vkGetDeviceBufferMemoryRequirements: {
12912 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12913 "VkDecoder vkGetDeviceBufferMemoryRequirements");
12914 VkDevice device;
12915 const VkDeviceBufferMemoryRequirements* pInfo;
12916 VkMemoryRequirements2* pMemoryRequirements;
12917 // Begin non wrapped dispatchable handle unboxing for device;
12918 uint64_t cgen_var_0;
12919 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12920 *readStreamPtrPtr += 1 * 8;
12921 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
12922 auto unboxed_device = unbox_VkDevice(device);
12923 auto vk = dispatch_VkDevice(device);
12924 // End manual dispatchable handle unboxing for device;
12925 vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceBufferMemoryRequirements));
12926 reservedunmarshal_VkDeviceBufferMemoryRequirements(
12927 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12928 (VkDeviceBufferMemoryRequirements*)(pInfo), readStreamPtrPtr);
12929 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
12930 vkReadStream->unsetHandleMapping();
12931 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
12932 reservedunmarshal_VkMemoryRequirements2(
12933 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12934 (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
12935 if (pInfo) {
12936 transform_tohost_VkDeviceBufferMemoryRequirements(
12937 m_state, (VkDeviceBufferMemoryRequirements*)(pInfo));
12938 }
12939 if (pMemoryRequirements) {
12940 transform_tohost_VkMemoryRequirements2(
12941 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
12942 }
12943 if (m_logCalls) {
12944 fprintf(stderr,
12945 "stream %p: call vkGetDeviceBufferMemoryRequirements 0x%llx 0x%llx "
12946 "0x%llx \n",
12947 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
12948 (unsigned long long)pMemoryRequirements);
12949 }
12950 vk->vkGetDeviceBufferMemoryRequirements(unboxed_device, pInfo, pMemoryRequirements);
12951 vkStream->unsetHandleMapping();
12952 if (pMemoryRequirements) {
12953 transform_fromhost_VkMemoryRequirements2(
12954 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
12955 }
12956 marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12957 (VkMemoryRequirements2*)(pMemoryRequirements));
12958 vkStream->commitWrite();
12959 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
12960 (uintptr_t)snapshotTraceBegin);
12961 size_t snapshotTraceBytes = vkReadStream->endTrace();
12962 if (m_state->snapshotsEnabled()) {
12963 m_state->snapshot()->vkGetDeviceBufferMemoryRequirements(
12964 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
12965 pMemoryRequirements);
12966 }
12967 vkReadStream->clearPool();
12968 if (m_queueSubmitWithCommandsEnabled)
12969 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
12970 break;
12971 }
12972 case OP_vkGetDeviceImageMemoryRequirements: {
12973 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
12974 "VkDecoder vkGetDeviceImageMemoryRequirements");
12975 VkDevice device;
12976 const VkDeviceImageMemoryRequirements* pInfo;
12977 VkMemoryRequirements2* pMemoryRequirements;
12978 // Begin non wrapped dispatchable handle unboxing for device;
12979 uint64_t cgen_var_0;
12980 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
12981 *readStreamPtrPtr += 1 * 8;
12982 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
12983 auto unboxed_device = unbox_VkDevice(device);
12984 auto vk = dispatch_VkDevice(device);
12985 // End manual dispatchable handle unboxing for device;
12986 vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageMemoryRequirements));
12987 reservedunmarshal_VkDeviceImageMemoryRequirements(
12988 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12989 (VkDeviceImageMemoryRequirements*)(pInfo), readStreamPtrPtr);
12990 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
12991 vkReadStream->unsetHandleMapping();
12992 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
12993 reservedunmarshal_VkMemoryRequirements2(
12994 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
12995 (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
12996 if (pInfo) {
12997 transform_tohost_VkDeviceImageMemoryRequirements(
12998 m_state, (VkDeviceImageMemoryRequirements*)(pInfo));
12999 }
13000 if (pMemoryRequirements) {
13001 transform_tohost_VkMemoryRequirements2(
13002 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
13003 }
13004 if (m_logCalls) {
13005 fprintf(stderr,
13006 "stream %p: call vkGetDeviceImageMemoryRequirements 0x%llx 0x%llx "
13007 "0x%llx \n",
13008 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
13009 (unsigned long long)pMemoryRequirements);
13010 }
13011 vk->vkGetDeviceImageMemoryRequirements(unboxed_device, pInfo, pMemoryRequirements);
13012 vkStream->unsetHandleMapping();
13013 if (pMemoryRequirements) {
13014 transform_fromhost_VkMemoryRequirements2(
13015 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
13016 }
13017 marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13018 (VkMemoryRequirements2*)(pMemoryRequirements));
13019 vkStream->commitWrite();
13020 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13021 (uintptr_t)snapshotTraceBegin);
13022 size_t snapshotTraceBytes = vkReadStream->endTrace();
13023 if (m_state->snapshotsEnabled()) {
13024 m_state->snapshot()->vkGetDeviceImageMemoryRequirements(
13025 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
13026 pMemoryRequirements);
13027 }
13028 vkReadStream->clearPool();
13029 if (m_queueSubmitWithCommandsEnabled)
13030 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13031 break;
13032 }
13033 case OP_vkGetDeviceImageSparseMemoryRequirements: {
13034 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13035 "VkDecoder vkGetDeviceImageSparseMemoryRequirements");
13036 VkDevice device;
13037 const VkDeviceImageMemoryRequirements* pInfo;
13038 uint32_t* pSparseMemoryRequirementCount;
13039 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements;
13040 // Begin non wrapped dispatchable handle unboxing for device;
13041 uint64_t cgen_var_0;
13042 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13043 *readStreamPtrPtr += 1 * 8;
13044 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
13045 auto unboxed_device = unbox_VkDevice(device);
13046 auto vk = dispatch_VkDevice(device);
13047 // End manual dispatchable handle unboxing for device;
13048 vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageMemoryRequirements));
13049 reservedunmarshal_VkDeviceImageMemoryRequirements(
13050 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13051 (VkDeviceImageMemoryRequirements*)(pInfo), readStreamPtrPtr);
13052 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirementCount;
13053 vkReadStream->unsetHandleMapping();
13054 // WARNING PTR CHECK
13055 memcpy((uint32_t**)&pSparseMemoryRequirementCount, (*readStreamPtrPtr), 8);
13056 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirementCount);
13057 *readStreamPtrPtr += 8;
13058 if (pSparseMemoryRequirementCount) {
13059 vkReadStream->alloc((void**)&pSparseMemoryRequirementCount, sizeof(uint32_t));
13060 memcpy((uint32_t*)pSparseMemoryRequirementCount, *readStreamPtrPtr,
13061 sizeof(uint32_t));
13062 *readStreamPtrPtr += sizeof(uint32_t);
13063 }
13064 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirements;
13065 vkReadStream->unsetHandleMapping();
13066 // WARNING PTR CHECK
13067 memcpy((VkSparseImageMemoryRequirements2**)&pSparseMemoryRequirements,
13068 (*readStreamPtrPtr), 8);
13069 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirements);
13070 *readStreamPtrPtr += 8;
13071 if (pSparseMemoryRequirements) {
13072 vkReadStream->alloc((void**)&pSparseMemoryRequirements,
13073 (*(pSparseMemoryRequirementCount)) *
13074 sizeof(VkSparseImageMemoryRequirements2));
13075 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
13076 reservedunmarshal_VkSparseImageMemoryRequirements2(
13077 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13078 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i),
13079 readStreamPtrPtr);
13080 }
13081 }
13082 if (pInfo) {
13083 transform_tohost_VkDeviceImageMemoryRequirements(
13084 m_state, (VkDeviceImageMemoryRequirements*)(pInfo));
13085 }
13086 if (pSparseMemoryRequirementCount) {
13087 if (pSparseMemoryRequirements) {
13088 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
13089 ++i) {
13090 transform_tohost_VkSparseImageMemoryRequirements2(
13091 m_state,
13092 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
13093 }
13094 }
13095 }
13096 if (m_logCalls) {
13097 fprintf(stderr,
13098 "stream %p: call vkGetDeviceImageSparseMemoryRequirements 0x%llx "
13099 "0x%llx 0x%llx 0x%llx \n",
13100 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
13101 (unsigned long long)pSparseMemoryRequirementCount,
13102 (unsigned long long)pSparseMemoryRequirements);
13103 }
13104 vk->vkGetDeviceImageSparseMemoryRequirements(unboxed_device, pInfo,
13105 pSparseMemoryRequirementCount,
13106 pSparseMemoryRequirements);
13107 vkStream->unsetHandleMapping();
13108 // WARNING PTR CHECK
13109 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
13110 vkStream->putBe64(cgen_var_3);
13111 if (pSparseMemoryRequirementCount) {
13112 vkStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
13113 }
13114 if (pSparseMemoryRequirementCount) {
13115 if (pSparseMemoryRequirements) {
13116 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
13117 ++i) {
13118 transform_fromhost_VkSparseImageMemoryRequirements2(
13119 m_state,
13120 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
13121 }
13122 }
13123 }
13124 // WARNING PTR CHECK
13125 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
13126 vkStream->putBe64(cgen_var_4);
13127 if (pSparseMemoryRequirements) {
13128 if (pSparseMemoryRequirementCount) {
13129 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
13130 ++i) {
13131 marshal_VkSparseImageMemoryRequirements2(
13132 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13133 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
13134 }
13135 }
13136 }
13137 vkStream->commitWrite();
13138 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13139 (uintptr_t)snapshotTraceBegin);
13140 size_t snapshotTraceBytes = vkReadStream->endTrace();
13141 if (m_state->snapshotsEnabled()) {
13142 m_state->snapshot()->vkGetDeviceImageSparseMemoryRequirements(
13143 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
13144 pSparseMemoryRequirementCount, pSparseMemoryRequirements);
13145 }
13146 vkReadStream->clearPool();
13147 if (m_queueSubmitWithCommandsEnabled)
13148 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13149 break;
13150 }
13151 #endif
13152 #ifdef VK_KHR_swapchain
13153 case OP_vkCreateSwapchainKHR: {
13154 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13155 "VkDecoder vkCreateSwapchainKHR");
13156 VkDevice device;
13157 const VkSwapchainCreateInfoKHR* pCreateInfo;
13158 const VkAllocationCallbacks* pAllocator;
13159 VkSwapchainKHR* pSwapchain;
13160 // Begin non wrapped dispatchable handle unboxing for device;
13161 uint64_t cgen_var_0;
13162 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13163 *readStreamPtrPtr += 1 * 8;
13164 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
13165 auto unboxed_device = unbox_VkDevice(device);
13166 auto vk = dispatch_VkDevice(device);
13167 // End manual dispatchable handle unboxing for device;
13168 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkSwapchainCreateInfoKHR));
13169 reservedunmarshal_VkSwapchainCreateInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13170 (VkSwapchainCreateInfoKHR*)(pCreateInfo),
13171 readStreamPtrPtr);
13172 // WARNING PTR CHECK
13173 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
13174 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
13175 *readStreamPtrPtr += 8;
13176 if (pAllocator) {
13177 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
13178 reservedunmarshal_VkAllocationCallbacks(
13179 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13180 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
13181 }
13182 // Begin manual dispatchable handle unboxing for pSwapchain;
13183 vkReadStream->unsetHandleMapping();
13184 vkReadStream->alloc((void**)&pSwapchain, sizeof(VkSwapchainKHR));
13185 uint64_t cgen_var_2;
13186 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
13187 *readStreamPtrPtr += 8;
13188 *(VkSwapchainKHR*)pSwapchain =
13189 (VkSwapchainKHR)(VkSwapchainKHR)((VkSwapchainKHR)(*&cgen_var_2));
13190 if (pCreateInfo) {
13191 transform_tohost_VkSwapchainCreateInfoKHR(
13192 m_state, (VkSwapchainCreateInfoKHR*)(pCreateInfo));
13193 }
13194 if (pAllocator) {
13195 transform_tohost_VkAllocationCallbacks(m_state,
13196 (VkAllocationCallbacks*)(pAllocator));
13197 }
13198 if (m_logCalls) {
13199 fprintf(stderr,
13200 "stream %p: call vkCreateSwapchainKHR 0x%llx 0x%llx 0x%llx 0x%llx \n",
13201 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
13202 (unsigned long long)pAllocator, (unsigned long long)pSwapchain);
13203 }
13204 VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
13205 vkCreateSwapchainKHR_VkResult_return =
13206 vk->vkCreateSwapchainKHR(unboxed_device, pCreateInfo, pAllocator, pSwapchain);
13207 if ((vkCreateSwapchainKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
13208 m_state->on_DeviceLost();
13209 m_state->on_CheckOutOfMemory(vkCreateSwapchainKHR_VkResult_return, opcode, context);
13210 vkStream->unsetHandleMapping();
13211 // Begin auto non dispatchable handle create for pSwapchain;
13212 if (vkCreateSwapchainKHR_VkResult_return == VK_SUCCESS)
13213 vkStream->setHandleMapping(&m_boxedHandleCreateMapping);
13214 uint64_t cgen_var_3;
13215 static_assert(8 == sizeof(VkSwapchainKHR),
13216 "handle map overwrite requires VkSwapchainKHR to be 8 bytes long");
13217 vkStream->handleMapping()->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)pSwapchain,
13218 1);
13219 vkStream->write((VkSwapchainKHR*)pSwapchain, 8 * 1);
13220 // Begin auto non dispatchable handle create for pSwapchain;
13221 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
13222 vkStream->write(&vkCreateSwapchainKHR_VkResult_return, sizeof(VkResult));
13223 vkStream->commitWrite();
13224 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13225 (uintptr_t)snapshotTraceBegin);
13226 size_t snapshotTraceBytes = vkReadStream->endTrace();
13227 if (m_state->snapshotsEnabled()) {
13228 m_state->snapshot()->vkCreateSwapchainKHR(
13229 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
13230 vkCreateSwapchainKHR_VkResult_return, device, pCreateInfo, pAllocator,
13231 pSwapchain);
13232 }
13233 vkReadStream->clearPool();
13234 if (m_queueSubmitWithCommandsEnabled)
13235 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13236 break;
13237 }
13238 case OP_vkDestroySwapchainKHR: {
13239 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13240 "VkDecoder vkDestroySwapchainKHR");
13241 VkDevice device;
13242 VkSwapchainKHR swapchain;
13243 const VkAllocationCallbacks* pAllocator;
13244 // Begin non wrapped dispatchable handle unboxing for device;
13245 uint64_t cgen_var_0;
13246 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13247 *readStreamPtrPtr += 1 * 8;
13248 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
13249 auto unboxed_device = unbox_VkDevice(device);
13250 auto vk = dispatch_VkDevice(device);
13251 // End manual dispatchable handle unboxing for device;
13252 // Begin manual non dispatchable handle destroy unboxing for swapchain;
13253 VkSwapchainKHR boxed_swapchain_preserve;
13254 uint64_t cgen_var_1;
13255 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
13256 *readStreamPtrPtr += 1 * 8;
13257 *(VkSwapchainKHR*)&swapchain =
13258 (VkSwapchainKHR)(VkSwapchainKHR)((VkSwapchainKHR)(*&cgen_var_1));
13259 boxed_swapchain_preserve = swapchain;
13260 swapchain = try_unbox_VkSwapchainKHR(swapchain);
13261 // WARNING PTR CHECK
13262 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
13263 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
13264 *readStreamPtrPtr += 8;
13265 if (pAllocator) {
13266 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
13267 reservedunmarshal_VkAllocationCallbacks(
13268 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13269 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
13270 }
13271 if (pAllocator) {
13272 transform_tohost_VkAllocationCallbacks(m_state,
13273 (VkAllocationCallbacks*)(pAllocator));
13274 }
13275 if (m_logCalls) {
13276 fprintf(stderr, "stream %p: call vkDestroySwapchainKHR 0x%llx 0x%llx 0x%llx \n",
13277 ioStream, (unsigned long long)device, (unsigned long long)swapchain,
13278 (unsigned long long)pAllocator);
13279 }
13280 vk->vkDestroySwapchainKHR(unboxed_device, swapchain, pAllocator);
13281 vkStream->unsetHandleMapping();
13282 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13283 (uintptr_t)snapshotTraceBegin);
13284 size_t snapshotTraceBytes = vkReadStream->endTrace();
13285 if (m_state->snapshotsEnabled()) {
13286 m_state->snapshot()->vkDestroySwapchainKHR(
13287 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
13288 boxed_swapchain_preserve, pAllocator);
13289 }
13290 delete_VkSwapchainKHR(boxed_swapchain_preserve);
13291 vkReadStream->clearPool();
13292 if (m_queueSubmitWithCommandsEnabled)
13293 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13294 break;
13295 }
13296 case OP_vkGetSwapchainImagesKHR: {
13297 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13298 "VkDecoder vkGetSwapchainImagesKHR");
13299 VkDevice device;
13300 VkSwapchainKHR swapchain;
13301 uint32_t* pSwapchainImageCount;
13302 VkImage* pSwapchainImages;
13303 // Begin non wrapped dispatchable handle unboxing for device;
13304 uint64_t cgen_var_0;
13305 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13306 *readStreamPtrPtr += 1 * 8;
13307 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
13308 auto unboxed_device = unbox_VkDevice(device);
13309 auto vk = dispatch_VkDevice(device);
13310 // End manual dispatchable handle unboxing for device;
13311 uint64_t cgen_var_1;
13312 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
13313 *readStreamPtrPtr += 1 * 8;
13314 *(VkSwapchainKHR*)&swapchain =
13315 (VkSwapchainKHR)unbox_VkSwapchainKHR((VkSwapchainKHR)(*&cgen_var_1));
13316 // Begin manual dispatchable handle unboxing for pSwapchainImageCount;
13317 vkReadStream->unsetHandleMapping();
13318 // WARNING PTR CHECK
13319 memcpy((uint32_t**)&pSwapchainImageCount, (*readStreamPtrPtr), 8);
13320 android::base::Stream::fromBe64((uint8_t*)&pSwapchainImageCount);
13321 *readStreamPtrPtr += 8;
13322 if (pSwapchainImageCount) {
13323 vkReadStream->alloc((void**)&pSwapchainImageCount, sizeof(uint32_t));
13324 memcpy((uint32_t*)pSwapchainImageCount, *readStreamPtrPtr, sizeof(uint32_t));
13325 *readStreamPtrPtr += sizeof(uint32_t);
13326 }
13327 // Begin manual dispatchable handle unboxing for pSwapchainImages;
13328 vkReadStream->unsetHandleMapping();
13329 // WARNING PTR CHECK
13330 memcpy((VkImage**)&pSwapchainImages, (*readStreamPtrPtr), 8);
13331 android::base::Stream::fromBe64((uint8_t*)&pSwapchainImages);
13332 *readStreamPtrPtr += 8;
13333 if (pSwapchainImages) {
13334 vkReadStream->alloc((void**)&pSwapchainImages,
13335 (*(pSwapchainImageCount)) * sizeof(VkImage));
13336 if ((*(pSwapchainImageCount))) {
13337 uint8_t* cgen_var_3_0_ptr = (uint8_t*)(*readStreamPtrPtr);
13338 *readStreamPtrPtr += 8 * (*(pSwapchainImageCount));
13339 if (pSwapchainImageCount) {
13340 for (uint32_t k = 0; k < (*(pSwapchainImageCount)); ++k) {
13341 uint64_t tmpval;
13342 memcpy(&tmpval, cgen_var_3_0_ptr + k * 8, sizeof(uint64_t));
13343 *(((VkImage*)pSwapchainImages) + k) =
13344 tmpval ? (VkImage)(VkImage)((VkImage)tmpval) : VK_NULL_HANDLE;
13345 }
13346 }
13347 }
13348 }
13349 if (m_logCalls) {
13350 fprintf(
13351 stderr,
13352 "stream %p: call vkGetSwapchainImagesKHR 0x%llx 0x%llx 0x%llx 0x%llx \n",
13353 ioStream, (unsigned long long)device, (unsigned long long)swapchain,
13354 (unsigned long long)pSwapchainImageCount,
13355 (unsigned long long)pSwapchainImages);
13356 }
13357 VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
13358 vkGetSwapchainImagesKHR_VkResult_return = vk->vkGetSwapchainImagesKHR(
13359 unboxed_device, swapchain, pSwapchainImageCount, pSwapchainImages);
13360 if ((vkGetSwapchainImagesKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
13361 m_state->on_DeviceLost();
13362 m_state->on_CheckOutOfMemory(vkGetSwapchainImagesKHR_VkResult_return, opcode,
13363 context);
13364 vkStream->unsetHandleMapping();
13365 // WARNING PTR CHECK
13366 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pSwapchainImageCount;
13367 vkStream->putBe64(cgen_var_4);
13368 if (pSwapchainImageCount) {
13369 vkStream->write((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
13370 }
13371 // WARNING PTR CHECK
13372 uint64_t cgen_var_5 = (uint64_t)(uintptr_t)pSwapchainImages;
13373 vkStream->putBe64(cgen_var_5);
13374 if (pSwapchainImages) {
13375 if ((*(pSwapchainImageCount))) {
13376 uint64_t* cgen_var_5_0;
13377 vkStream->alloc((void**)&cgen_var_5_0, (*(pSwapchainImageCount)) * 8);
13378 vkStream->handleMapping()->mapHandles_VkImage_u64(
13379 pSwapchainImages, cgen_var_5_0, (*(pSwapchainImageCount)));
13380 vkStream->write((uint64_t*)cgen_var_5_0, (*(pSwapchainImageCount)) * 8);
13381 }
13382 }
13383 vkStream->write(&vkGetSwapchainImagesKHR_VkResult_return, sizeof(VkResult));
13384 vkStream->commitWrite();
13385 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13386 (uintptr_t)snapshotTraceBegin);
13387 size_t snapshotTraceBytes = vkReadStream->endTrace();
13388 if (m_state->snapshotsEnabled()) {
13389 m_state->snapshot()->vkGetSwapchainImagesKHR(
13390 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
13391 vkGetSwapchainImagesKHR_VkResult_return, device, swapchain,
13392 pSwapchainImageCount, pSwapchainImages);
13393 }
13394 vkReadStream->clearPool();
13395 if (m_queueSubmitWithCommandsEnabled)
13396 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13397 break;
13398 }
13399 case OP_vkAcquireNextImageKHR: {
13400 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13401 "VkDecoder vkAcquireNextImageKHR");
13402 VkDevice device;
13403 VkSwapchainKHR swapchain;
13404 uint64_t timeout;
13405 VkSemaphore semaphore;
13406 VkFence fence;
13407 uint32_t* pImageIndex;
13408 // Begin non wrapped dispatchable handle unboxing for device;
13409 uint64_t cgen_var_0;
13410 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13411 *readStreamPtrPtr += 1 * 8;
13412 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
13413 auto unboxed_device = unbox_VkDevice(device);
13414 auto vk = dispatch_VkDevice(device);
13415 // End manual dispatchable handle unboxing for device;
13416 uint64_t cgen_var_1;
13417 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
13418 *readStreamPtrPtr += 1 * 8;
13419 *(VkSwapchainKHR*)&swapchain =
13420 (VkSwapchainKHR)unbox_VkSwapchainKHR((VkSwapchainKHR)(*&cgen_var_1));
13421 memcpy((uint64_t*)&timeout, *readStreamPtrPtr, sizeof(uint64_t));
13422 *readStreamPtrPtr += sizeof(uint64_t);
13423 uint64_t cgen_var_2;
13424 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
13425 *readStreamPtrPtr += 1 * 8;
13426 *(VkSemaphore*)&semaphore =
13427 (VkSemaphore)unbox_VkSemaphore((VkSemaphore)(*&cgen_var_2));
13428 uint64_t cgen_var_3;
13429 memcpy((uint64_t*)&cgen_var_3, *readStreamPtrPtr, 1 * 8);
13430 *readStreamPtrPtr += 1 * 8;
13431 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_3));
13432 // Begin manual dispatchable handle unboxing for pImageIndex;
13433 vkReadStream->unsetHandleMapping();
13434 vkReadStream->alloc((void**)&pImageIndex, sizeof(uint32_t));
13435 memcpy((uint32_t*)pImageIndex, *readStreamPtrPtr, sizeof(uint32_t));
13436 *readStreamPtrPtr += sizeof(uint32_t);
13437 if (m_logCalls) {
13438 fprintf(stderr,
13439 "stream %p: call vkAcquireNextImageKHR 0x%llx 0x%llx 0x%llx 0x%llx "
13440 "0x%llx 0x%llx \n",
13441 ioStream, (unsigned long long)device, (unsigned long long)swapchain,
13442 (unsigned long long)timeout, (unsigned long long)semaphore,
13443 (unsigned long long)fence, (unsigned long long)pImageIndex);
13444 }
13445 VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
13446 vkAcquireNextImageKHR_VkResult_return = vk->vkAcquireNextImageKHR(
13447 unboxed_device, swapchain, timeout, semaphore, fence, pImageIndex);
13448 if ((vkAcquireNextImageKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
13449 m_state->on_DeviceLost();
13450 m_state->on_CheckOutOfMemory(vkAcquireNextImageKHR_VkResult_return, opcode,
13451 context);
13452 vkStream->unsetHandleMapping();
13453 vkStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
13454 vkStream->write(&vkAcquireNextImageKHR_VkResult_return, sizeof(VkResult));
13455 vkStream->commitWrite();
13456 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13457 (uintptr_t)snapshotTraceBegin);
13458 size_t snapshotTraceBytes = vkReadStream->endTrace();
13459 if (m_state->snapshotsEnabled()) {
13460 m_state->snapshot()->vkAcquireNextImageKHR(
13461 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
13462 vkAcquireNextImageKHR_VkResult_return, device, swapchain, timeout,
13463 semaphore, fence, pImageIndex);
13464 }
13465 vkReadStream->clearPool();
13466 if (m_queueSubmitWithCommandsEnabled)
13467 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13468 break;
13469 }
13470 case OP_vkQueuePresentKHR: {
13471 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13472 "VkDecoder vkQueuePresentKHR");
13473 VkQueue queue;
13474 const VkPresentInfoKHR* pPresentInfo;
13475 // Begin global wrapped dispatchable handle unboxing for queue;
13476 uint64_t cgen_var_0;
13477 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13478 *readStreamPtrPtr += 1 * 8;
13479 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
13480 vkReadStream->alloc((void**)&pPresentInfo, sizeof(const VkPresentInfoKHR));
13481 reservedunmarshal_VkPresentInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13482 (VkPresentInfoKHR*)(pPresentInfo),
13483 readStreamPtrPtr);
13484 if (pPresentInfo) {
13485 transform_tohost_VkPresentInfoKHR(m_state, (VkPresentInfoKHR*)(pPresentInfo));
13486 }
13487 if (m_logCalls) {
13488 fprintf(stderr, "stream %p: call vkQueuePresentKHR 0x%llx 0x%llx \n", ioStream,
13489 (unsigned long long)queue, (unsigned long long)pPresentInfo);
13490 }
13491 VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
13492 vkQueuePresentKHR_VkResult_return =
13493 m_state->on_vkQueuePresentKHR(&m_pool, queue, pPresentInfo);
13494 if ((vkQueuePresentKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
13495 m_state->on_DeviceLost();
13496 m_state->on_CheckOutOfMemory(vkQueuePresentKHR_VkResult_return, opcode, context);
13497 vkStream->unsetHandleMapping();
13498 vkStream->write(&vkQueuePresentKHR_VkResult_return, sizeof(VkResult));
13499 vkStream->commitWrite();
13500 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13501 (uintptr_t)snapshotTraceBegin);
13502 size_t snapshotTraceBytes = vkReadStream->endTrace();
13503 if (m_state->snapshotsEnabled()) {
13504 m_state->snapshot()->vkQueuePresentKHR(
13505 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
13506 vkQueuePresentKHR_VkResult_return, queue, pPresentInfo);
13507 }
13508 vkReadStream->clearPool();
13509 if (m_queueSubmitWithCommandsEnabled)
13510 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13511 break;
13512 }
13513 case OP_vkGetDeviceGroupPresentCapabilitiesKHR: {
13514 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13515 "VkDecoder vkGetDeviceGroupPresentCapabilitiesKHR");
13516 VkDevice device;
13517 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities;
13518 // Begin non wrapped dispatchable handle unboxing for device;
13519 uint64_t cgen_var_0;
13520 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13521 *readStreamPtrPtr += 1 * 8;
13522 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
13523 auto unboxed_device = unbox_VkDevice(device);
13524 auto vk = dispatch_VkDevice(device);
13525 // End manual dispatchable handle unboxing for device;
13526 // Begin manual dispatchable handle unboxing for pDeviceGroupPresentCapabilities;
13527 vkReadStream->unsetHandleMapping();
13528 vkReadStream->alloc((void**)&pDeviceGroupPresentCapabilities,
13529 sizeof(VkDeviceGroupPresentCapabilitiesKHR));
13530 reservedunmarshal_VkDeviceGroupPresentCapabilitiesKHR(
13531 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13532 (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities),
13533 readStreamPtrPtr);
13534 if (pDeviceGroupPresentCapabilities) {
13535 transform_tohost_VkDeviceGroupPresentCapabilitiesKHR(
13536 m_state,
13537 (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
13538 }
13539 if (m_logCalls) {
13540 fprintf(
13541 stderr,
13542 "stream %p: call vkGetDeviceGroupPresentCapabilitiesKHR 0x%llx 0x%llx \n",
13543 ioStream, (unsigned long long)device,
13544 (unsigned long long)pDeviceGroupPresentCapabilities);
13545 }
13546 VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
13547 vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return =
13548 vk->vkGetDeviceGroupPresentCapabilitiesKHR(unboxed_device,
13549 pDeviceGroupPresentCapabilities);
13550 if ((vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return) ==
13551 VK_ERROR_DEVICE_LOST)
13552 m_state->on_DeviceLost();
13553 m_state->on_CheckOutOfMemory(vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return,
13554 opcode, context);
13555 vkStream->unsetHandleMapping();
13556 if (pDeviceGroupPresentCapabilities) {
13557 transform_fromhost_VkDeviceGroupPresentCapabilitiesKHR(
13558 m_state,
13559 (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
13560 }
13561 marshal_VkDeviceGroupPresentCapabilitiesKHR(
13562 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13563 (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
13564 vkStream->write(&vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return,
13565 sizeof(VkResult));
13566 vkStream->commitWrite();
13567 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13568 (uintptr_t)snapshotTraceBegin);
13569 size_t snapshotTraceBytes = vkReadStream->endTrace();
13570 if (m_state->snapshotsEnabled()) {
13571 m_state->snapshot()->vkGetDeviceGroupPresentCapabilitiesKHR(
13572 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
13573 vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return, device,
13574 pDeviceGroupPresentCapabilities);
13575 }
13576 vkReadStream->clearPool();
13577 if (m_queueSubmitWithCommandsEnabled)
13578 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13579 break;
13580 }
13581 case OP_vkGetDeviceGroupSurfacePresentModesKHR: {
13582 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13583 "VkDecoder vkGetDeviceGroupSurfacePresentModesKHR");
13584 VkDevice device;
13585 VkSurfaceKHR surface;
13586 VkDeviceGroupPresentModeFlagsKHR* pModes;
13587 // Begin non wrapped dispatchable handle unboxing for device;
13588 uint64_t cgen_var_0;
13589 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13590 *readStreamPtrPtr += 1 * 8;
13591 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
13592 auto unboxed_device = unbox_VkDevice(device);
13593 auto vk = dispatch_VkDevice(device);
13594 // End manual dispatchable handle unboxing for device;
13595 uint64_t cgen_var_1;
13596 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
13597 *readStreamPtrPtr += 1 * 8;
13598 *(VkSurfaceKHR*)&surface =
13599 (VkSurfaceKHR)unbox_VkSurfaceKHR((VkSurfaceKHR)(*&cgen_var_1));
13600 // Begin manual dispatchable handle unboxing for pModes;
13601 vkReadStream->unsetHandleMapping();
13602 // WARNING PTR CHECK
13603 memcpy((VkDeviceGroupPresentModeFlagsKHR**)&pModes, (*readStreamPtrPtr), 8);
13604 android::base::Stream::fromBe64((uint8_t*)&pModes);
13605 *readStreamPtrPtr += 8;
13606 if (pModes) {
13607 vkReadStream->alloc((void**)&pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
13608 memcpy((VkDeviceGroupPresentModeFlagsKHR*)pModes, *readStreamPtrPtr,
13609 sizeof(VkDeviceGroupPresentModeFlagsKHR));
13610 *readStreamPtrPtr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
13611 }
13612 if (m_logCalls) {
13613 fprintf(stderr,
13614 "stream %p: call vkGetDeviceGroupSurfacePresentModesKHR 0x%llx 0x%llx "
13615 "0x%llx \n",
13616 ioStream, (unsigned long long)device, (unsigned long long)surface,
13617 (unsigned long long)pModes);
13618 }
13619 VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
13620 vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return =
13621 vk->vkGetDeviceGroupSurfacePresentModesKHR(unboxed_device, surface, pModes);
13622 if ((vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return) ==
13623 VK_ERROR_DEVICE_LOST)
13624 m_state->on_DeviceLost();
13625 m_state->on_CheckOutOfMemory(vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return,
13626 opcode, context);
13627 vkStream->unsetHandleMapping();
13628 // WARNING PTR CHECK
13629 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pModes;
13630 vkStream->putBe64(cgen_var_3);
13631 if (pModes) {
13632 vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes,
13633 sizeof(VkDeviceGroupPresentModeFlagsKHR));
13634 }
13635 vkStream->write(&vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return,
13636 sizeof(VkResult));
13637 vkStream->commitWrite();
13638 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13639 (uintptr_t)snapshotTraceBegin);
13640 size_t snapshotTraceBytes = vkReadStream->endTrace();
13641 if (m_state->snapshotsEnabled()) {
13642 m_state->snapshot()->vkGetDeviceGroupSurfacePresentModesKHR(
13643 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
13644 vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return, device, surface,
13645 pModes);
13646 }
13647 vkReadStream->clearPool();
13648 if (m_queueSubmitWithCommandsEnabled)
13649 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13650 break;
13651 }
13652 case OP_vkGetPhysicalDevicePresentRectanglesKHR: {
13653 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13654 "VkDecoder vkGetPhysicalDevicePresentRectanglesKHR");
13655 VkPhysicalDevice physicalDevice;
13656 VkSurfaceKHR surface;
13657 uint32_t* pRectCount;
13658 VkRect2D* pRects;
13659 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
13660 uint64_t cgen_var_0;
13661 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13662 *readStreamPtrPtr += 1 * 8;
13663 *(VkPhysicalDevice*)&physicalDevice =
13664 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
13665 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
13666 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
13667 // End manual dispatchable handle unboxing for physicalDevice;
13668 uint64_t cgen_var_1;
13669 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
13670 *readStreamPtrPtr += 1 * 8;
13671 *(VkSurfaceKHR*)&surface =
13672 (VkSurfaceKHR)unbox_VkSurfaceKHR((VkSurfaceKHR)(*&cgen_var_1));
13673 // Begin manual dispatchable handle unboxing for pRectCount;
13674 vkReadStream->unsetHandleMapping();
13675 // WARNING PTR CHECK
13676 memcpy((uint32_t**)&pRectCount, (*readStreamPtrPtr), 8);
13677 android::base::Stream::fromBe64((uint8_t*)&pRectCount);
13678 *readStreamPtrPtr += 8;
13679 if (pRectCount) {
13680 vkReadStream->alloc((void**)&pRectCount, sizeof(uint32_t));
13681 memcpy((uint32_t*)pRectCount, *readStreamPtrPtr, sizeof(uint32_t));
13682 *readStreamPtrPtr += sizeof(uint32_t);
13683 }
13684 // Begin manual dispatchable handle unboxing for pRects;
13685 vkReadStream->unsetHandleMapping();
13686 // WARNING PTR CHECK
13687 memcpy((VkRect2D**)&pRects, (*readStreamPtrPtr), 8);
13688 android::base::Stream::fromBe64((uint8_t*)&pRects);
13689 *readStreamPtrPtr += 8;
13690 if (pRects) {
13691 vkReadStream->alloc((void**)&pRects, (*(pRectCount)) * sizeof(VkRect2D));
13692 for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i) {
13693 reservedunmarshal_VkRect2D(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13694 (VkRect2D*)(pRects + i), readStreamPtrPtr);
13695 }
13696 }
13697 if (pRectCount) {
13698 if (pRects) {
13699 for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i) {
13700 transform_tohost_VkRect2D(m_state, (VkRect2D*)(pRects + i));
13701 }
13702 }
13703 }
13704 if (m_logCalls) {
13705 fprintf(stderr,
13706 "stream %p: call vkGetPhysicalDevicePresentRectanglesKHR 0x%llx 0x%llx "
13707 "0x%llx 0x%llx \n",
13708 ioStream, (unsigned long long)physicalDevice,
13709 (unsigned long long)surface, (unsigned long long)pRectCount,
13710 (unsigned long long)pRects);
13711 }
13712 VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
13713 vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return =
13714 vk->vkGetPhysicalDevicePresentRectanglesKHR(unboxed_physicalDevice, surface,
13715 pRectCount, pRects);
13716 if ((vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return) ==
13717 VK_ERROR_DEVICE_LOST)
13718 m_state->on_DeviceLost();
13719 m_state->on_CheckOutOfMemory(
13720 vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return, opcode, context);
13721 vkStream->unsetHandleMapping();
13722 // WARNING PTR CHECK
13723 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pRectCount;
13724 vkStream->putBe64(cgen_var_4);
13725 if (pRectCount) {
13726 vkStream->write((uint32_t*)pRectCount, sizeof(uint32_t));
13727 }
13728 if (pRectCount) {
13729 if (pRects) {
13730 for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i) {
13731 transform_fromhost_VkRect2D(m_state, (VkRect2D*)(pRects + i));
13732 }
13733 }
13734 }
13735 // WARNING PTR CHECK
13736 uint64_t cgen_var_5 = (uint64_t)(uintptr_t)pRects;
13737 vkStream->putBe64(cgen_var_5);
13738 if (pRects) {
13739 if (pRectCount) {
13740 for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i) {
13741 marshal_VkRect2D(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13742 (VkRect2D*)(pRects + i));
13743 }
13744 }
13745 }
13746 vkStream->write(&vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return,
13747 sizeof(VkResult));
13748 vkStream->commitWrite();
13749 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13750 (uintptr_t)snapshotTraceBegin);
13751 size_t snapshotTraceBytes = vkReadStream->endTrace();
13752 if (m_state->snapshotsEnabled()) {
13753 m_state->snapshot()->vkGetPhysicalDevicePresentRectanglesKHR(
13754 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
13755 vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return, physicalDevice,
13756 surface, pRectCount, pRects);
13757 }
13758 vkReadStream->clearPool();
13759 if (m_queueSubmitWithCommandsEnabled)
13760 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13761 break;
13762 }
13763 case OP_vkAcquireNextImage2KHR: {
13764 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13765 "VkDecoder vkAcquireNextImage2KHR");
13766 VkDevice device;
13767 const VkAcquireNextImageInfoKHR* pAcquireInfo;
13768 uint32_t* pImageIndex;
13769 // Begin non wrapped dispatchable handle unboxing for device;
13770 uint64_t cgen_var_0;
13771 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13772 *readStreamPtrPtr += 1 * 8;
13773 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
13774 auto unboxed_device = unbox_VkDevice(device);
13775 auto vk = dispatch_VkDevice(device);
13776 // End manual dispatchable handle unboxing for device;
13777 vkReadStream->alloc((void**)&pAcquireInfo, sizeof(const VkAcquireNextImageInfoKHR));
13778 reservedunmarshal_VkAcquireNextImageInfoKHR(
13779 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13780 (VkAcquireNextImageInfoKHR*)(pAcquireInfo), readStreamPtrPtr);
13781 // Begin manual dispatchable handle unboxing for pImageIndex;
13782 vkReadStream->unsetHandleMapping();
13783 vkReadStream->alloc((void**)&pImageIndex, sizeof(uint32_t));
13784 memcpy((uint32_t*)pImageIndex, *readStreamPtrPtr, sizeof(uint32_t));
13785 *readStreamPtrPtr += sizeof(uint32_t);
13786 if (pAcquireInfo) {
13787 transform_tohost_VkAcquireNextImageInfoKHR(
13788 m_state, (VkAcquireNextImageInfoKHR*)(pAcquireInfo));
13789 }
13790 if (m_logCalls) {
13791 fprintf(stderr,
13792 "stream %p: call vkAcquireNextImage2KHR 0x%llx 0x%llx 0x%llx \n",
13793 ioStream, (unsigned long long)device, (unsigned long long)pAcquireInfo,
13794 (unsigned long long)pImageIndex);
13795 }
13796 VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
13797 vkAcquireNextImage2KHR_VkResult_return =
13798 vk->vkAcquireNextImage2KHR(unboxed_device, pAcquireInfo, pImageIndex);
13799 if ((vkAcquireNextImage2KHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
13800 m_state->on_DeviceLost();
13801 m_state->on_CheckOutOfMemory(vkAcquireNextImage2KHR_VkResult_return, opcode,
13802 context);
13803 vkStream->unsetHandleMapping();
13804 vkStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
13805 vkStream->write(&vkAcquireNextImage2KHR_VkResult_return, sizeof(VkResult));
13806 vkStream->commitWrite();
13807 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13808 (uintptr_t)snapshotTraceBegin);
13809 size_t snapshotTraceBytes = vkReadStream->endTrace();
13810 if (m_state->snapshotsEnabled()) {
13811 m_state->snapshot()->vkAcquireNextImage2KHR(
13812 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
13813 vkAcquireNextImage2KHR_VkResult_return, device, pAcquireInfo, pImageIndex);
13814 }
13815 vkReadStream->clearPool();
13816 if (m_queueSubmitWithCommandsEnabled)
13817 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13818 break;
13819 }
13820 #endif
13821 #ifdef VK_KHR_dynamic_rendering
13822 case OP_vkCmdBeginRenderingKHR: {
13823 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13824 "VkDecoder vkCmdBeginRenderingKHR");
13825 VkCommandBuffer commandBuffer;
13826 const VkRenderingInfo* pRenderingInfo;
13827 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
13828 uint64_t cgen_var_0;
13829 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13830 *readStreamPtrPtr += 1 * 8;
13831 *(VkCommandBuffer*)&commandBuffer =
13832 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
13833 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
13834 auto vk = dispatch_VkCommandBuffer(commandBuffer);
13835 // End manual dispatchable handle unboxing for commandBuffer;
13836 vkReadStream->alloc((void**)&pRenderingInfo, sizeof(const VkRenderingInfo));
13837 reservedunmarshal_VkRenderingInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13838 (VkRenderingInfo*)(pRenderingInfo),
13839 readStreamPtrPtr);
13840 if (pRenderingInfo) {
13841 transform_tohost_VkRenderingInfo(m_state, (VkRenderingInfo*)(pRenderingInfo));
13842 }
13843 if (m_logCalls) {
13844 fprintf(stderr, "stream %p: call vkCmdBeginRenderingKHR 0x%llx 0x%llx \n",
13845 ioStream, (unsigned long long)commandBuffer,
13846 (unsigned long long)pRenderingInfo);
13847 }
13848 vk->vkCmdBeginRenderingKHR(unboxed_commandBuffer, pRenderingInfo);
13849 vkStream->unsetHandleMapping();
13850 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13851 (uintptr_t)snapshotTraceBegin);
13852 size_t snapshotTraceBytes = vkReadStream->endTrace();
13853 if (m_state->snapshotsEnabled()) {
13854 m_state->snapshot()->vkCmdBeginRenderingKHR(snapshotTraceBegin,
13855 snapshotTraceBytes, &m_pool,
13856 commandBuffer, pRenderingInfo);
13857 }
13858 vkReadStream->clearPool();
13859 if (m_queueSubmitWithCommandsEnabled)
13860 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13861 break;
13862 }
13863 case OP_vkCmdEndRenderingKHR: {
13864 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13865 "VkDecoder vkCmdEndRenderingKHR");
13866 VkCommandBuffer commandBuffer;
13867 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
13868 uint64_t cgen_var_0;
13869 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13870 *readStreamPtrPtr += 1 * 8;
13871 *(VkCommandBuffer*)&commandBuffer =
13872 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
13873 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
13874 auto vk = dispatch_VkCommandBuffer(commandBuffer);
13875 // End manual dispatchable handle unboxing for commandBuffer;
13876 if (m_logCalls) {
13877 fprintf(stderr, "stream %p: call vkCmdEndRenderingKHR 0x%llx \n", ioStream,
13878 (unsigned long long)commandBuffer);
13879 }
13880 vk->vkCmdEndRenderingKHR(unboxed_commandBuffer);
13881 vkStream->unsetHandleMapping();
13882 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13883 (uintptr_t)snapshotTraceBegin);
13884 size_t snapshotTraceBytes = vkReadStream->endTrace();
13885 if (m_state->snapshotsEnabled()) {
13886 m_state->snapshot()->vkCmdEndRenderingKHR(
13887 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer);
13888 }
13889 vkReadStream->clearPool();
13890 if (m_queueSubmitWithCommandsEnabled)
13891 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13892 break;
13893 }
13894 #endif
13895 #ifdef VK_KHR_get_physical_device_properties2
13896 case OP_vkGetPhysicalDeviceFeatures2KHR: {
13897 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13898 "VkDecoder vkGetPhysicalDeviceFeatures2KHR");
13899 VkPhysicalDevice physicalDevice;
13900 VkPhysicalDeviceFeatures2* pFeatures;
13901 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
13902 uint64_t cgen_var_0;
13903 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13904 *readStreamPtrPtr += 1 * 8;
13905 *(VkPhysicalDevice*)&physicalDevice =
13906 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
13907 // Begin manual dispatchable handle unboxing for pFeatures;
13908 vkReadStream->unsetHandleMapping();
13909 vkReadStream->alloc((void**)&pFeatures, sizeof(VkPhysicalDeviceFeatures2));
13910 reservedunmarshal_VkPhysicalDeviceFeatures2(
13911 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13912 (VkPhysicalDeviceFeatures2*)(pFeatures), readStreamPtrPtr);
13913 if (pFeatures) {
13914 transform_tohost_VkPhysicalDeviceFeatures2(
13915 m_state, (VkPhysicalDeviceFeatures2*)(pFeatures));
13916 }
13917 if (m_logCalls) {
13918 fprintf(stderr,
13919 "stream %p: call vkGetPhysicalDeviceFeatures2KHR 0x%llx 0x%llx \n",
13920 ioStream, (unsigned long long)physicalDevice,
13921 (unsigned long long)pFeatures);
13922 }
13923 m_state->on_vkGetPhysicalDeviceFeatures2KHR(&m_pool, physicalDevice, pFeatures);
13924 vkStream->unsetHandleMapping();
13925 if (pFeatures) {
13926 transform_fromhost_VkPhysicalDeviceFeatures2(
13927 m_state, (VkPhysicalDeviceFeatures2*)(pFeatures));
13928 }
13929 marshal_VkPhysicalDeviceFeatures2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13930 (VkPhysicalDeviceFeatures2*)(pFeatures));
13931 vkStream->commitWrite();
13932 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13933 (uintptr_t)snapshotTraceBegin);
13934 size_t snapshotTraceBytes = vkReadStream->endTrace();
13935 if (m_state->snapshotsEnabled()) {
13936 m_state->snapshot()->vkGetPhysicalDeviceFeatures2KHR(
13937 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice, pFeatures);
13938 }
13939 vkReadStream->clearPool();
13940 if (m_queueSubmitWithCommandsEnabled)
13941 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13942 break;
13943 }
13944 case OP_vkGetPhysicalDeviceProperties2KHR: {
13945 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13946 "VkDecoder vkGetPhysicalDeviceProperties2KHR");
13947 VkPhysicalDevice physicalDevice;
13948 VkPhysicalDeviceProperties2* pProperties;
13949 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
13950 uint64_t cgen_var_0;
13951 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
13952 *readStreamPtrPtr += 1 * 8;
13953 *(VkPhysicalDevice*)&physicalDevice =
13954 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
13955 // Begin manual dispatchable handle unboxing for pProperties;
13956 vkReadStream->unsetHandleMapping();
13957 vkReadStream->alloc((void**)&pProperties, sizeof(VkPhysicalDeviceProperties2));
13958 reservedunmarshal_VkPhysicalDeviceProperties2(
13959 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13960 (VkPhysicalDeviceProperties2*)(pProperties), readStreamPtrPtr);
13961 if (pProperties) {
13962 transform_tohost_VkPhysicalDeviceProperties2(
13963 m_state, (VkPhysicalDeviceProperties2*)(pProperties));
13964 }
13965 if (m_logCalls) {
13966 fprintf(stderr,
13967 "stream %p: call vkGetPhysicalDeviceProperties2KHR 0x%llx 0x%llx \n",
13968 ioStream, (unsigned long long)physicalDevice,
13969 (unsigned long long)pProperties);
13970 }
13971 m_state->on_vkGetPhysicalDeviceProperties2KHR(&m_pool, physicalDevice, pProperties);
13972 vkStream->unsetHandleMapping();
13973 if (pProperties) {
13974 transform_fromhost_VkPhysicalDeviceProperties2(
13975 m_state, (VkPhysicalDeviceProperties2*)(pProperties));
13976 }
13977 marshal_VkPhysicalDeviceProperties2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
13978 (VkPhysicalDeviceProperties2*)(pProperties));
13979 vkStream->commitWrite();
13980 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
13981 (uintptr_t)snapshotTraceBegin);
13982 size_t snapshotTraceBytes = vkReadStream->endTrace();
13983 if (m_state->snapshotsEnabled()) {
13984 m_state->snapshot()->vkGetPhysicalDeviceProperties2KHR(
13985 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
13986 pProperties);
13987 }
13988 vkReadStream->clearPool();
13989 if (m_queueSubmitWithCommandsEnabled)
13990 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
13991 break;
13992 }
13993 case OP_vkGetPhysicalDeviceFormatProperties2KHR: {
13994 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
13995 "VkDecoder vkGetPhysicalDeviceFormatProperties2KHR");
13996 VkPhysicalDevice physicalDevice;
13997 VkFormat format;
13998 VkFormatProperties2* pFormatProperties;
13999 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
14000 uint64_t cgen_var_0;
14001 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14002 *readStreamPtrPtr += 1 * 8;
14003 *(VkPhysicalDevice*)&physicalDevice =
14004 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
14005 memcpy((VkFormat*)&format, *readStreamPtrPtr, sizeof(VkFormat));
14006 *readStreamPtrPtr += sizeof(VkFormat);
14007 // Begin manual dispatchable handle unboxing for pFormatProperties;
14008 vkReadStream->unsetHandleMapping();
14009 vkReadStream->alloc((void**)&pFormatProperties, sizeof(VkFormatProperties2));
14010 reservedunmarshal_VkFormatProperties2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14011 (VkFormatProperties2*)(pFormatProperties),
14012 readStreamPtrPtr);
14013 if (pFormatProperties) {
14014 transform_tohost_VkFormatProperties2(m_state,
14015 (VkFormatProperties2*)(pFormatProperties));
14016 }
14017 if (m_logCalls) {
14018 fprintf(stderr,
14019 "stream %p: call vkGetPhysicalDeviceFormatProperties2KHR 0x%llx 0x%llx "
14020 "0x%llx \n",
14021 ioStream, (unsigned long long)physicalDevice,
14022 (unsigned long long)format, (unsigned long long)pFormatProperties);
14023 }
14024 m_state->on_vkGetPhysicalDeviceFormatProperties2KHR(&m_pool, physicalDevice, format,
14025 pFormatProperties);
14026 vkStream->unsetHandleMapping();
14027 if (pFormatProperties) {
14028 transform_fromhost_VkFormatProperties2(
14029 m_state, (VkFormatProperties2*)(pFormatProperties));
14030 }
14031 marshal_VkFormatProperties2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14032 (VkFormatProperties2*)(pFormatProperties));
14033 vkStream->commitWrite();
14034 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14035 (uintptr_t)snapshotTraceBegin);
14036 size_t snapshotTraceBytes = vkReadStream->endTrace();
14037 if (m_state->snapshotsEnabled()) {
14038 m_state->snapshot()->vkGetPhysicalDeviceFormatProperties2KHR(
14039 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice, format,
14040 pFormatProperties);
14041 }
14042 vkReadStream->clearPool();
14043 if (m_queueSubmitWithCommandsEnabled)
14044 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14045 break;
14046 }
14047 case OP_vkGetPhysicalDeviceImageFormatProperties2KHR: {
14048 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14049 "VkDecoder vkGetPhysicalDeviceImageFormatProperties2KHR");
14050 VkPhysicalDevice physicalDevice;
14051 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo;
14052 VkImageFormatProperties2* pImageFormatProperties;
14053 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
14054 uint64_t cgen_var_0;
14055 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14056 *readStreamPtrPtr += 1 * 8;
14057 *(VkPhysicalDevice*)&physicalDevice =
14058 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
14059 vkReadStream->alloc((void**)&pImageFormatInfo,
14060 sizeof(const VkPhysicalDeviceImageFormatInfo2));
14061 reservedunmarshal_VkPhysicalDeviceImageFormatInfo2(
14062 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14063 (VkPhysicalDeviceImageFormatInfo2*)(pImageFormatInfo), readStreamPtrPtr);
14064 // Begin manual dispatchable handle unboxing for pImageFormatProperties;
14065 vkReadStream->unsetHandleMapping();
14066 vkReadStream->alloc((void**)&pImageFormatProperties,
14067 sizeof(VkImageFormatProperties2));
14068 reservedunmarshal_VkImageFormatProperties2(
14069 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14070 (VkImageFormatProperties2*)(pImageFormatProperties), readStreamPtrPtr);
14071 if (pImageFormatInfo) {
14072 transform_tohost_VkPhysicalDeviceImageFormatInfo2(
14073 m_state, (VkPhysicalDeviceImageFormatInfo2*)(pImageFormatInfo));
14074 }
14075 if (pImageFormatProperties) {
14076 transform_tohost_VkImageFormatProperties2(
14077 m_state, (VkImageFormatProperties2*)(pImageFormatProperties));
14078 }
14079 if (m_logCalls) {
14080 fprintf(stderr,
14081 "stream %p: call vkGetPhysicalDeviceImageFormatProperties2KHR 0x%llx "
14082 "0x%llx 0x%llx \n",
14083 ioStream, (unsigned long long)physicalDevice,
14084 (unsigned long long)pImageFormatInfo,
14085 (unsigned long long)pImageFormatProperties);
14086 }
14087 VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
14088 vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
14089 m_state->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
14090 &m_pool, physicalDevice, pImageFormatInfo, pImageFormatProperties);
14091 if ((vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return) ==
14092 VK_ERROR_DEVICE_LOST)
14093 m_state->on_DeviceLost();
14094 m_state->on_CheckOutOfMemory(
14095 vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return, opcode, context);
14096 vkStream->unsetHandleMapping();
14097 if (pImageFormatProperties) {
14098 transform_fromhost_VkImageFormatProperties2(
14099 m_state, (VkImageFormatProperties2*)(pImageFormatProperties));
14100 }
14101 marshal_VkImageFormatProperties2(
14102 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14103 (VkImageFormatProperties2*)(pImageFormatProperties));
14104 vkStream->write(&vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return,
14105 sizeof(VkResult));
14106 vkStream->commitWrite();
14107 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14108 (uintptr_t)snapshotTraceBegin);
14109 size_t snapshotTraceBytes = vkReadStream->endTrace();
14110 if (m_state->snapshotsEnabled()) {
14111 m_state->snapshot()->vkGetPhysicalDeviceImageFormatProperties2KHR(
14112 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
14113 vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return,
14114 physicalDevice, pImageFormatInfo, pImageFormatProperties);
14115 }
14116 vkReadStream->clearPool();
14117 if (m_queueSubmitWithCommandsEnabled)
14118 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14119 break;
14120 }
14121 case OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR: {
14122 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14123 "VkDecoder vkGetPhysicalDeviceQueueFamilyProperties2KHR");
14124 VkPhysicalDevice physicalDevice;
14125 uint32_t* pQueueFamilyPropertyCount;
14126 VkQueueFamilyProperties2* pQueueFamilyProperties;
14127 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
14128 uint64_t cgen_var_0;
14129 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14130 *readStreamPtrPtr += 1 * 8;
14131 *(VkPhysicalDevice*)&physicalDevice =
14132 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
14133 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
14134 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
14135 // End manual dispatchable handle unboxing for physicalDevice;
14136 // Begin manual dispatchable handle unboxing for pQueueFamilyPropertyCount;
14137 vkReadStream->unsetHandleMapping();
14138 // WARNING PTR CHECK
14139 memcpy((uint32_t**)&pQueueFamilyPropertyCount, (*readStreamPtrPtr), 8);
14140 android::base::Stream::fromBe64((uint8_t*)&pQueueFamilyPropertyCount);
14141 *readStreamPtrPtr += 8;
14142 if (pQueueFamilyPropertyCount) {
14143 vkReadStream->alloc((void**)&pQueueFamilyPropertyCount, sizeof(uint32_t));
14144 memcpy((uint32_t*)pQueueFamilyPropertyCount, *readStreamPtrPtr,
14145 sizeof(uint32_t));
14146 *readStreamPtrPtr += sizeof(uint32_t);
14147 }
14148 // Begin manual dispatchable handle unboxing for pQueueFamilyProperties;
14149 vkReadStream->unsetHandleMapping();
14150 // WARNING PTR CHECK
14151 memcpy((VkQueueFamilyProperties2**)&pQueueFamilyProperties, (*readStreamPtrPtr), 8);
14152 android::base::Stream::fromBe64((uint8_t*)&pQueueFamilyProperties);
14153 *readStreamPtrPtr += 8;
14154 if (pQueueFamilyProperties) {
14155 vkReadStream->alloc(
14156 (void**)&pQueueFamilyProperties,
14157 (*(pQueueFamilyPropertyCount)) * sizeof(VkQueueFamilyProperties2));
14158 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
14159 reservedunmarshal_VkQueueFamilyProperties2(
14160 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14161 (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i),
14162 readStreamPtrPtr);
14163 }
14164 }
14165 if (pQueueFamilyPropertyCount) {
14166 if (pQueueFamilyProperties) {
14167 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
14168 transform_tohost_VkQueueFamilyProperties2(
14169 m_state, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
14170 }
14171 }
14172 }
14173 if (m_logCalls) {
14174 fprintf(stderr,
14175 "stream %p: call vkGetPhysicalDeviceQueueFamilyProperties2KHR 0x%llx "
14176 "0x%llx 0x%llx \n",
14177 ioStream, (unsigned long long)physicalDevice,
14178 (unsigned long long)pQueueFamilyPropertyCount,
14179 (unsigned long long)pQueueFamilyProperties);
14180 }
14181 vk->vkGetPhysicalDeviceQueueFamilyProperties2KHR(
14182 unboxed_physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
14183 vkStream->unsetHandleMapping();
14184 // WARNING PTR CHECK
14185 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
14186 vkStream->putBe64(cgen_var_3);
14187 if (pQueueFamilyPropertyCount) {
14188 vkStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
14189 }
14190 if (pQueueFamilyPropertyCount) {
14191 if (pQueueFamilyProperties) {
14192 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
14193 transform_fromhost_VkQueueFamilyProperties2(
14194 m_state, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
14195 }
14196 }
14197 }
14198 // WARNING PTR CHECK
14199 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
14200 vkStream->putBe64(cgen_var_4);
14201 if (pQueueFamilyProperties) {
14202 if (pQueueFamilyPropertyCount) {
14203 for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
14204 marshal_VkQueueFamilyProperties2(
14205 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14206 (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
14207 }
14208 }
14209 }
14210 vkStream->commitWrite();
14211 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14212 (uintptr_t)snapshotTraceBegin);
14213 size_t snapshotTraceBytes = vkReadStream->endTrace();
14214 if (m_state->snapshotsEnabled()) {
14215 m_state->snapshot()->vkGetPhysicalDeviceQueueFamilyProperties2KHR(
14216 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
14217 pQueueFamilyPropertyCount, pQueueFamilyProperties);
14218 }
14219 vkReadStream->clearPool();
14220 if (m_queueSubmitWithCommandsEnabled)
14221 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14222 break;
14223 }
14224 case OP_vkGetPhysicalDeviceMemoryProperties2KHR: {
14225 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14226 "VkDecoder vkGetPhysicalDeviceMemoryProperties2KHR");
14227 VkPhysicalDevice physicalDevice;
14228 VkPhysicalDeviceMemoryProperties2* pMemoryProperties;
14229 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
14230 uint64_t cgen_var_0;
14231 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14232 *readStreamPtrPtr += 1 * 8;
14233 *(VkPhysicalDevice*)&physicalDevice =
14234 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
14235 // Begin manual dispatchable handle unboxing for pMemoryProperties;
14236 vkReadStream->unsetHandleMapping();
14237 vkReadStream->alloc((void**)&pMemoryProperties,
14238 sizeof(VkPhysicalDeviceMemoryProperties2));
14239 reservedunmarshal_VkPhysicalDeviceMemoryProperties2(
14240 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14241 (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), readStreamPtrPtr);
14242 if (pMemoryProperties) {
14243 transform_tohost_VkPhysicalDeviceMemoryProperties2(
14244 m_state, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
14245 }
14246 if (m_logCalls) {
14247 fprintf(
14248 stderr,
14249 "stream %p: call vkGetPhysicalDeviceMemoryProperties2KHR 0x%llx 0x%llx \n",
14250 ioStream, (unsigned long long)physicalDevice,
14251 (unsigned long long)pMemoryProperties);
14252 }
14253 m_state->on_vkGetPhysicalDeviceMemoryProperties2KHR(&m_pool, physicalDevice,
14254 pMemoryProperties);
14255 vkStream->unsetHandleMapping();
14256 if (pMemoryProperties) {
14257 transform_fromhost_VkPhysicalDeviceMemoryProperties2(
14258 m_state, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
14259 }
14260 marshal_VkPhysicalDeviceMemoryProperties2(
14261 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14262 (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
14263 vkStream->commitWrite();
14264 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14265 (uintptr_t)snapshotTraceBegin);
14266 size_t snapshotTraceBytes = vkReadStream->endTrace();
14267 if (m_state->snapshotsEnabled()) {
14268 m_state->snapshot()->vkGetPhysicalDeviceMemoryProperties2KHR(
14269 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
14270 pMemoryProperties);
14271 }
14272 vkReadStream->clearPool();
14273 if (m_queueSubmitWithCommandsEnabled)
14274 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14275 break;
14276 }
14277 case OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR: {
14278 GFXSTREAM_TRACE_EVENT(
14279 GFXSTREAM_TRACE_DECODER_CATEGORY,
14280 "VkDecoder vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
14281 VkPhysicalDevice physicalDevice;
14282 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo;
14283 uint32_t* pPropertyCount;
14284 VkSparseImageFormatProperties2* pProperties;
14285 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
14286 uint64_t cgen_var_0;
14287 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14288 *readStreamPtrPtr += 1 * 8;
14289 *(VkPhysicalDevice*)&physicalDevice =
14290 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
14291 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
14292 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
14293 // End manual dispatchable handle unboxing for physicalDevice;
14294 vkReadStream->alloc((void**)&pFormatInfo,
14295 sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
14296 reservedunmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
14297 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14298 (VkPhysicalDeviceSparseImageFormatInfo2*)(pFormatInfo), readStreamPtrPtr);
14299 // Begin manual dispatchable handle unboxing for pPropertyCount;
14300 vkReadStream->unsetHandleMapping();
14301 // WARNING PTR CHECK
14302 memcpy((uint32_t**)&pPropertyCount, (*readStreamPtrPtr), 8);
14303 android::base::Stream::fromBe64((uint8_t*)&pPropertyCount);
14304 *readStreamPtrPtr += 8;
14305 if (pPropertyCount) {
14306 vkReadStream->alloc((void**)&pPropertyCount, sizeof(uint32_t));
14307 memcpy((uint32_t*)pPropertyCount, *readStreamPtrPtr, sizeof(uint32_t));
14308 *readStreamPtrPtr += sizeof(uint32_t);
14309 }
14310 // Begin manual dispatchable handle unboxing for pProperties;
14311 vkReadStream->unsetHandleMapping();
14312 // WARNING PTR CHECK
14313 memcpy((VkSparseImageFormatProperties2**)&pProperties, (*readStreamPtrPtr), 8);
14314 android::base::Stream::fromBe64((uint8_t*)&pProperties);
14315 *readStreamPtrPtr += 8;
14316 if (pProperties) {
14317 vkReadStream->alloc(
14318 (void**)&pProperties,
14319 (*(pPropertyCount)) * sizeof(VkSparseImageFormatProperties2));
14320 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
14321 reservedunmarshal_VkSparseImageFormatProperties2(
14322 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14323 (VkSparseImageFormatProperties2*)(pProperties + i), readStreamPtrPtr);
14324 }
14325 }
14326 if (pFormatInfo) {
14327 transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2(
14328 m_state, (VkPhysicalDeviceSparseImageFormatInfo2*)(pFormatInfo));
14329 }
14330 if (pPropertyCount) {
14331 if (pProperties) {
14332 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
14333 transform_tohost_VkSparseImageFormatProperties2(
14334 m_state, (VkSparseImageFormatProperties2*)(pProperties + i));
14335 }
14336 }
14337 }
14338 if (m_logCalls) {
14339 fprintf(stderr,
14340 "stream %p: call vkGetPhysicalDeviceSparseImageFormatProperties2KHR "
14341 "0x%llx 0x%llx 0x%llx 0x%llx \n",
14342 ioStream, (unsigned long long)physicalDevice,
14343 (unsigned long long)pFormatInfo, (unsigned long long)pPropertyCount,
14344 (unsigned long long)pProperties);
14345 }
14346 vk->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
14347 unboxed_physicalDevice, pFormatInfo, pPropertyCount, pProperties);
14348 vkStream->unsetHandleMapping();
14349 // WARNING PTR CHECK
14350 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pPropertyCount;
14351 vkStream->putBe64(cgen_var_3);
14352 if (pPropertyCount) {
14353 vkStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
14354 }
14355 if (pPropertyCount) {
14356 if (pProperties) {
14357 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
14358 transform_fromhost_VkSparseImageFormatProperties2(
14359 m_state, (VkSparseImageFormatProperties2*)(pProperties + i));
14360 }
14361 }
14362 }
14363 // WARNING PTR CHECK
14364 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pProperties;
14365 vkStream->putBe64(cgen_var_4);
14366 if (pProperties) {
14367 if (pPropertyCount) {
14368 for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
14369 marshal_VkSparseImageFormatProperties2(
14370 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14371 (VkSparseImageFormatProperties2*)(pProperties + i));
14372 }
14373 }
14374 }
14375 vkStream->commitWrite();
14376 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14377 (uintptr_t)snapshotTraceBegin);
14378 size_t snapshotTraceBytes = vkReadStream->endTrace();
14379 if (m_state->snapshotsEnabled()) {
14380 m_state->snapshot()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
14381 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
14382 pFormatInfo, pPropertyCount, pProperties);
14383 }
14384 vkReadStream->clearPool();
14385 if (m_queueSubmitWithCommandsEnabled)
14386 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14387 break;
14388 }
14389 #endif
14390 #ifdef VK_KHR_maintenance1
14391 case OP_vkTrimCommandPoolKHR: {
14392 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14393 "VkDecoder vkTrimCommandPoolKHR");
14394 VkDevice device;
14395 VkCommandPool commandPool;
14396 VkCommandPoolTrimFlags flags;
14397 // Begin non wrapped dispatchable handle unboxing for device;
14398 uint64_t cgen_var_0;
14399 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14400 *readStreamPtrPtr += 1 * 8;
14401 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
14402 auto unboxed_device = unbox_VkDevice(device);
14403 auto vk = dispatch_VkDevice(device);
14404 // End manual dispatchable handle unboxing for device;
14405 uint64_t cgen_var_1;
14406 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
14407 *readStreamPtrPtr += 1 * 8;
14408 *(VkCommandPool*)&commandPool =
14409 (VkCommandPool)unbox_VkCommandPool((VkCommandPool)(*&cgen_var_1));
14410 memcpy((VkCommandPoolTrimFlags*)&flags, *readStreamPtrPtr,
14411 sizeof(VkCommandPoolTrimFlags));
14412 *readStreamPtrPtr += sizeof(VkCommandPoolTrimFlags);
14413 if (m_logCalls) {
14414 fprintf(stderr, "stream %p: call vkTrimCommandPoolKHR 0x%llx 0x%llx 0x%llx \n",
14415 ioStream, (unsigned long long)device, (unsigned long long)commandPool,
14416 (unsigned long long)flags);
14417 }
14418 vk->vkTrimCommandPoolKHR(unboxed_device, commandPool, flags);
14419 vkStream->unsetHandleMapping();
14420 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14421 (uintptr_t)snapshotTraceBegin);
14422 size_t snapshotTraceBytes = vkReadStream->endTrace();
14423 if (m_state->snapshotsEnabled()) {
14424 m_state->snapshot()->vkTrimCommandPoolKHR(snapshotTraceBegin,
14425 snapshotTraceBytes, &m_pool, device,
14426 commandPool, flags);
14427 }
14428 vkReadStream->clearPool();
14429 if (m_queueSubmitWithCommandsEnabled)
14430 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14431 break;
14432 }
14433 #endif
14434 #ifdef VK_KHR_external_memory_capabilities
14435 case OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR: {
14436 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14437 "VkDecoder vkGetPhysicalDeviceExternalBufferPropertiesKHR");
14438 VkPhysicalDevice physicalDevice;
14439 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo;
14440 VkExternalBufferProperties* pExternalBufferProperties;
14441 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
14442 uint64_t cgen_var_0;
14443 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14444 *readStreamPtrPtr += 1 * 8;
14445 *(VkPhysicalDevice*)&physicalDevice =
14446 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
14447 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
14448 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
14449 // End manual dispatchable handle unboxing for physicalDevice;
14450 vkReadStream->alloc((void**)&pExternalBufferInfo,
14451 sizeof(const VkPhysicalDeviceExternalBufferInfo));
14452 reservedunmarshal_VkPhysicalDeviceExternalBufferInfo(
14453 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14454 (VkPhysicalDeviceExternalBufferInfo*)(pExternalBufferInfo), readStreamPtrPtr);
14455 // Begin manual dispatchable handle unboxing for pExternalBufferProperties;
14456 vkReadStream->unsetHandleMapping();
14457 vkReadStream->alloc((void**)&pExternalBufferProperties,
14458 sizeof(VkExternalBufferProperties));
14459 reservedunmarshal_VkExternalBufferProperties(
14460 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14461 (VkExternalBufferProperties*)(pExternalBufferProperties), readStreamPtrPtr);
14462 if (pExternalBufferInfo) {
14463 m_state->transformImpl_VkPhysicalDeviceExternalBufferInfo_tohost(
14464 pExternalBufferInfo, 1);
14465 transform_tohost_VkPhysicalDeviceExternalBufferInfo(
14466 m_state, (VkPhysicalDeviceExternalBufferInfo*)(pExternalBufferInfo));
14467 }
14468 if (pExternalBufferProperties) {
14469 m_state->transformImpl_VkExternalBufferProperties_tohost(
14470 pExternalBufferProperties, 1);
14471 transform_tohost_VkExternalBufferProperties(
14472 m_state, (VkExternalBufferProperties*)(pExternalBufferProperties));
14473 }
14474 if (m_logCalls) {
14475 fprintf(stderr,
14476 "stream %p: call vkGetPhysicalDeviceExternalBufferPropertiesKHR 0x%llx "
14477 "0x%llx 0x%llx \n",
14478 ioStream, (unsigned long long)physicalDevice,
14479 (unsigned long long)pExternalBufferInfo,
14480 (unsigned long long)pExternalBufferProperties);
14481 }
14482 vk->vkGetPhysicalDeviceExternalBufferPropertiesKHR(
14483 unboxed_physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
14484 vkStream->unsetHandleMapping();
14485 if (pExternalBufferProperties) {
14486 m_state->transformImpl_VkExternalBufferProperties_fromhost(
14487 pExternalBufferProperties, 1);
14488 transform_fromhost_VkExternalBufferProperties(
14489 m_state, (VkExternalBufferProperties*)(pExternalBufferProperties));
14490 }
14491 marshal_VkExternalBufferProperties(
14492 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14493 (VkExternalBufferProperties*)(pExternalBufferProperties));
14494 vkStream->commitWrite();
14495 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14496 (uintptr_t)snapshotTraceBegin);
14497 size_t snapshotTraceBytes = vkReadStream->endTrace();
14498 if (m_state->snapshotsEnabled()) {
14499 m_state->snapshot()->vkGetPhysicalDeviceExternalBufferPropertiesKHR(
14500 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
14501 pExternalBufferInfo, pExternalBufferProperties);
14502 }
14503 vkReadStream->clearPool();
14504 if (m_queueSubmitWithCommandsEnabled)
14505 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14506 break;
14507 }
14508 #endif
14509 #ifdef VK_KHR_external_semaphore_capabilities
14510 case OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: {
14511 GFXSTREAM_TRACE_EVENT(
14512 GFXSTREAM_TRACE_DECODER_CATEGORY,
14513 "VkDecoder vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
14514 VkPhysicalDevice physicalDevice;
14515 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo;
14516 VkExternalSemaphoreProperties* pExternalSemaphoreProperties;
14517 // Begin global wrapped dispatchable handle unboxing for physicalDevice;
14518 uint64_t cgen_var_0;
14519 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14520 *readStreamPtrPtr += 1 * 8;
14521 *(VkPhysicalDevice*)&physicalDevice =
14522 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
14523 vkReadStream->alloc((void**)&pExternalSemaphoreInfo,
14524 sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
14525 reservedunmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
14526 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14527 (VkPhysicalDeviceExternalSemaphoreInfo*)(pExternalSemaphoreInfo),
14528 readStreamPtrPtr);
14529 // Begin manual dispatchable handle unboxing for pExternalSemaphoreProperties;
14530 vkReadStream->unsetHandleMapping();
14531 vkReadStream->alloc((void**)&pExternalSemaphoreProperties,
14532 sizeof(VkExternalSemaphoreProperties));
14533 reservedunmarshal_VkExternalSemaphoreProperties(
14534 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14535 (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties),
14536 readStreamPtrPtr);
14537 if (pExternalSemaphoreInfo) {
14538 transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo(
14539 m_state, (VkPhysicalDeviceExternalSemaphoreInfo*)(pExternalSemaphoreInfo));
14540 }
14541 if (pExternalSemaphoreProperties) {
14542 transform_tohost_VkExternalSemaphoreProperties(
14543 m_state, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
14544 }
14545 if (m_logCalls) {
14546 fprintf(stderr,
14547 "stream %p: call vkGetPhysicalDeviceExternalSemaphorePropertiesKHR "
14548 "0x%llx 0x%llx 0x%llx \n",
14549 ioStream, (unsigned long long)physicalDevice,
14550 (unsigned long long)pExternalSemaphoreInfo,
14551 (unsigned long long)pExternalSemaphoreProperties);
14552 }
14553 m_state->on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
14554 &m_pool, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
14555 vkStream->unsetHandleMapping();
14556 if (pExternalSemaphoreProperties) {
14557 transform_fromhost_VkExternalSemaphoreProperties(
14558 m_state, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
14559 }
14560 marshal_VkExternalSemaphoreProperties(
14561 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14562 (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
14563 vkStream->commitWrite();
14564 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14565 (uintptr_t)snapshotTraceBegin);
14566 size_t snapshotTraceBytes = vkReadStream->endTrace();
14567 if (m_state->snapshotsEnabled()) {
14568 m_state->snapshot()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
14569 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
14570 pExternalSemaphoreInfo, pExternalSemaphoreProperties);
14571 }
14572 vkReadStream->clearPool();
14573 if (m_queueSubmitWithCommandsEnabled)
14574 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14575 break;
14576 }
14577 #endif
14578 #ifdef VK_KHR_external_semaphore_fd
14579 case OP_vkImportSemaphoreFdKHR: {
14580 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14581 "VkDecoder vkImportSemaphoreFdKHR");
14582 VkDevice device;
14583 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo;
14584 // Begin global wrapped dispatchable handle unboxing for device;
14585 uint64_t cgen_var_0;
14586 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14587 *readStreamPtrPtr += 1 * 8;
14588 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
14589 vkReadStream->alloc((void**)&pImportSemaphoreFdInfo,
14590 sizeof(const VkImportSemaphoreFdInfoKHR));
14591 reservedunmarshal_VkImportSemaphoreFdInfoKHR(
14592 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14593 (VkImportSemaphoreFdInfoKHR*)(pImportSemaphoreFdInfo), readStreamPtrPtr);
14594 if (pImportSemaphoreFdInfo) {
14595 transform_tohost_VkImportSemaphoreFdInfoKHR(
14596 m_state, (VkImportSemaphoreFdInfoKHR*)(pImportSemaphoreFdInfo));
14597 }
14598 if (m_logCalls) {
14599 fprintf(stderr, "stream %p: call vkImportSemaphoreFdKHR 0x%llx 0x%llx \n",
14600 ioStream, (unsigned long long)device,
14601 (unsigned long long)pImportSemaphoreFdInfo);
14602 }
14603 VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
14604 vkImportSemaphoreFdKHR_VkResult_return =
14605 m_state->on_vkImportSemaphoreFdKHR(&m_pool, device, pImportSemaphoreFdInfo);
14606 if ((vkImportSemaphoreFdKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
14607 m_state->on_DeviceLost();
14608 m_state->on_CheckOutOfMemory(vkImportSemaphoreFdKHR_VkResult_return, opcode,
14609 context);
14610 vkStream->unsetHandleMapping();
14611 vkStream->write(&vkImportSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
14612 vkStream->commitWrite();
14613 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14614 (uintptr_t)snapshotTraceBegin);
14615 size_t snapshotTraceBytes = vkReadStream->endTrace();
14616 if (m_state->snapshotsEnabled()) {
14617 m_state->snapshot()->vkImportSemaphoreFdKHR(
14618 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
14619 vkImportSemaphoreFdKHR_VkResult_return, device, pImportSemaphoreFdInfo);
14620 }
14621 vkReadStream->clearPool();
14622 if (m_queueSubmitWithCommandsEnabled)
14623 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14624 break;
14625 }
14626 case OP_vkGetSemaphoreFdKHR: {
14627 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14628 "VkDecoder vkGetSemaphoreFdKHR");
14629 VkDevice device;
14630 const VkSemaphoreGetFdInfoKHR* pGetFdInfo;
14631 int* pFd;
14632 // Begin global wrapped dispatchable handle unboxing for device;
14633 uint64_t cgen_var_0;
14634 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14635 *readStreamPtrPtr += 1 * 8;
14636 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
14637 vkReadStream->alloc((void**)&pGetFdInfo, sizeof(const VkSemaphoreGetFdInfoKHR));
14638 reservedunmarshal_VkSemaphoreGetFdInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14639 (VkSemaphoreGetFdInfoKHR*)(pGetFdInfo),
14640 readStreamPtrPtr);
14641 // Begin manual dispatchable handle unboxing for pFd;
14642 vkReadStream->unsetHandleMapping();
14643 vkReadStream->alloc((void**)&pFd, sizeof(int));
14644 memcpy((int*)pFd, *readStreamPtrPtr, sizeof(int));
14645 *readStreamPtrPtr += sizeof(int);
14646 if (pGetFdInfo) {
14647 transform_tohost_VkSemaphoreGetFdInfoKHR(
14648 m_state, (VkSemaphoreGetFdInfoKHR*)(pGetFdInfo));
14649 }
14650 if (m_logCalls) {
14651 fprintf(stderr, "stream %p: call vkGetSemaphoreFdKHR 0x%llx 0x%llx 0x%llx \n",
14652 ioStream, (unsigned long long)device, (unsigned long long)pGetFdInfo,
14653 (unsigned long long)pFd);
14654 }
14655 VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
14656 vkGetSemaphoreFdKHR_VkResult_return =
14657 m_state->on_vkGetSemaphoreFdKHR(&m_pool, device, pGetFdInfo, pFd);
14658 if ((vkGetSemaphoreFdKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
14659 m_state->on_DeviceLost();
14660 m_state->on_CheckOutOfMemory(vkGetSemaphoreFdKHR_VkResult_return, opcode, context);
14661 vkStream->unsetHandleMapping();
14662 vkStream->write((int*)pFd, sizeof(int));
14663 vkStream->write(&vkGetSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
14664 vkStream->commitWrite();
14665 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14666 (uintptr_t)snapshotTraceBegin);
14667 size_t snapshotTraceBytes = vkReadStream->endTrace();
14668 if (m_state->snapshotsEnabled()) {
14669 m_state->snapshot()->vkGetSemaphoreFdKHR(
14670 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
14671 vkGetSemaphoreFdKHR_VkResult_return, device, pGetFdInfo, pFd);
14672 }
14673 vkReadStream->clearPool();
14674 if (m_queueSubmitWithCommandsEnabled)
14675 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14676 break;
14677 }
14678 #endif
14679 #ifdef VK_KHR_descriptor_update_template
14680 case OP_vkCreateDescriptorUpdateTemplateKHR: {
14681 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14682 "VkDecoder vkCreateDescriptorUpdateTemplateKHR");
14683 VkDevice device;
14684 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo;
14685 const VkAllocationCallbacks* pAllocator;
14686 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate;
14687 // Begin global wrapped dispatchable handle unboxing for device;
14688 uint64_t cgen_var_0;
14689 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14690 *readStreamPtrPtr += 1 * 8;
14691 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
14692 vkReadStream->alloc((void**)&pCreateInfo,
14693 sizeof(const VkDescriptorUpdateTemplateCreateInfo));
14694 reservedunmarshal_VkDescriptorUpdateTemplateCreateInfo(
14695 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14696 (VkDescriptorUpdateTemplateCreateInfo*)(pCreateInfo), readStreamPtrPtr);
14697 // WARNING PTR CHECK
14698 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
14699 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
14700 *readStreamPtrPtr += 8;
14701 if (pAllocator) {
14702 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
14703 reservedunmarshal_VkAllocationCallbacks(
14704 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14705 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
14706 }
14707 // Begin manual dispatchable handle unboxing for pDescriptorUpdateTemplate;
14708 vkReadStream->unsetHandleMapping();
14709 vkReadStream->alloc((void**)&pDescriptorUpdateTemplate,
14710 sizeof(VkDescriptorUpdateTemplate));
14711 uint64_t cgen_var_2;
14712 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
14713 *readStreamPtrPtr += 8;
14714 *(VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate =
14715 (VkDescriptorUpdateTemplate)(VkDescriptorUpdateTemplate)((
14716 VkDescriptorUpdateTemplate)(*&cgen_var_2));
14717 if (pCreateInfo) {
14718 transform_tohost_VkDescriptorUpdateTemplateCreateInfo(
14719 m_state, (VkDescriptorUpdateTemplateCreateInfo*)(pCreateInfo));
14720 }
14721 if (pAllocator) {
14722 transform_tohost_VkAllocationCallbacks(m_state,
14723 (VkAllocationCallbacks*)(pAllocator));
14724 }
14725 if (m_logCalls) {
14726 fprintf(stderr,
14727 "stream %p: call vkCreateDescriptorUpdateTemplateKHR 0x%llx 0x%llx "
14728 "0x%llx 0x%llx \n",
14729 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
14730 (unsigned long long)pAllocator,
14731 (unsigned long long)pDescriptorUpdateTemplate);
14732 }
14733 VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
14734 vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
14735 m_state->on_vkCreateDescriptorUpdateTemplateKHR(
14736 &m_pool, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
14737 if ((vkCreateDescriptorUpdateTemplateKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
14738 m_state->on_DeviceLost();
14739 m_state->on_CheckOutOfMemory(vkCreateDescriptorUpdateTemplateKHR_VkResult_return,
14740 opcode, context);
14741 vkStream->unsetHandleMapping();
14742 // Begin manual non dispatchable handle create for pDescriptorUpdateTemplate;
14743 vkStream->unsetHandleMapping();
14744 uint64_t cgen_var_3;
14745 static_assert(
14746 8 == sizeof(VkDescriptorUpdateTemplate),
14747 "handle map overwrite requires VkDescriptorUpdateTemplate to be 8 bytes long");
14748 vkStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate(
14749 (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
14750 vkStream->write((VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 8 * 1);
14751 // Begin manual non dispatchable handle create for pDescriptorUpdateTemplate;
14752 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
14753 vkStream->write(&vkCreateDescriptorUpdateTemplateKHR_VkResult_return,
14754 sizeof(VkResult));
14755 vkStream->commitWrite();
14756 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14757 (uintptr_t)snapshotTraceBegin);
14758 size_t snapshotTraceBytes = vkReadStream->endTrace();
14759 if (m_state->snapshotsEnabled()) {
14760 m_state->snapshot()->vkCreateDescriptorUpdateTemplateKHR(
14761 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
14762 vkCreateDescriptorUpdateTemplateKHR_VkResult_return, device, pCreateInfo,
14763 pAllocator, pDescriptorUpdateTemplate);
14764 }
14765 vkReadStream->clearPool();
14766 if (m_queueSubmitWithCommandsEnabled)
14767 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14768 break;
14769 }
14770 case OP_vkDestroyDescriptorUpdateTemplateKHR: {
14771 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14772 "VkDecoder vkDestroyDescriptorUpdateTemplateKHR");
14773 VkDevice device;
14774 VkDescriptorUpdateTemplate descriptorUpdateTemplate;
14775 const VkAllocationCallbacks* pAllocator;
14776 // Begin global wrapped dispatchable handle unboxing for device;
14777 uint64_t cgen_var_0;
14778 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14779 *readStreamPtrPtr += 1 * 8;
14780 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
14781 // Begin manual non dispatchable handle destroy unboxing for
14782 // descriptorUpdateTemplate;
14783 VkDescriptorUpdateTemplate boxed_descriptorUpdateTemplate_preserve;
14784 uint64_t cgen_var_1;
14785 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
14786 *readStreamPtrPtr += 1 * 8;
14787 *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate =
14788 (VkDescriptorUpdateTemplate)(VkDescriptorUpdateTemplate)((
14789 VkDescriptorUpdateTemplate)(*&cgen_var_1));
14790 boxed_descriptorUpdateTemplate_preserve = descriptorUpdateTemplate;
14791 descriptorUpdateTemplate =
14792 try_unbox_VkDescriptorUpdateTemplate(descriptorUpdateTemplate);
14793 // WARNING PTR CHECK
14794 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
14795 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
14796 *readStreamPtrPtr += 8;
14797 if (pAllocator) {
14798 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
14799 reservedunmarshal_VkAllocationCallbacks(
14800 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14801 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
14802 }
14803 if (pAllocator) {
14804 transform_tohost_VkAllocationCallbacks(m_state,
14805 (VkAllocationCallbacks*)(pAllocator));
14806 }
14807 if (m_logCalls) {
14808 fprintf(stderr,
14809 "stream %p: call vkDestroyDescriptorUpdateTemplateKHR 0x%llx 0x%llx "
14810 "0x%llx \n",
14811 ioStream, (unsigned long long)device,
14812 (unsigned long long)descriptorUpdateTemplate,
14813 (unsigned long long)pAllocator);
14814 }
14815 m_state->on_vkDestroyDescriptorUpdateTemplateKHR(
14816 &m_pool, device, descriptorUpdateTemplate, pAllocator);
14817 vkStream->unsetHandleMapping();
14818 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14819 (uintptr_t)snapshotTraceBegin);
14820 size_t snapshotTraceBytes = vkReadStream->endTrace();
14821 if (m_state->snapshotsEnabled()) {
14822 m_state->snapshot()->vkDestroyDescriptorUpdateTemplateKHR(
14823 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
14824 boxed_descriptorUpdateTemplate_preserve, pAllocator);
14825 }
14826 delete_VkDescriptorUpdateTemplate(boxed_descriptorUpdateTemplate_preserve);
14827 vkReadStream->clearPool();
14828 if (m_queueSubmitWithCommandsEnabled)
14829 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14830 break;
14831 }
14832 case OP_vkUpdateDescriptorSetWithTemplateKHR: {
14833 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14834 "VkDecoder vkUpdateDescriptorSetWithTemplateKHR");
14835 VkDevice device;
14836 VkDescriptorSet descriptorSet;
14837 VkDescriptorUpdateTemplate descriptorUpdateTemplate;
14838 const void* pData;
14839 // Begin non wrapped dispatchable handle unboxing for device;
14840 uint64_t cgen_var_0;
14841 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14842 *readStreamPtrPtr += 1 * 8;
14843 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
14844 auto unboxed_device = unbox_VkDevice(device);
14845 auto vk = dispatch_VkDevice(device);
14846 // End manual dispatchable handle unboxing for device;
14847 uint64_t cgen_var_1;
14848 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
14849 *readStreamPtrPtr += 1 * 8;
14850 *(VkDescriptorSet*)&descriptorSet =
14851 (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)(*&cgen_var_1));
14852 uint64_t cgen_var_2;
14853 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
14854 *readStreamPtrPtr += 1 * 8;
14855 *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate =
14856 (VkDescriptorUpdateTemplate)unbox_VkDescriptorUpdateTemplate(
14857 (VkDescriptorUpdateTemplate)(*&cgen_var_2));
14858 // WARNING PTR CHECK
14859 memcpy((void**)&pData, (*readStreamPtrPtr), 8);
14860 android::base::Stream::fromBe64((uint8_t*)&pData);
14861 *readStreamPtrPtr += 8;
14862 if (pData) {
14863 vkReadStream->alloc((void**)&pData, sizeof(const uint8_t));
14864 memcpy((void*)pData, *readStreamPtrPtr, sizeof(const uint8_t));
14865 *readStreamPtrPtr += sizeof(const uint8_t);
14866 }
14867 if (m_logCalls) {
14868 fprintf(stderr,
14869 "stream %p: call vkUpdateDescriptorSetWithTemplateKHR 0x%llx 0x%llx "
14870 "0x%llx 0x%llx \n",
14871 ioStream, (unsigned long long)device, (unsigned long long)descriptorSet,
14872 (unsigned long long)descriptorUpdateTemplate,
14873 (unsigned long long)pData);
14874 }
14875 vk->vkUpdateDescriptorSetWithTemplateKHR(unboxed_device, descriptorSet,
14876 descriptorUpdateTemplate, pData);
14877 vkStream->unsetHandleMapping();
14878 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14879 (uintptr_t)snapshotTraceBegin);
14880 size_t snapshotTraceBytes = vkReadStream->endTrace();
14881 if (m_state->snapshotsEnabled()) {
14882 m_state->snapshot()->vkUpdateDescriptorSetWithTemplateKHR(
14883 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, descriptorSet,
14884 descriptorUpdateTemplate, pData);
14885 }
14886 vkReadStream->clearPool();
14887 if (m_queueSubmitWithCommandsEnabled)
14888 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14889 break;
14890 }
14891 #endif
14892 #ifdef VK_KHR_create_renderpass2
14893 case OP_vkCreateRenderPass2KHR: {
14894 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14895 "VkDecoder vkCreateRenderPass2KHR");
14896 VkDevice device;
14897 const VkRenderPassCreateInfo2* pCreateInfo;
14898 const VkAllocationCallbacks* pAllocator;
14899 VkRenderPass* pRenderPass;
14900 // Begin global wrapped dispatchable handle unboxing for device;
14901 uint64_t cgen_var_0;
14902 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14903 *readStreamPtrPtr += 1 * 8;
14904 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
14905 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkRenderPassCreateInfo2));
14906 reservedunmarshal_VkRenderPassCreateInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14907 (VkRenderPassCreateInfo2*)(pCreateInfo),
14908 readStreamPtrPtr);
14909 // WARNING PTR CHECK
14910 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
14911 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
14912 *readStreamPtrPtr += 8;
14913 if (pAllocator) {
14914 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
14915 reservedunmarshal_VkAllocationCallbacks(
14916 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14917 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
14918 }
14919 // Begin manual dispatchable handle unboxing for pRenderPass;
14920 vkReadStream->unsetHandleMapping();
14921 vkReadStream->alloc((void**)&pRenderPass, sizeof(VkRenderPass));
14922 uint64_t cgen_var_2;
14923 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
14924 *readStreamPtrPtr += 8;
14925 *(VkRenderPass*)pRenderPass =
14926 (VkRenderPass)(VkRenderPass)((VkRenderPass)(*&cgen_var_2));
14927 if (pCreateInfo) {
14928 transform_tohost_VkRenderPassCreateInfo2(
14929 m_state, (VkRenderPassCreateInfo2*)(pCreateInfo));
14930 }
14931 if (pAllocator) {
14932 transform_tohost_VkAllocationCallbacks(m_state,
14933 (VkAllocationCallbacks*)(pAllocator));
14934 }
14935 if (m_logCalls) {
14936 fprintf(stderr,
14937 "stream %p: call vkCreateRenderPass2KHR 0x%llx 0x%llx 0x%llx 0x%llx \n",
14938 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
14939 (unsigned long long)pAllocator, (unsigned long long)pRenderPass);
14940 }
14941 VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
14942 vkCreateRenderPass2KHR_VkResult_return = m_state->on_vkCreateRenderPass2KHR(
14943 &m_pool, device, pCreateInfo, pAllocator, pRenderPass);
14944 if ((vkCreateRenderPass2KHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
14945 m_state->on_DeviceLost();
14946 m_state->on_CheckOutOfMemory(vkCreateRenderPass2KHR_VkResult_return, opcode,
14947 context);
14948 vkStream->unsetHandleMapping();
14949 // Begin manual non dispatchable handle create for pRenderPass;
14950 vkStream->unsetHandleMapping();
14951 uint64_t cgen_var_3;
14952 static_assert(8 == sizeof(VkRenderPass),
14953 "handle map overwrite requires VkRenderPass to be 8 bytes long");
14954 vkStream->handleMapping()->mapHandles_VkRenderPass((VkRenderPass*)pRenderPass, 1);
14955 vkStream->write((VkRenderPass*)pRenderPass, 8 * 1);
14956 // Begin manual non dispatchable handle create for pRenderPass;
14957 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
14958 vkStream->write(&vkCreateRenderPass2KHR_VkResult_return, sizeof(VkResult));
14959 vkStream->commitWrite();
14960 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
14961 (uintptr_t)snapshotTraceBegin);
14962 size_t snapshotTraceBytes = vkReadStream->endTrace();
14963 if (m_state->snapshotsEnabled()) {
14964 m_state->snapshot()->vkCreateRenderPass2KHR(
14965 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
14966 vkCreateRenderPass2KHR_VkResult_return, device, pCreateInfo, pAllocator,
14967 pRenderPass);
14968 }
14969 vkReadStream->clearPool();
14970 if (m_queueSubmitWithCommandsEnabled)
14971 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
14972 break;
14973 }
14974 case OP_vkCmdBeginRenderPass2KHR: {
14975 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
14976 "VkDecoder vkCmdBeginRenderPass2KHR");
14977 VkCommandBuffer commandBuffer;
14978 const VkRenderPassBeginInfo* pRenderPassBegin;
14979 const VkSubpassBeginInfo* pSubpassBeginInfo;
14980 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
14981 uint64_t cgen_var_0;
14982 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
14983 *readStreamPtrPtr += 1 * 8;
14984 *(VkCommandBuffer*)&commandBuffer =
14985 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
14986 vkReadStream->alloc((void**)&pRenderPassBegin, sizeof(const VkRenderPassBeginInfo));
14987 reservedunmarshal_VkRenderPassBeginInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14988 (VkRenderPassBeginInfo*)(pRenderPassBegin),
14989 readStreamPtrPtr);
14990 vkReadStream->alloc((void**)&pSubpassBeginInfo, sizeof(const VkSubpassBeginInfo));
14991 reservedunmarshal_VkSubpassBeginInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
14992 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
14993 readStreamPtrPtr);
14994 if (pRenderPassBegin) {
14995 transform_tohost_VkRenderPassBeginInfo(
14996 m_state, (VkRenderPassBeginInfo*)(pRenderPassBegin));
14997 }
14998 if (pSubpassBeginInfo) {
14999 transform_tohost_VkSubpassBeginInfo(m_state,
15000 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
15001 }
15002 if (m_logCalls) {
15003 fprintf(stderr,
15004 "stream %p: call vkCmdBeginRenderPass2KHR 0x%llx 0x%llx 0x%llx \n",
15005 ioStream, (unsigned long long)commandBuffer,
15006 (unsigned long long)pRenderPassBegin,
15007 (unsigned long long)pSubpassBeginInfo);
15008 }
15009 m_state->on_vkCmdBeginRenderPass2KHR(&m_pool, commandBuffer, pRenderPassBegin,
15010 pSubpassBeginInfo);
15011 vkStream->unsetHandleMapping();
15012 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15013 (uintptr_t)snapshotTraceBegin);
15014 size_t snapshotTraceBytes = vkReadStream->endTrace();
15015 if (m_state->snapshotsEnabled()) {
15016 m_state->snapshot()->vkCmdBeginRenderPass2KHR(
15017 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
15018 pRenderPassBegin, pSubpassBeginInfo);
15019 }
15020 vkReadStream->clearPool();
15021 if (m_queueSubmitWithCommandsEnabled)
15022 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15023 break;
15024 }
15025 case OP_vkCmdNextSubpass2KHR: {
15026 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15027 "VkDecoder vkCmdNextSubpass2KHR");
15028 VkCommandBuffer commandBuffer;
15029 const VkSubpassBeginInfo* pSubpassBeginInfo;
15030 const VkSubpassEndInfo* pSubpassEndInfo;
15031 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
15032 uint64_t cgen_var_0;
15033 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15034 *readStreamPtrPtr += 1 * 8;
15035 *(VkCommandBuffer*)&commandBuffer =
15036 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
15037 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
15038 auto vk = dispatch_VkCommandBuffer(commandBuffer);
15039 // End manual dispatchable handle unboxing for commandBuffer;
15040 vkReadStream->alloc((void**)&pSubpassBeginInfo, sizeof(const VkSubpassBeginInfo));
15041 reservedunmarshal_VkSubpassBeginInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15042 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
15043 readStreamPtrPtr);
15044 vkReadStream->alloc((void**)&pSubpassEndInfo, sizeof(const VkSubpassEndInfo));
15045 reservedunmarshal_VkSubpassEndInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15046 (VkSubpassEndInfo*)(pSubpassEndInfo),
15047 readStreamPtrPtr);
15048 if (pSubpassBeginInfo) {
15049 transform_tohost_VkSubpassBeginInfo(m_state,
15050 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
15051 }
15052 if (pSubpassEndInfo) {
15053 transform_tohost_VkSubpassEndInfo(m_state,
15054 (VkSubpassEndInfo*)(pSubpassEndInfo));
15055 }
15056 if (m_logCalls) {
15057 fprintf(stderr, "stream %p: call vkCmdNextSubpass2KHR 0x%llx 0x%llx 0x%llx \n",
15058 ioStream, (unsigned long long)commandBuffer,
15059 (unsigned long long)pSubpassBeginInfo,
15060 (unsigned long long)pSubpassEndInfo);
15061 }
15062 vk->vkCmdNextSubpass2KHR(unboxed_commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
15063 vkStream->unsetHandleMapping();
15064 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15065 (uintptr_t)snapshotTraceBegin);
15066 size_t snapshotTraceBytes = vkReadStream->endTrace();
15067 if (m_state->snapshotsEnabled()) {
15068 m_state->snapshot()->vkCmdNextSubpass2KHR(
15069 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
15070 pSubpassBeginInfo, pSubpassEndInfo);
15071 }
15072 vkReadStream->clearPool();
15073 if (m_queueSubmitWithCommandsEnabled)
15074 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15075 break;
15076 }
15077 case OP_vkCmdEndRenderPass2KHR: {
15078 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15079 "VkDecoder vkCmdEndRenderPass2KHR");
15080 VkCommandBuffer commandBuffer;
15081 const VkSubpassEndInfo* pSubpassEndInfo;
15082 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
15083 uint64_t cgen_var_0;
15084 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15085 *readStreamPtrPtr += 1 * 8;
15086 *(VkCommandBuffer*)&commandBuffer =
15087 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
15088 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
15089 auto vk = dispatch_VkCommandBuffer(commandBuffer);
15090 // End manual dispatchable handle unboxing for commandBuffer;
15091 vkReadStream->alloc((void**)&pSubpassEndInfo, sizeof(const VkSubpassEndInfo));
15092 reservedunmarshal_VkSubpassEndInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15093 (VkSubpassEndInfo*)(pSubpassEndInfo),
15094 readStreamPtrPtr);
15095 if (pSubpassEndInfo) {
15096 transform_tohost_VkSubpassEndInfo(m_state,
15097 (VkSubpassEndInfo*)(pSubpassEndInfo));
15098 }
15099 if (m_logCalls) {
15100 fprintf(stderr, "stream %p: call vkCmdEndRenderPass2KHR 0x%llx 0x%llx \n",
15101 ioStream, (unsigned long long)commandBuffer,
15102 (unsigned long long)pSubpassEndInfo);
15103 }
15104 vk->vkCmdEndRenderPass2KHR(unboxed_commandBuffer, pSubpassEndInfo);
15105 vkStream->unsetHandleMapping();
15106 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15107 (uintptr_t)snapshotTraceBegin);
15108 size_t snapshotTraceBytes = vkReadStream->endTrace();
15109 if (m_state->snapshotsEnabled()) {
15110 m_state->snapshot()->vkCmdEndRenderPass2KHR(snapshotTraceBegin,
15111 snapshotTraceBytes, &m_pool,
15112 commandBuffer, pSubpassEndInfo);
15113 }
15114 vkReadStream->clearPool();
15115 if (m_queueSubmitWithCommandsEnabled)
15116 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15117 break;
15118 }
15119 #endif
15120 #ifdef VK_KHR_external_fence_capabilities
15121 case OP_vkGetPhysicalDeviceExternalFencePropertiesKHR: {
15122 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15123 "VkDecoder vkGetPhysicalDeviceExternalFencePropertiesKHR");
15124 VkPhysicalDevice physicalDevice;
15125 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo;
15126 VkExternalFenceProperties* pExternalFenceProperties;
15127 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
15128 uint64_t cgen_var_0;
15129 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15130 *readStreamPtrPtr += 1 * 8;
15131 *(VkPhysicalDevice*)&physicalDevice =
15132 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
15133 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
15134 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
15135 // End manual dispatchable handle unboxing for physicalDevice;
15136 vkReadStream->alloc((void**)&pExternalFenceInfo,
15137 sizeof(const VkPhysicalDeviceExternalFenceInfo));
15138 reservedunmarshal_VkPhysicalDeviceExternalFenceInfo(
15139 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15140 (VkPhysicalDeviceExternalFenceInfo*)(pExternalFenceInfo), readStreamPtrPtr);
15141 // Begin manual dispatchable handle unboxing for pExternalFenceProperties;
15142 vkReadStream->unsetHandleMapping();
15143 vkReadStream->alloc((void**)&pExternalFenceProperties,
15144 sizeof(VkExternalFenceProperties));
15145 reservedunmarshal_VkExternalFenceProperties(
15146 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15147 (VkExternalFenceProperties*)(pExternalFenceProperties), readStreamPtrPtr);
15148 if (pExternalFenceInfo) {
15149 transform_tohost_VkPhysicalDeviceExternalFenceInfo(
15150 m_state, (VkPhysicalDeviceExternalFenceInfo*)(pExternalFenceInfo));
15151 }
15152 if (pExternalFenceProperties) {
15153 transform_tohost_VkExternalFenceProperties(
15154 m_state, (VkExternalFenceProperties*)(pExternalFenceProperties));
15155 }
15156 if (m_logCalls) {
15157 fprintf(stderr,
15158 "stream %p: call vkGetPhysicalDeviceExternalFencePropertiesKHR 0x%llx "
15159 "0x%llx 0x%llx \n",
15160 ioStream, (unsigned long long)physicalDevice,
15161 (unsigned long long)pExternalFenceInfo,
15162 (unsigned long long)pExternalFenceProperties);
15163 }
15164 vk->vkGetPhysicalDeviceExternalFencePropertiesKHR(
15165 unboxed_physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
15166 vkStream->unsetHandleMapping();
15167 if (pExternalFenceProperties) {
15168 transform_fromhost_VkExternalFenceProperties(
15169 m_state, (VkExternalFenceProperties*)(pExternalFenceProperties));
15170 }
15171 marshal_VkExternalFenceProperties(
15172 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15173 (VkExternalFenceProperties*)(pExternalFenceProperties));
15174 vkStream->commitWrite();
15175 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15176 (uintptr_t)snapshotTraceBegin);
15177 size_t snapshotTraceBytes = vkReadStream->endTrace();
15178 if (m_state->snapshotsEnabled()) {
15179 m_state->snapshot()->vkGetPhysicalDeviceExternalFencePropertiesKHR(
15180 snapshotTraceBegin, snapshotTraceBytes, &m_pool, physicalDevice,
15181 pExternalFenceInfo, pExternalFenceProperties);
15182 }
15183 vkReadStream->clearPool();
15184 if (m_queueSubmitWithCommandsEnabled)
15185 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15186 break;
15187 }
15188 #endif
15189 #ifdef VK_KHR_external_fence_fd
15190 case OP_vkImportFenceFdKHR: {
15191 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15192 "VkDecoder vkImportFenceFdKHR");
15193 VkDevice device;
15194 const VkImportFenceFdInfoKHR* pImportFenceFdInfo;
15195 // Begin non wrapped dispatchable handle unboxing for device;
15196 uint64_t cgen_var_0;
15197 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15198 *readStreamPtrPtr += 1 * 8;
15199 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15200 auto unboxed_device = unbox_VkDevice(device);
15201 auto vk = dispatch_VkDevice(device);
15202 // End manual dispatchable handle unboxing for device;
15203 vkReadStream->alloc((void**)&pImportFenceFdInfo,
15204 sizeof(const VkImportFenceFdInfoKHR));
15205 reservedunmarshal_VkImportFenceFdInfoKHR(
15206 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15207 (VkImportFenceFdInfoKHR*)(pImportFenceFdInfo), readStreamPtrPtr);
15208 if (pImportFenceFdInfo) {
15209 transform_tohost_VkImportFenceFdInfoKHR(
15210 m_state, (VkImportFenceFdInfoKHR*)(pImportFenceFdInfo));
15211 }
15212 if (m_logCalls) {
15213 fprintf(stderr, "stream %p: call vkImportFenceFdKHR 0x%llx 0x%llx \n", ioStream,
15214 (unsigned long long)device, (unsigned long long)pImportFenceFdInfo);
15215 }
15216 VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
15217 vkImportFenceFdKHR_VkResult_return =
15218 vk->vkImportFenceFdKHR(unboxed_device, pImportFenceFdInfo);
15219 if ((vkImportFenceFdKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
15220 m_state->on_DeviceLost();
15221 m_state->on_CheckOutOfMemory(vkImportFenceFdKHR_VkResult_return, opcode, context);
15222 vkStream->unsetHandleMapping();
15223 vkStream->write(&vkImportFenceFdKHR_VkResult_return, sizeof(VkResult));
15224 vkStream->commitWrite();
15225 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15226 (uintptr_t)snapshotTraceBegin);
15227 size_t snapshotTraceBytes = vkReadStream->endTrace();
15228 if (m_state->snapshotsEnabled()) {
15229 m_state->snapshot()->vkImportFenceFdKHR(
15230 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
15231 vkImportFenceFdKHR_VkResult_return, device, pImportFenceFdInfo);
15232 }
15233 vkReadStream->clearPool();
15234 if (m_queueSubmitWithCommandsEnabled)
15235 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15236 break;
15237 }
15238 case OP_vkGetFenceFdKHR: {
15239 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15240 "VkDecoder vkGetFenceFdKHR");
15241 VkDevice device;
15242 const VkFenceGetFdInfoKHR* pGetFdInfo;
15243 int* pFd;
15244 // Begin non wrapped dispatchable handle unboxing for device;
15245 uint64_t cgen_var_0;
15246 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15247 *readStreamPtrPtr += 1 * 8;
15248 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15249 auto unboxed_device = unbox_VkDevice(device);
15250 auto vk = dispatch_VkDevice(device);
15251 // End manual dispatchable handle unboxing for device;
15252 vkReadStream->alloc((void**)&pGetFdInfo, sizeof(const VkFenceGetFdInfoKHR));
15253 reservedunmarshal_VkFenceGetFdInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15254 (VkFenceGetFdInfoKHR*)(pGetFdInfo),
15255 readStreamPtrPtr);
15256 // Begin manual dispatchable handle unboxing for pFd;
15257 vkReadStream->unsetHandleMapping();
15258 vkReadStream->alloc((void**)&pFd, sizeof(int));
15259 memcpy((int*)pFd, *readStreamPtrPtr, sizeof(int));
15260 *readStreamPtrPtr += sizeof(int);
15261 if (pGetFdInfo) {
15262 transform_tohost_VkFenceGetFdInfoKHR(m_state,
15263 (VkFenceGetFdInfoKHR*)(pGetFdInfo));
15264 }
15265 if (m_logCalls) {
15266 fprintf(stderr, "stream %p: call vkGetFenceFdKHR 0x%llx 0x%llx 0x%llx \n",
15267 ioStream, (unsigned long long)device, (unsigned long long)pGetFdInfo,
15268 (unsigned long long)pFd);
15269 }
15270 VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
15271 vkGetFenceFdKHR_VkResult_return =
15272 vk->vkGetFenceFdKHR(unboxed_device, pGetFdInfo, pFd);
15273 if ((vkGetFenceFdKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
15274 m_state->on_DeviceLost();
15275 m_state->on_CheckOutOfMemory(vkGetFenceFdKHR_VkResult_return, opcode, context);
15276 vkStream->unsetHandleMapping();
15277 vkStream->write((int*)pFd, sizeof(int));
15278 vkStream->write(&vkGetFenceFdKHR_VkResult_return, sizeof(VkResult));
15279 vkStream->commitWrite();
15280 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15281 (uintptr_t)snapshotTraceBegin);
15282 size_t snapshotTraceBytes = vkReadStream->endTrace();
15283 if (m_state->snapshotsEnabled()) {
15284 m_state->snapshot()->vkGetFenceFdKHR(snapshotTraceBegin, snapshotTraceBytes,
15285 &m_pool, vkGetFenceFdKHR_VkResult_return,
15286 device, pGetFdInfo, pFd);
15287 }
15288 vkReadStream->clearPool();
15289 if (m_queueSubmitWithCommandsEnabled)
15290 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15291 break;
15292 }
15293 #endif
15294 #ifdef VK_KHR_get_memory_requirements2
15295 case OP_vkGetImageMemoryRequirements2KHR: {
15296 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15297 "VkDecoder vkGetImageMemoryRequirements2KHR");
15298 VkDevice device;
15299 const VkImageMemoryRequirementsInfo2* pInfo;
15300 VkMemoryRequirements2* pMemoryRequirements;
15301 // Begin global wrapped dispatchable handle unboxing for device;
15302 uint64_t cgen_var_0;
15303 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15304 *readStreamPtrPtr += 1 * 8;
15305 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15306 vkReadStream->alloc((void**)&pInfo, sizeof(const VkImageMemoryRequirementsInfo2));
15307 reservedunmarshal_VkImageMemoryRequirementsInfo2(
15308 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15309 (VkImageMemoryRequirementsInfo2*)(pInfo), readStreamPtrPtr);
15310 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
15311 vkReadStream->unsetHandleMapping();
15312 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
15313 reservedunmarshal_VkMemoryRequirements2(
15314 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15315 (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
15316 if (pInfo) {
15317 transform_tohost_VkImageMemoryRequirementsInfo2(
15318 m_state, (VkImageMemoryRequirementsInfo2*)(pInfo));
15319 }
15320 if (pMemoryRequirements) {
15321 transform_tohost_VkMemoryRequirements2(
15322 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
15323 }
15324 if (m_logCalls) {
15325 fprintf(
15326 stderr,
15327 "stream %p: call vkGetImageMemoryRequirements2KHR 0x%llx 0x%llx 0x%llx \n",
15328 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
15329 (unsigned long long)pMemoryRequirements);
15330 }
15331 m_state->on_vkGetImageMemoryRequirements2KHR(&m_pool, device, pInfo,
15332 pMemoryRequirements);
15333 vkStream->unsetHandleMapping();
15334 if (pMemoryRequirements) {
15335 transform_fromhost_VkMemoryRequirements2(
15336 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
15337 }
15338 marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15339 (VkMemoryRequirements2*)(pMemoryRequirements));
15340 vkStream->commitWrite();
15341 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15342 (uintptr_t)snapshotTraceBegin);
15343 size_t snapshotTraceBytes = vkReadStream->endTrace();
15344 if (m_state->snapshotsEnabled()) {
15345 m_state->snapshot()->vkGetImageMemoryRequirements2KHR(
15346 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
15347 pMemoryRequirements);
15348 }
15349 vkReadStream->clearPool();
15350 if (m_queueSubmitWithCommandsEnabled)
15351 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15352 break;
15353 }
15354 case OP_vkGetBufferMemoryRequirements2KHR: {
15355 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15356 "VkDecoder vkGetBufferMemoryRequirements2KHR");
15357 VkDevice device;
15358 const VkBufferMemoryRequirementsInfo2* pInfo;
15359 VkMemoryRequirements2* pMemoryRequirements;
15360 // Begin global wrapped dispatchable handle unboxing for device;
15361 uint64_t cgen_var_0;
15362 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15363 *readStreamPtrPtr += 1 * 8;
15364 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15365 vkReadStream->alloc((void**)&pInfo, sizeof(const VkBufferMemoryRequirementsInfo2));
15366 reservedunmarshal_VkBufferMemoryRequirementsInfo2(
15367 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15368 (VkBufferMemoryRequirementsInfo2*)(pInfo), readStreamPtrPtr);
15369 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
15370 vkReadStream->unsetHandleMapping();
15371 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
15372 reservedunmarshal_VkMemoryRequirements2(
15373 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15374 (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
15375 if (pInfo) {
15376 transform_tohost_VkBufferMemoryRequirementsInfo2(
15377 m_state, (VkBufferMemoryRequirementsInfo2*)(pInfo));
15378 }
15379 if (pMemoryRequirements) {
15380 transform_tohost_VkMemoryRequirements2(
15381 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
15382 }
15383 if (m_logCalls) {
15384 fprintf(
15385 stderr,
15386 "stream %p: call vkGetBufferMemoryRequirements2KHR 0x%llx 0x%llx 0x%llx \n",
15387 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
15388 (unsigned long long)pMemoryRequirements);
15389 }
15390 m_state->on_vkGetBufferMemoryRequirements2KHR(&m_pool, device, pInfo,
15391 pMemoryRequirements);
15392 vkStream->unsetHandleMapping();
15393 if (pMemoryRequirements) {
15394 transform_fromhost_VkMemoryRequirements2(
15395 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
15396 }
15397 marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15398 (VkMemoryRequirements2*)(pMemoryRequirements));
15399 vkStream->commitWrite();
15400 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15401 (uintptr_t)snapshotTraceBegin);
15402 size_t snapshotTraceBytes = vkReadStream->endTrace();
15403 if (m_state->snapshotsEnabled()) {
15404 m_state->snapshot()->vkGetBufferMemoryRequirements2KHR(
15405 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
15406 pMemoryRequirements);
15407 }
15408 vkReadStream->clearPool();
15409 if (m_queueSubmitWithCommandsEnabled)
15410 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15411 break;
15412 }
15413 case OP_vkGetImageSparseMemoryRequirements2KHR: {
15414 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15415 "VkDecoder vkGetImageSparseMemoryRequirements2KHR");
15416 VkDevice device;
15417 const VkImageSparseMemoryRequirementsInfo2* pInfo;
15418 uint32_t* pSparseMemoryRequirementCount;
15419 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements;
15420 // Begin non wrapped dispatchable handle unboxing for device;
15421 uint64_t cgen_var_0;
15422 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15423 *readStreamPtrPtr += 1 * 8;
15424 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15425 auto unboxed_device = unbox_VkDevice(device);
15426 auto vk = dispatch_VkDevice(device);
15427 // End manual dispatchable handle unboxing for device;
15428 vkReadStream->alloc((void**)&pInfo,
15429 sizeof(const VkImageSparseMemoryRequirementsInfo2));
15430 reservedunmarshal_VkImageSparseMemoryRequirementsInfo2(
15431 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15432 (VkImageSparseMemoryRequirementsInfo2*)(pInfo), readStreamPtrPtr);
15433 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirementCount;
15434 vkReadStream->unsetHandleMapping();
15435 // WARNING PTR CHECK
15436 memcpy((uint32_t**)&pSparseMemoryRequirementCount, (*readStreamPtrPtr), 8);
15437 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirementCount);
15438 *readStreamPtrPtr += 8;
15439 if (pSparseMemoryRequirementCount) {
15440 vkReadStream->alloc((void**)&pSparseMemoryRequirementCount, sizeof(uint32_t));
15441 memcpy((uint32_t*)pSparseMemoryRequirementCount, *readStreamPtrPtr,
15442 sizeof(uint32_t));
15443 *readStreamPtrPtr += sizeof(uint32_t);
15444 }
15445 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirements;
15446 vkReadStream->unsetHandleMapping();
15447 // WARNING PTR CHECK
15448 memcpy((VkSparseImageMemoryRequirements2**)&pSparseMemoryRequirements,
15449 (*readStreamPtrPtr), 8);
15450 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirements);
15451 *readStreamPtrPtr += 8;
15452 if (pSparseMemoryRequirements) {
15453 vkReadStream->alloc((void**)&pSparseMemoryRequirements,
15454 (*(pSparseMemoryRequirementCount)) *
15455 sizeof(VkSparseImageMemoryRequirements2));
15456 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
15457 reservedunmarshal_VkSparseImageMemoryRequirements2(
15458 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15459 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i),
15460 readStreamPtrPtr);
15461 }
15462 }
15463 if (pInfo) {
15464 transform_tohost_VkImageSparseMemoryRequirementsInfo2(
15465 m_state, (VkImageSparseMemoryRequirementsInfo2*)(pInfo));
15466 }
15467 if (pSparseMemoryRequirementCount) {
15468 if (pSparseMemoryRequirements) {
15469 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
15470 ++i) {
15471 transform_tohost_VkSparseImageMemoryRequirements2(
15472 m_state,
15473 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
15474 }
15475 }
15476 }
15477 if (m_logCalls) {
15478 fprintf(stderr,
15479 "stream %p: call vkGetImageSparseMemoryRequirements2KHR 0x%llx 0x%llx "
15480 "0x%llx 0x%llx \n",
15481 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
15482 (unsigned long long)pSparseMemoryRequirementCount,
15483 (unsigned long long)pSparseMemoryRequirements);
15484 }
15485 vk->vkGetImageSparseMemoryRequirements2KHR(unboxed_device, pInfo,
15486 pSparseMemoryRequirementCount,
15487 pSparseMemoryRequirements);
15488 vkStream->unsetHandleMapping();
15489 // WARNING PTR CHECK
15490 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
15491 vkStream->putBe64(cgen_var_3);
15492 if (pSparseMemoryRequirementCount) {
15493 vkStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
15494 }
15495 if (pSparseMemoryRequirementCount) {
15496 if (pSparseMemoryRequirements) {
15497 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
15498 ++i) {
15499 transform_fromhost_VkSparseImageMemoryRequirements2(
15500 m_state,
15501 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
15502 }
15503 }
15504 }
15505 // WARNING PTR CHECK
15506 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
15507 vkStream->putBe64(cgen_var_4);
15508 if (pSparseMemoryRequirements) {
15509 if (pSparseMemoryRequirementCount) {
15510 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
15511 ++i) {
15512 marshal_VkSparseImageMemoryRequirements2(
15513 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15514 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
15515 }
15516 }
15517 }
15518 vkStream->commitWrite();
15519 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15520 (uintptr_t)snapshotTraceBegin);
15521 size_t snapshotTraceBytes = vkReadStream->endTrace();
15522 if (m_state->snapshotsEnabled()) {
15523 m_state->snapshot()->vkGetImageSparseMemoryRequirements2KHR(
15524 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
15525 pSparseMemoryRequirementCount, pSparseMemoryRequirements);
15526 }
15527 vkReadStream->clearPool();
15528 if (m_queueSubmitWithCommandsEnabled)
15529 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15530 break;
15531 }
15532 #endif
15533 #ifdef VK_KHR_sampler_ycbcr_conversion
15534 case OP_vkCreateSamplerYcbcrConversionKHR: {
15535 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15536 "VkDecoder vkCreateSamplerYcbcrConversionKHR");
15537 VkDevice device;
15538 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo;
15539 const VkAllocationCallbacks* pAllocator;
15540 VkSamplerYcbcrConversion* pYcbcrConversion;
15541 // Begin global wrapped dispatchable handle unboxing for device;
15542 uint64_t cgen_var_0;
15543 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15544 *readStreamPtrPtr += 1 * 8;
15545 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15546 vkReadStream->alloc((void**)&pCreateInfo,
15547 sizeof(const VkSamplerYcbcrConversionCreateInfo));
15548 reservedunmarshal_VkSamplerYcbcrConversionCreateInfo(
15549 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15550 (VkSamplerYcbcrConversionCreateInfo*)(pCreateInfo), readStreamPtrPtr);
15551 // WARNING PTR CHECK
15552 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
15553 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
15554 *readStreamPtrPtr += 8;
15555 if (pAllocator) {
15556 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
15557 reservedunmarshal_VkAllocationCallbacks(
15558 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15559 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
15560 }
15561 // Begin manual dispatchable handle unboxing for pYcbcrConversion;
15562 vkReadStream->unsetHandleMapping();
15563 vkReadStream->alloc((void**)&pYcbcrConversion, sizeof(VkSamplerYcbcrConversion));
15564 uint64_t cgen_var_2;
15565 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
15566 *readStreamPtrPtr += 8;
15567 *(VkSamplerYcbcrConversion*)pYcbcrConversion =
15568 (VkSamplerYcbcrConversion)(VkSamplerYcbcrConversion)((
15569 VkSamplerYcbcrConversion)(*&cgen_var_2));
15570 if (pCreateInfo) {
15571 transform_tohost_VkSamplerYcbcrConversionCreateInfo(
15572 m_state, (VkSamplerYcbcrConversionCreateInfo*)(pCreateInfo));
15573 }
15574 if (pAllocator) {
15575 transform_tohost_VkAllocationCallbacks(m_state,
15576 (VkAllocationCallbacks*)(pAllocator));
15577 }
15578 if (m_logCalls) {
15579 fprintf(stderr,
15580 "stream %p: call vkCreateSamplerYcbcrConversionKHR 0x%llx 0x%llx "
15581 "0x%llx 0x%llx \n",
15582 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
15583 (unsigned long long)pAllocator, (unsigned long long)pYcbcrConversion);
15584 }
15585 VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
15586 vkCreateSamplerYcbcrConversionKHR_VkResult_return =
15587 m_state->on_vkCreateSamplerYcbcrConversionKHR(&m_pool, device, pCreateInfo,
15588 pAllocator, pYcbcrConversion);
15589 if ((vkCreateSamplerYcbcrConversionKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
15590 m_state->on_DeviceLost();
15591 m_state->on_CheckOutOfMemory(vkCreateSamplerYcbcrConversionKHR_VkResult_return,
15592 opcode, context);
15593 vkStream->unsetHandleMapping();
15594 // Begin manual non dispatchable handle create for pYcbcrConversion;
15595 vkStream->unsetHandleMapping();
15596 uint64_t cgen_var_3;
15597 static_assert(
15598 8 == sizeof(VkSamplerYcbcrConversion),
15599 "handle map overwrite requires VkSamplerYcbcrConversion to be 8 bytes long");
15600 vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion(
15601 (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
15602 vkStream->write((VkSamplerYcbcrConversion*)pYcbcrConversion, 8 * 1);
15603 // Begin manual non dispatchable handle create for pYcbcrConversion;
15604 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
15605 vkStream->write(&vkCreateSamplerYcbcrConversionKHR_VkResult_return,
15606 sizeof(VkResult));
15607 vkStream->commitWrite();
15608 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15609 (uintptr_t)snapshotTraceBegin);
15610 size_t snapshotTraceBytes = vkReadStream->endTrace();
15611 if (m_state->snapshotsEnabled()) {
15612 m_state->snapshot()->vkCreateSamplerYcbcrConversionKHR(
15613 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
15614 vkCreateSamplerYcbcrConversionKHR_VkResult_return, device, pCreateInfo,
15615 pAllocator, pYcbcrConversion);
15616 }
15617 vkReadStream->clearPool();
15618 if (m_queueSubmitWithCommandsEnabled)
15619 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15620 break;
15621 }
15622 case OP_vkDestroySamplerYcbcrConversionKHR: {
15623 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15624 "VkDecoder vkDestroySamplerYcbcrConversionKHR");
15625 VkDevice device;
15626 VkSamplerYcbcrConversion ycbcrConversion;
15627 const VkAllocationCallbacks* pAllocator;
15628 // Begin global wrapped dispatchable handle unboxing for device;
15629 uint64_t cgen_var_0;
15630 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15631 *readStreamPtrPtr += 1 * 8;
15632 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15633 // Begin manual non dispatchable handle destroy unboxing for ycbcrConversion;
15634 VkSamplerYcbcrConversion boxed_ycbcrConversion_preserve;
15635 uint64_t cgen_var_1;
15636 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
15637 *readStreamPtrPtr += 1 * 8;
15638 *(VkSamplerYcbcrConversion*)&ycbcrConversion =
15639 (VkSamplerYcbcrConversion)(VkSamplerYcbcrConversion)((
15640 VkSamplerYcbcrConversion)(*&cgen_var_1));
15641 boxed_ycbcrConversion_preserve = ycbcrConversion;
15642 ycbcrConversion = try_unbox_VkSamplerYcbcrConversion(ycbcrConversion);
15643 // WARNING PTR CHECK
15644 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
15645 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
15646 *readStreamPtrPtr += 8;
15647 if (pAllocator) {
15648 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
15649 reservedunmarshal_VkAllocationCallbacks(
15650 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15651 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
15652 }
15653 if (pAllocator) {
15654 transform_tohost_VkAllocationCallbacks(m_state,
15655 (VkAllocationCallbacks*)(pAllocator));
15656 }
15657 if (m_logCalls) {
15658 fprintf(stderr,
15659 "stream %p: call vkDestroySamplerYcbcrConversionKHR 0x%llx 0x%llx "
15660 "0x%llx \n",
15661 ioStream, (unsigned long long)device,
15662 (unsigned long long)ycbcrConversion, (unsigned long long)pAllocator);
15663 }
15664 m_state->on_vkDestroySamplerYcbcrConversionKHR(&m_pool, device, ycbcrConversion,
15665 pAllocator);
15666 vkStream->unsetHandleMapping();
15667 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15668 (uintptr_t)snapshotTraceBegin);
15669 size_t snapshotTraceBytes = vkReadStream->endTrace();
15670 if (m_state->snapshotsEnabled()) {
15671 m_state->snapshot()->vkDestroySamplerYcbcrConversionKHR(
15672 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device,
15673 boxed_ycbcrConversion_preserve, pAllocator);
15674 }
15675 delete_VkSamplerYcbcrConversion(boxed_ycbcrConversion_preserve);
15676 vkReadStream->clearPool();
15677 if (m_queueSubmitWithCommandsEnabled)
15678 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15679 break;
15680 }
15681 #endif
15682 #ifdef VK_KHR_bind_memory2
15683 case OP_vkBindBufferMemory2KHR: {
15684 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15685 "VkDecoder vkBindBufferMemory2KHR");
15686 VkDevice device;
15687 uint32_t bindInfoCount;
15688 const VkBindBufferMemoryInfo* pBindInfos;
15689 // Begin global wrapped dispatchable handle unboxing for device;
15690 uint64_t cgen_var_0;
15691 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15692 *readStreamPtrPtr += 1 * 8;
15693 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15694 memcpy((uint32_t*)&bindInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
15695 *readStreamPtrPtr += sizeof(uint32_t);
15696 vkReadStream->alloc((void**)&pBindInfos,
15697 ((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
15698 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
15699 reservedunmarshal_VkBindBufferMemoryInfo(
15700 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15701 (VkBindBufferMemoryInfo*)(pBindInfos + i), readStreamPtrPtr);
15702 }
15703 if (pBindInfos) {
15704 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
15705 transform_tohost_VkBindBufferMemoryInfo(
15706 m_state, (VkBindBufferMemoryInfo*)(pBindInfos + i));
15707 }
15708 }
15709 if (m_logCalls) {
15710 fprintf(stderr,
15711 "stream %p: call vkBindBufferMemory2KHR 0x%llx 0x%llx 0x%llx \n",
15712 ioStream, (unsigned long long)device, (unsigned long long)bindInfoCount,
15713 (unsigned long long)pBindInfos);
15714 }
15715 VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
15716 vkBindBufferMemory2KHR_VkResult_return =
15717 m_state->on_vkBindBufferMemory2KHR(&m_pool, device, bindInfoCount, pBindInfos);
15718 if ((vkBindBufferMemory2KHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
15719 m_state->on_DeviceLost();
15720 m_state->on_CheckOutOfMemory(vkBindBufferMemory2KHR_VkResult_return, opcode,
15721 context);
15722 vkStream->unsetHandleMapping();
15723 vkStream->write(&vkBindBufferMemory2KHR_VkResult_return, sizeof(VkResult));
15724 vkStream->commitWrite();
15725 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15726 (uintptr_t)snapshotTraceBegin);
15727 size_t snapshotTraceBytes = vkReadStream->endTrace();
15728 if (m_state->snapshotsEnabled()) {
15729 m_state->snapshot()->vkBindBufferMemory2KHR(
15730 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
15731 vkBindBufferMemory2KHR_VkResult_return, device, bindInfoCount, pBindInfos);
15732 }
15733 vkReadStream->clearPool();
15734 if (m_queueSubmitWithCommandsEnabled)
15735 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15736 break;
15737 }
15738 case OP_vkBindImageMemory2KHR: {
15739 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15740 "VkDecoder vkBindImageMemory2KHR");
15741 VkDevice device;
15742 uint32_t bindInfoCount;
15743 const VkBindImageMemoryInfo* pBindInfos;
15744 // Begin global wrapped dispatchable handle unboxing for device;
15745 uint64_t cgen_var_0;
15746 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15747 *readStreamPtrPtr += 1 * 8;
15748 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15749 memcpy((uint32_t*)&bindInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
15750 *readStreamPtrPtr += sizeof(uint32_t);
15751 vkReadStream->alloc((void**)&pBindInfos,
15752 ((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
15753 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
15754 reservedunmarshal_VkBindImageMemoryInfo(
15755 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15756 (VkBindImageMemoryInfo*)(pBindInfos + i), readStreamPtrPtr);
15757 }
15758 if (pBindInfos) {
15759 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
15760 transform_tohost_VkBindImageMemoryInfo(
15761 m_state, (VkBindImageMemoryInfo*)(pBindInfos + i));
15762 }
15763 }
15764 if (m_logCalls) {
15765 fprintf(stderr, "stream %p: call vkBindImageMemory2KHR 0x%llx 0x%llx 0x%llx \n",
15766 ioStream, (unsigned long long)device, (unsigned long long)bindInfoCount,
15767 (unsigned long long)pBindInfos);
15768 }
15769 VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
15770 vkBindImageMemory2KHR_VkResult_return =
15771 m_state->on_vkBindImageMemory2KHR(&m_pool, device, bindInfoCount, pBindInfos);
15772 if ((vkBindImageMemory2KHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
15773 m_state->on_DeviceLost();
15774 m_state->on_CheckOutOfMemory(vkBindImageMemory2KHR_VkResult_return, opcode,
15775 context);
15776 vkStream->unsetHandleMapping();
15777 vkStream->write(&vkBindImageMemory2KHR_VkResult_return, sizeof(VkResult));
15778 vkStream->commitWrite();
15779 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15780 (uintptr_t)snapshotTraceBegin);
15781 size_t snapshotTraceBytes = vkReadStream->endTrace();
15782 if (m_state->snapshotsEnabled()) {
15783 m_state->snapshot()->vkBindImageMemory2KHR(
15784 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
15785 vkBindImageMemory2KHR_VkResult_return, device, bindInfoCount, pBindInfos);
15786 }
15787 vkReadStream->clearPool();
15788 if (m_queueSubmitWithCommandsEnabled)
15789 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15790 break;
15791 }
15792 #endif
15793 #ifdef VK_KHR_maintenance3
15794 case OP_vkGetDescriptorSetLayoutSupportKHR: {
15795 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15796 "VkDecoder vkGetDescriptorSetLayoutSupportKHR");
15797 VkDevice device;
15798 const VkDescriptorSetLayoutCreateInfo* pCreateInfo;
15799 VkDescriptorSetLayoutSupport* pSupport;
15800 // Begin non wrapped dispatchable handle unboxing for device;
15801 uint64_t cgen_var_0;
15802 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15803 *readStreamPtrPtr += 1 * 8;
15804 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15805 auto unboxed_device = unbox_VkDevice(device);
15806 auto vk = dispatch_VkDevice(device);
15807 // End manual dispatchable handle unboxing for device;
15808 vkReadStream->alloc((void**)&pCreateInfo,
15809 sizeof(const VkDescriptorSetLayoutCreateInfo));
15810 reservedunmarshal_VkDescriptorSetLayoutCreateInfo(
15811 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15812 (VkDescriptorSetLayoutCreateInfo*)(pCreateInfo), readStreamPtrPtr);
15813 // Begin manual dispatchable handle unboxing for pSupport;
15814 vkReadStream->unsetHandleMapping();
15815 vkReadStream->alloc((void**)&pSupport, sizeof(VkDescriptorSetLayoutSupport));
15816 reservedunmarshal_VkDescriptorSetLayoutSupport(
15817 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15818 (VkDescriptorSetLayoutSupport*)(pSupport), readStreamPtrPtr);
15819 if (pCreateInfo) {
15820 transform_tohost_VkDescriptorSetLayoutCreateInfo(
15821 m_state, (VkDescriptorSetLayoutCreateInfo*)(pCreateInfo));
15822 }
15823 if (pSupport) {
15824 transform_tohost_VkDescriptorSetLayoutSupport(
15825 m_state, (VkDescriptorSetLayoutSupport*)(pSupport));
15826 }
15827 if (m_logCalls) {
15828 fprintf(stderr,
15829 "stream %p: call vkGetDescriptorSetLayoutSupportKHR 0x%llx 0x%llx "
15830 "0x%llx \n",
15831 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
15832 (unsigned long long)pSupport);
15833 }
15834 vk->vkGetDescriptorSetLayoutSupportKHR(unboxed_device, pCreateInfo, pSupport);
15835 vkStream->unsetHandleMapping();
15836 if (pSupport) {
15837 transform_fromhost_VkDescriptorSetLayoutSupport(
15838 m_state, (VkDescriptorSetLayoutSupport*)(pSupport));
15839 }
15840 marshal_VkDescriptorSetLayoutSupport(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15841 (VkDescriptorSetLayoutSupport*)(pSupport));
15842 vkStream->commitWrite();
15843 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15844 (uintptr_t)snapshotTraceBegin);
15845 size_t snapshotTraceBytes = vkReadStream->endTrace();
15846 if (m_state->snapshotsEnabled()) {
15847 m_state->snapshot()->vkGetDescriptorSetLayoutSupportKHR(
15848 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pCreateInfo,
15849 pSupport);
15850 }
15851 vkReadStream->clearPool();
15852 if (m_queueSubmitWithCommandsEnabled)
15853 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15854 break;
15855 }
15856 #endif
15857 #ifdef VK_KHR_buffer_device_address
15858 case OP_vkGetBufferDeviceAddressKHR: {
15859 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15860 "VkDecoder vkGetBufferDeviceAddressKHR");
15861 VkDevice device;
15862 const VkBufferDeviceAddressInfo* pInfo;
15863 // Begin non wrapped dispatchable handle unboxing for device;
15864 uint64_t cgen_var_0;
15865 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15866 *readStreamPtrPtr += 1 * 8;
15867 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15868 auto unboxed_device = unbox_VkDevice(device);
15869 auto vk = dispatch_VkDevice(device);
15870 // End manual dispatchable handle unboxing for device;
15871 vkReadStream->alloc((void**)&pInfo, sizeof(const VkBufferDeviceAddressInfo));
15872 reservedunmarshal_VkBufferDeviceAddressInfo(
15873 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(pInfo),
15874 readStreamPtrPtr);
15875 if (pInfo) {
15876 transform_tohost_VkBufferDeviceAddressInfo(m_state,
15877 (VkBufferDeviceAddressInfo*)(pInfo));
15878 }
15879 if (m_logCalls) {
15880 fprintf(stderr, "stream %p: call vkGetBufferDeviceAddressKHR 0x%llx 0x%llx \n",
15881 ioStream, (unsigned long long)device, (unsigned long long)pInfo);
15882 }
15883 VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
15884 (VkDeviceAddress)0;
15885 vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
15886 vk->vkGetBufferDeviceAddressKHR(unboxed_device, pInfo);
15887 vkStream->unsetHandleMapping();
15888 vkStream->write(&vkGetBufferDeviceAddressKHR_VkDeviceAddress_return,
15889 sizeof(VkDeviceAddress));
15890 vkStream->commitWrite();
15891 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15892 (uintptr_t)snapshotTraceBegin);
15893 size_t snapshotTraceBytes = vkReadStream->endTrace();
15894 if (m_state->snapshotsEnabled()) {
15895 m_state->snapshot()->vkGetBufferDeviceAddressKHR(
15896 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
15897 vkGetBufferDeviceAddressKHR_VkDeviceAddress_return, device, pInfo);
15898 }
15899 vkReadStream->clearPool();
15900 if (m_queueSubmitWithCommandsEnabled)
15901 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15902 break;
15903 }
15904 case OP_vkGetBufferOpaqueCaptureAddressKHR: {
15905 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15906 "VkDecoder vkGetBufferOpaqueCaptureAddressKHR");
15907 VkDevice device;
15908 const VkBufferDeviceAddressInfo* pInfo;
15909 // Begin non wrapped dispatchable handle unboxing for device;
15910 uint64_t cgen_var_0;
15911 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15912 *readStreamPtrPtr += 1 * 8;
15913 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15914 auto unboxed_device = unbox_VkDevice(device);
15915 auto vk = dispatch_VkDevice(device);
15916 // End manual dispatchable handle unboxing for device;
15917 vkReadStream->alloc((void**)&pInfo, sizeof(const VkBufferDeviceAddressInfo));
15918 reservedunmarshal_VkBufferDeviceAddressInfo(
15919 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(pInfo),
15920 readStreamPtrPtr);
15921 if (pInfo) {
15922 transform_tohost_VkBufferDeviceAddressInfo(m_state,
15923 (VkBufferDeviceAddressInfo*)(pInfo));
15924 }
15925 if (m_logCalls) {
15926 fprintf(stderr,
15927 "stream %p: call vkGetBufferOpaqueCaptureAddressKHR 0x%llx 0x%llx \n",
15928 ioStream, (unsigned long long)device, (unsigned long long)pInfo);
15929 }
15930 uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
15931 vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
15932 vk->vkGetBufferOpaqueCaptureAddressKHR(unboxed_device, pInfo);
15933 vkStream->unsetHandleMapping();
15934 vkStream->write(&vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return,
15935 sizeof(uint64_t));
15936 vkStream->commitWrite();
15937 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15938 (uintptr_t)snapshotTraceBegin);
15939 size_t snapshotTraceBytes = vkReadStream->endTrace();
15940 if (m_state->snapshotsEnabled()) {
15941 m_state->snapshot()->vkGetBufferOpaqueCaptureAddressKHR(
15942 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
15943 vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return, device, pInfo);
15944 }
15945 vkReadStream->clearPool();
15946 if (m_queueSubmitWithCommandsEnabled)
15947 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15948 break;
15949 }
15950 case OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR: {
15951 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
15952 "VkDecoder vkGetDeviceMemoryOpaqueCaptureAddressKHR");
15953 VkDevice device;
15954 const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo;
15955 // Begin non wrapped dispatchable handle unboxing for device;
15956 uint64_t cgen_var_0;
15957 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
15958 *readStreamPtrPtr += 1 * 8;
15959 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
15960 auto unboxed_device = unbox_VkDevice(device);
15961 auto vk = dispatch_VkDevice(device);
15962 // End manual dispatchable handle unboxing for device;
15963 vkReadStream->alloc((void**)&pInfo,
15964 sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo));
15965 reservedunmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
15966 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
15967 (VkDeviceMemoryOpaqueCaptureAddressInfo*)(pInfo), readStreamPtrPtr);
15968 if (pInfo) {
15969 transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo(
15970 m_state, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(pInfo));
15971 }
15972 if (m_logCalls) {
15973 fprintf(
15974 stderr,
15975 "stream %p: call vkGetDeviceMemoryOpaqueCaptureAddressKHR 0x%llx 0x%llx \n",
15976 ioStream, (unsigned long long)device, (unsigned long long)pInfo);
15977 }
15978 uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
15979 vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
15980 vk->vkGetDeviceMemoryOpaqueCaptureAddressKHR(unboxed_device, pInfo);
15981 vkStream->unsetHandleMapping();
15982 vkStream->write(&vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return,
15983 sizeof(uint64_t));
15984 vkStream->commitWrite();
15985 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
15986 (uintptr_t)snapshotTraceBegin);
15987 size_t snapshotTraceBytes = vkReadStream->endTrace();
15988 if (m_state->snapshotsEnabled()) {
15989 m_state->snapshot()->vkGetDeviceMemoryOpaqueCaptureAddressKHR(
15990 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
15991 vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return, device, pInfo);
15992 }
15993 vkReadStream->clearPool();
15994 if (m_queueSubmitWithCommandsEnabled)
15995 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
15996 break;
15997 }
15998 #endif
15999 #ifdef VK_KHR_pipeline_executable_properties
16000 case OP_vkGetPipelineExecutablePropertiesKHR: {
16001 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16002 "VkDecoder vkGetPipelineExecutablePropertiesKHR");
16003 VkDevice device;
16004 const VkPipelineInfoKHR* pPipelineInfo;
16005 uint32_t* pExecutableCount;
16006 VkPipelineExecutablePropertiesKHR* pProperties;
16007 // Begin non wrapped dispatchable handle unboxing for device;
16008 uint64_t cgen_var_0;
16009 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16010 *readStreamPtrPtr += 1 * 8;
16011 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
16012 auto unboxed_device = unbox_VkDevice(device);
16013 auto vk = dispatch_VkDevice(device);
16014 // End manual dispatchable handle unboxing for device;
16015 vkReadStream->alloc((void**)&pPipelineInfo, sizeof(const VkPipelineInfoKHR));
16016 reservedunmarshal_VkPipelineInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16017 (VkPipelineInfoKHR*)(pPipelineInfo),
16018 readStreamPtrPtr);
16019 // Begin manual dispatchable handle unboxing for pExecutableCount;
16020 vkReadStream->unsetHandleMapping();
16021 // WARNING PTR CHECK
16022 memcpy((uint32_t**)&pExecutableCount, (*readStreamPtrPtr), 8);
16023 android::base::Stream::fromBe64((uint8_t*)&pExecutableCount);
16024 *readStreamPtrPtr += 8;
16025 if (pExecutableCount) {
16026 vkReadStream->alloc((void**)&pExecutableCount, sizeof(uint32_t));
16027 memcpy((uint32_t*)pExecutableCount, *readStreamPtrPtr, sizeof(uint32_t));
16028 *readStreamPtrPtr += sizeof(uint32_t);
16029 }
16030 // Begin manual dispatchable handle unboxing for pProperties;
16031 vkReadStream->unsetHandleMapping();
16032 // WARNING PTR CHECK
16033 memcpy((VkPipelineExecutablePropertiesKHR**)&pProperties, (*readStreamPtrPtr), 8);
16034 android::base::Stream::fromBe64((uint8_t*)&pProperties);
16035 *readStreamPtrPtr += 8;
16036 if (pProperties) {
16037 vkReadStream->alloc(
16038 (void**)&pProperties,
16039 (*(pExecutableCount)) * sizeof(VkPipelineExecutablePropertiesKHR));
16040 for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i) {
16041 reservedunmarshal_VkPipelineExecutablePropertiesKHR(
16042 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16043 (VkPipelineExecutablePropertiesKHR*)(pProperties + i),
16044 readStreamPtrPtr);
16045 }
16046 }
16047 if (pPipelineInfo) {
16048 transform_tohost_VkPipelineInfoKHR(m_state,
16049 (VkPipelineInfoKHR*)(pPipelineInfo));
16050 }
16051 if (pExecutableCount) {
16052 if (pProperties) {
16053 for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i) {
16054 transform_tohost_VkPipelineExecutablePropertiesKHR(
16055 m_state, (VkPipelineExecutablePropertiesKHR*)(pProperties + i));
16056 }
16057 }
16058 }
16059 if (m_logCalls) {
16060 fprintf(stderr,
16061 "stream %p: call vkGetPipelineExecutablePropertiesKHR 0x%llx 0x%llx "
16062 "0x%llx 0x%llx \n",
16063 ioStream, (unsigned long long)device, (unsigned long long)pPipelineInfo,
16064 (unsigned long long)pExecutableCount, (unsigned long long)pProperties);
16065 }
16066 VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
16067 vkGetPipelineExecutablePropertiesKHR_VkResult_return =
16068 vk->vkGetPipelineExecutablePropertiesKHR(unboxed_device, pPipelineInfo,
16069 pExecutableCount, pProperties);
16070 if ((vkGetPipelineExecutablePropertiesKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
16071 m_state->on_DeviceLost();
16072 m_state->on_CheckOutOfMemory(vkGetPipelineExecutablePropertiesKHR_VkResult_return,
16073 opcode, context);
16074 vkStream->unsetHandleMapping();
16075 // WARNING PTR CHECK
16076 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pExecutableCount;
16077 vkStream->putBe64(cgen_var_3);
16078 if (pExecutableCount) {
16079 vkStream->write((uint32_t*)pExecutableCount, sizeof(uint32_t));
16080 }
16081 if (pExecutableCount) {
16082 if (pProperties) {
16083 for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i) {
16084 transform_fromhost_VkPipelineExecutablePropertiesKHR(
16085 m_state, (VkPipelineExecutablePropertiesKHR*)(pProperties + i));
16086 }
16087 }
16088 }
16089 // WARNING PTR CHECK
16090 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pProperties;
16091 vkStream->putBe64(cgen_var_4);
16092 if (pProperties) {
16093 if (pExecutableCount) {
16094 for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i) {
16095 marshal_VkPipelineExecutablePropertiesKHR(
16096 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16097 (VkPipelineExecutablePropertiesKHR*)(pProperties + i));
16098 }
16099 }
16100 }
16101 vkStream->write(&vkGetPipelineExecutablePropertiesKHR_VkResult_return,
16102 sizeof(VkResult));
16103 vkStream->commitWrite();
16104 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16105 (uintptr_t)snapshotTraceBegin);
16106 size_t snapshotTraceBytes = vkReadStream->endTrace();
16107 if (m_state->snapshotsEnabled()) {
16108 m_state->snapshot()->vkGetPipelineExecutablePropertiesKHR(
16109 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
16110 vkGetPipelineExecutablePropertiesKHR_VkResult_return, device, pPipelineInfo,
16111 pExecutableCount, pProperties);
16112 }
16113 vkReadStream->clearPool();
16114 if (m_queueSubmitWithCommandsEnabled)
16115 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16116 break;
16117 }
16118 case OP_vkGetPipelineExecutableStatisticsKHR: {
16119 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16120 "VkDecoder vkGetPipelineExecutableStatisticsKHR");
16121 VkDevice device;
16122 const VkPipelineExecutableInfoKHR* pExecutableInfo;
16123 uint32_t* pStatisticCount;
16124 VkPipelineExecutableStatisticKHR* pStatistics;
16125 // Begin non wrapped dispatchable handle unboxing for device;
16126 uint64_t cgen_var_0;
16127 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16128 *readStreamPtrPtr += 1 * 8;
16129 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
16130 auto unboxed_device = unbox_VkDevice(device);
16131 auto vk = dispatch_VkDevice(device);
16132 // End manual dispatchable handle unboxing for device;
16133 vkReadStream->alloc((void**)&pExecutableInfo,
16134 sizeof(const VkPipelineExecutableInfoKHR));
16135 reservedunmarshal_VkPipelineExecutableInfoKHR(
16136 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16137 (VkPipelineExecutableInfoKHR*)(pExecutableInfo), readStreamPtrPtr);
16138 // Begin manual dispatchable handle unboxing for pStatisticCount;
16139 vkReadStream->unsetHandleMapping();
16140 // WARNING PTR CHECK
16141 memcpy((uint32_t**)&pStatisticCount, (*readStreamPtrPtr), 8);
16142 android::base::Stream::fromBe64((uint8_t*)&pStatisticCount);
16143 *readStreamPtrPtr += 8;
16144 if (pStatisticCount) {
16145 vkReadStream->alloc((void**)&pStatisticCount, sizeof(uint32_t));
16146 memcpy((uint32_t*)pStatisticCount, *readStreamPtrPtr, sizeof(uint32_t));
16147 *readStreamPtrPtr += sizeof(uint32_t);
16148 }
16149 // Begin manual dispatchable handle unboxing for pStatistics;
16150 vkReadStream->unsetHandleMapping();
16151 // WARNING PTR CHECK
16152 memcpy((VkPipelineExecutableStatisticKHR**)&pStatistics, (*readStreamPtrPtr), 8);
16153 android::base::Stream::fromBe64((uint8_t*)&pStatistics);
16154 *readStreamPtrPtr += 8;
16155 if (pStatistics) {
16156 vkReadStream->alloc(
16157 (void**)&pStatistics,
16158 (*(pStatisticCount)) * sizeof(VkPipelineExecutableStatisticKHR));
16159 for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i) {
16160 reservedunmarshal_VkPipelineExecutableStatisticKHR(
16161 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16162 (VkPipelineExecutableStatisticKHR*)(pStatistics + i), readStreamPtrPtr);
16163 }
16164 }
16165 if (pExecutableInfo) {
16166 transform_tohost_VkPipelineExecutableInfoKHR(
16167 m_state, (VkPipelineExecutableInfoKHR*)(pExecutableInfo));
16168 }
16169 if (pStatisticCount) {
16170 if (pStatistics) {
16171 for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i) {
16172 transform_tohost_VkPipelineExecutableStatisticKHR(
16173 m_state, (VkPipelineExecutableStatisticKHR*)(pStatistics + i));
16174 }
16175 }
16176 }
16177 if (m_logCalls) {
16178 fprintf(stderr,
16179 "stream %p: call vkGetPipelineExecutableStatisticsKHR 0x%llx 0x%llx "
16180 "0x%llx 0x%llx \n",
16181 ioStream, (unsigned long long)device,
16182 (unsigned long long)pExecutableInfo,
16183 (unsigned long long)pStatisticCount, (unsigned long long)pStatistics);
16184 }
16185 VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
16186 vkGetPipelineExecutableStatisticsKHR_VkResult_return =
16187 vk->vkGetPipelineExecutableStatisticsKHR(unboxed_device, pExecutableInfo,
16188 pStatisticCount, pStatistics);
16189 if ((vkGetPipelineExecutableStatisticsKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
16190 m_state->on_DeviceLost();
16191 m_state->on_CheckOutOfMemory(vkGetPipelineExecutableStatisticsKHR_VkResult_return,
16192 opcode, context);
16193 vkStream->unsetHandleMapping();
16194 // WARNING PTR CHECK
16195 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pStatisticCount;
16196 vkStream->putBe64(cgen_var_3);
16197 if (pStatisticCount) {
16198 vkStream->write((uint32_t*)pStatisticCount, sizeof(uint32_t));
16199 }
16200 if (pStatisticCount) {
16201 if (pStatistics) {
16202 for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i) {
16203 transform_fromhost_VkPipelineExecutableStatisticKHR(
16204 m_state, (VkPipelineExecutableStatisticKHR*)(pStatistics + i));
16205 }
16206 }
16207 }
16208 // WARNING PTR CHECK
16209 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pStatistics;
16210 vkStream->putBe64(cgen_var_4);
16211 if (pStatistics) {
16212 if (pStatisticCount) {
16213 for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i) {
16214 marshal_VkPipelineExecutableStatisticKHR(
16215 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16216 (VkPipelineExecutableStatisticKHR*)(pStatistics + i));
16217 }
16218 }
16219 }
16220 vkStream->write(&vkGetPipelineExecutableStatisticsKHR_VkResult_return,
16221 sizeof(VkResult));
16222 vkStream->commitWrite();
16223 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16224 (uintptr_t)snapshotTraceBegin);
16225 size_t snapshotTraceBytes = vkReadStream->endTrace();
16226 if (m_state->snapshotsEnabled()) {
16227 m_state->snapshot()->vkGetPipelineExecutableStatisticsKHR(
16228 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
16229 vkGetPipelineExecutableStatisticsKHR_VkResult_return, device,
16230 pExecutableInfo, pStatisticCount, pStatistics);
16231 }
16232 vkReadStream->clearPool();
16233 if (m_queueSubmitWithCommandsEnabled)
16234 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16235 break;
16236 }
16237 case OP_vkGetPipelineExecutableInternalRepresentationsKHR: {
16238 GFXSTREAM_TRACE_EVENT(
16239 GFXSTREAM_TRACE_DECODER_CATEGORY,
16240 "VkDecoder vkGetPipelineExecutableInternalRepresentationsKHR");
16241 VkDevice device;
16242 const VkPipelineExecutableInfoKHR* pExecutableInfo;
16243 uint32_t* pInternalRepresentationCount;
16244 VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations;
16245 // Begin non wrapped dispatchable handle unboxing for device;
16246 uint64_t cgen_var_0;
16247 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16248 *readStreamPtrPtr += 1 * 8;
16249 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
16250 auto unboxed_device = unbox_VkDevice(device);
16251 auto vk = dispatch_VkDevice(device);
16252 // End manual dispatchable handle unboxing for device;
16253 vkReadStream->alloc((void**)&pExecutableInfo,
16254 sizeof(const VkPipelineExecutableInfoKHR));
16255 reservedunmarshal_VkPipelineExecutableInfoKHR(
16256 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16257 (VkPipelineExecutableInfoKHR*)(pExecutableInfo), readStreamPtrPtr);
16258 // Begin manual dispatchable handle unboxing for pInternalRepresentationCount;
16259 vkReadStream->unsetHandleMapping();
16260 // WARNING PTR CHECK
16261 memcpy((uint32_t**)&pInternalRepresentationCount, (*readStreamPtrPtr), 8);
16262 android::base::Stream::fromBe64((uint8_t*)&pInternalRepresentationCount);
16263 *readStreamPtrPtr += 8;
16264 if (pInternalRepresentationCount) {
16265 vkReadStream->alloc((void**)&pInternalRepresentationCount, sizeof(uint32_t));
16266 memcpy((uint32_t*)pInternalRepresentationCount, *readStreamPtrPtr,
16267 sizeof(uint32_t));
16268 *readStreamPtrPtr += sizeof(uint32_t);
16269 }
16270 // Begin manual dispatchable handle unboxing for pInternalRepresentations;
16271 vkReadStream->unsetHandleMapping();
16272 // WARNING PTR CHECK
16273 memcpy((VkPipelineExecutableInternalRepresentationKHR**)&pInternalRepresentations,
16274 (*readStreamPtrPtr), 8);
16275 android::base::Stream::fromBe64((uint8_t*)&pInternalRepresentations);
16276 *readStreamPtrPtr += 8;
16277 if (pInternalRepresentations) {
16278 vkReadStream->alloc((void**)&pInternalRepresentations,
16279 (*(pInternalRepresentationCount)) *
16280 sizeof(VkPipelineExecutableInternalRepresentationKHR));
16281 for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i) {
16282 reservedunmarshal_VkPipelineExecutableInternalRepresentationKHR(
16283 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16284 (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations +
16285 i),
16286 readStreamPtrPtr);
16287 }
16288 }
16289 if (pExecutableInfo) {
16290 transform_tohost_VkPipelineExecutableInfoKHR(
16291 m_state, (VkPipelineExecutableInfoKHR*)(pExecutableInfo));
16292 }
16293 if (pInternalRepresentationCount) {
16294 if (pInternalRepresentations) {
16295 for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i) {
16296 transform_tohost_VkPipelineExecutableInternalRepresentationKHR(
16297 m_state,
16298 (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations +
16299 i));
16300 }
16301 }
16302 }
16303 if (m_logCalls) {
16304 fprintf(stderr,
16305 "stream %p: call vkGetPipelineExecutableInternalRepresentationsKHR "
16306 "0x%llx 0x%llx 0x%llx 0x%llx \n",
16307 ioStream, (unsigned long long)device,
16308 (unsigned long long)pExecutableInfo,
16309 (unsigned long long)pInternalRepresentationCount,
16310 (unsigned long long)pInternalRepresentations);
16311 }
16312 VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
16313 (VkResult)0;
16314 vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
16315 vk->vkGetPipelineExecutableInternalRepresentationsKHR(
16316 unboxed_device, pExecutableInfo, pInternalRepresentationCount,
16317 pInternalRepresentations);
16318 if ((vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return) ==
16319 VK_ERROR_DEVICE_LOST)
16320 m_state->on_DeviceLost();
16321 m_state->on_CheckOutOfMemory(
16322 vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return, opcode,
16323 context);
16324 vkStream->unsetHandleMapping();
16325 // WARNING PTR CHECK
16326 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pInternalRepresentationCount;
16327 vkStream->putBe64(cgen_var_3);
16328 if (pInternalRepresentationCount) {
16329 vkStream->write((uint32_t*)pInternalRepresentationCount, sizeof(uint32_t));
16330 }
16331 if (pInternalRepresentationCount) {
16332 if (pInternalRepresentations) {
16333 for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i) {
16334 transform_fromhost_VkPipelineExecutableInternalRepresentationKHR(
16335 m_state,
16336 (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations +
16337 i));
16338 }
16339 }
16340 }
16341 // WARNING PTR CHECK
16342 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pInternalRepresentations;
16343 vkStream->putBe64(cgen_var_4);
16344 if (pInternalRepresentations) {
16345 if (pInternalRepresentationCount) {
16346 for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i) {
16347 marshal_VkPipelineExecutableInternalRepresentationKHR(
16348 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16349 (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations +
16350 i));
16351 }
16352 }
16353 }
16354 vkStream->write(&vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return,
16355 sizeof(VkResult));
16356 vkStream->commitWrite();
16357 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16358 (uintptr_t)snapshotTraceBegin);
16359 size_t snapshotTraceBytes = vkReadStream->endTrace();
16360 if (m_state->snapshotsEnabled()) {
16361 m_state->snapshot()->vkGetPipelineExecutableInternalRepresentationsKHR(
16362 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
16363 vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return, device,
16364 pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
16365 }
16366 vkReadStream->clearPool();
16367 if (m_queueSubmitWithCommandsEnabled)
16368 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16369 break;
16370 }
16371 #endif
16372 #ifdef VK_KHR_synchronization2
16373 case OP_vkCmdSetEvent2KHR: {
16374 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16375 "VkDecoder vkCmdSetEvent2KHR");
16376 VkCommandBuffer commandBuffer;
16377 VkEvent event;
16378 const VkDependencyInfo* pDependencyInfo;
16379 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
16380 uint64_t cgen_var_0;
16381 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16382 *readStreamPtrPtr += 1 * 8;
16383 *(VkCommandBuffer*)&commandBuffer =
16384 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16385 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
16386 auto vk = dispatch_VkCommandBuffer(commandBuffer);
16387 // End manual dispatchable handle unboxing for commandBuffer;
16388 uint64_t cgen_var_1;
16389 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
16390 *readStreamPtrPtr += 1 * 8;
16391 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
16392 vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfo));
16393 reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16394 (VkDependencyInfo*)(pDependencyInfo),
16395 readStreamPtrPtr);
16396 if (pDependencyInfo) {
16397 transform_tohost_VkDependencyInfo(m_state,
16398 (VkDependencyInfo*)(pDependencyInfo));
16399 }
16400 if (m_logCalls) {
16401 fprintf(stderr, "stream %p: call vkCmdSetEvent2KHR 0x%llx 0x%llx 0x%llx \n",
16402 ioStream, (unsigned long long)commandBuffer, (unsigned long long)event,
16403 (unsigned long long)pDependencyInfo);
16404 }
16405 vk->vkCmdSetEvent2KHR(unboxed_commandBuffer, event, pDependencyInfo);
16406 vkStream->unsetHandleMapping();
16407 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16408 (uintptr_t)snapshotTraceBegin);
16409 size_t snapshotTraceBytes = vkReadStream->endTrace();
16410 if (m_state->snapshotsEnabled()) {
16411 m_state->snapshot()->vkCmdSetEvent2KHR(snapshotTraceBegin, snapshotTraceBytes,
16412 &m_pool, commandBuffer, event,
16413 pDependencyInfo);
16414 }
16415 vkReadStream->clearPool();
16416 if (m_queueSubmitWithCommandsEnabled)
16417 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16418 break;
16419 }
16420 case OP_vkCmdResetEvent2KHR: {
16421 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16422 "VkDecoder vkCmdResetEvent2KHR");
16423 VkCommandBuffer commandBuffer;
16424 VkEvent event;
16425 VkPipelineStageFlags2 stageMask;
16426 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
16427 uint64_t cgen_var_0;
16428 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16429 *readStreamPtrPtr += 1 * 8;
16430 *(VkCommandBuffer*)&commandBuffer =
16431 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16432 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
16433 auto vk = dispatch_VkCommandBuffer(commandBuffer);
16434 // End manual dispatchable handle unboxing for commandBuffer;
16435 uint64_t cgen_var_1;
16436 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
16437 *readStreamPtrPtr += 1 * 8;
16438 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
16439 memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
16440 sizeof(VkPipelineStageFlags2));
16441 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
16442 if (m_logCalls) {
16443 fprintf(stderr, "stream %p: call vkCmdResetEvent2KHR 0x%llx 0x%llx 0x%llx \n",
16444 ioStream, (unsigned long long)commandBuffer, (unsigned long long)event,
16445 (unsigned long long)stageMask);
16446 }
16447 vk->vkCmdResetEvent2KHR(unboxed_commandBuffer, event, stageMask);
16448 vkStream->unsetHandleMapping();
16449 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16450 (uintptr_t)snapshotTraceBegin);
16451 size_t snapshotTraceBytes = vkReadStream->endTrace();
16452 if (m_state->snapshotsEnabled()) {
16453 m_state->snapshot()->vkCmdResetEvent2KHR(snapshotTraceBegin, snapshotTraceBytes,
16454 &m_pool, commandBuffer, event,
16455 stageMask);
16456 }
16457 vkReadStream->clearPool();
16458 if (m_queueSubmitWithCommandsEnabled)
16459 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16460 break;
16461 }
16462 case OP_vkCmdWaitEvents2KHR: {
16463 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16464 "VkDecoder vkCmdWaitEvents2KHR");
16465 VkCommandBuffer commandBuffer;
16466 uint32_t eventCount;
16467 const VkEvent* pEvents;
16468 const VkDependencyInfo* pDependencyInfos;
16469 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
16470 uint64_t cgen_var_0;
16471 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16472 *readStreamPtrPtr += 1 * 8;
16473 *(VkCommandBuffer*)&commandBuffer =
16474 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16475 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
16476 auto vk = dispatch_VkCommandBuffer(commandBuffer);
16477 // End manual dispatchable handle unboxing for commandBuffer;
16478 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
16479 *readStreamPtrPtr += sizeof(uint32_t);
16480 vkReadStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
16481 if (((eventCount))) {
16482 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
16483 *readStreamPtrPtr += 8 * ((eventCount));
16484 for (uint32_t k = 0; k < ((eventCount)); ++k) {
16485 uint64_t tmpval;
16486 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
16487 *(((VkEvent*)pEvents) + k) =
16488 tmpval ? (VkEvent)unbox_VkEvent((VkEvent)tmpval) : VK_NULL_HANDLE;
16489 }
16490 }
16491 vkReadStream->alloc((void**)&pDependencyInfos,
16492 ((eventCount)) * sizeof(const VkDependencyInfo));
16493 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
16494 reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16495 (VkDependencyInfo*)(pDependencyInfos + i),
16496 readStreamPtrPtr);
16497 }
16498 if (pDependencyInfos) {
16499 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
16500 transform_tohost_VkDependencyInfo(
16501 m_state, (VkDependencyInfo*)(pDependencyInfos + i));
16502 }
16503 }
16504 if (m_logCalls) {
16505 fprintf(stderr,
16506 "stream %p: call vkCmdWaitEvents2KHR 0x%llx 0x%llx 0x%llx 0x%llx \n",
16507 ioStream, (unsigned long long)commandBuffer,
16508 (unsigned long long)eventCount, (unsigned long long)pEvents,
16509 (unsigned long long)pDependencyInfos);
16510 }
16511 vk->vkCmdWaitEvents2KHR(unboxed_commandBuffer, eventCount, pEvents,
16512 pDependencyInfos);
16513 vkStream->unsetHandleMapping();
16514 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16515 (uintptr_t)snapshotTraceBegin);
16516 size_t snapshotTraceBytes = vkReadStream->endTrace();
16517 if (m_state->snapshotsEnabled()) {
16518 m_state->snapshot()->vkCmdWaitEvents2KHR(snapshotTraceBegin, snapshotTraceBytes,
16519 &m_pool, commandBuffer, eventCount,
16520 pEvents, pDependencyInfos);
16521 }
16522 vkReadStream->clearPool();
16523 if (m_queueSubmitWithCommandsEnabled)
16524 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16525 break;
16526 }
16527 case OP_vkCmdPipelineBarrier2KHR: {
16528 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16529 "VkDecoder vkCmdPipelineBarrier2KHR");
16530 VkCommandBuffer commandBuffer;
16531 const VkDependencyInfo* pDependencyInfo;
16532 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
16533 uint64_t cgen_var_0;
16534 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16535 *readStreamPtrPtr += 1 * 8;
16536 *(VkCommandBuffer*)&commandBuffer =
16537 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16538 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
16539 auto vk = dispatch_VkCommandBuffer(commandBuffer);
16540 // End manual dispatchable handle unboxing for commandBuffer;
16541 vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfo));
16542 reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16543 (VkDependencyInfo*)(pDependencyInfo),
16544 readStreamPtrPtr);
16545 if (pDependencyInfo) {
16546 transform_tohost_VkDependencyInfo(m_state,
16547 (VkDependencyInfo*)(pDependencyInfo));
16548 }
16549 if (m_logCalls) {
16550 fprintf(stderr, "stream %p: call vkCmdPipelineBarrier2KHR 0x%llx 0x%llx \n",
16551 ioStream, (unsigned long long)commandBuffer,
16552 (unsigned long long)pDependencyInfo);
16553 }
16554 vk->vkCmdPipelineBarrier2KHR(unboxed_commandBuffer, pDependencyInfo);
16555 vkStream->unsetHandleMapping();
16556 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16557 (uintptr_t)snapshotTraceBegin);
16558 size_t snapshotTraceBytes = vkReadStream->endTrace();
16559 if (m_state->snapshotsEnabled()) {
16560 m_state->snapshot()->vkCmdPipelineBarrier2KHR(snapshotTraceBegin,
16561 snapshotTraceBytes, &m_pool,
16562 commandBuffer, pDependencyInfo);
16563 }
16564 vkReadStream->clearPool();
16565 if (m_queueSubmitWithCommandsEnabled)
16566 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16567 break;
16568 }
16569 case OP_vkCmdWriteTimestamp2KHR: {
16570 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16571 "VkDecoder vkCmdWriteTimestamp2KHR");
16572 VkCommandBuffer commandBuffer;
16573 VkPipelineStageFlags2 stage;
16574 VkQueryPool queryPool;
16575 uint32_t query;
16576 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
16577 uint64_t cgen_var_0;
16578 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16579 *readStreamPtrPtr += 1 * 8;
16580 *(VkCommandBuffer*)&commandBuffer =
16581 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16582 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
16583 auto vk = dispatch_VkCommandBuffer(commandBuffer);
16584 // End manual dispatchable handle unboxing for commandBuffer;
16585 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
16586 sizeof(VkPipelineStageFlags2));
16587 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
16588 uint64_t cgen_var_1;
16589 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
16590 *readStreamPtrPtr += 1 * 8;
16591 *(VkQueryPool*)&queryPool =
16592 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
16593 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
16594 *readStreamPtrPtr += sizeof(uint32_t);
16595 if (m_logCalls) {
16596 fprintf(
16597 stderr,
16598 "stream %p: call vkCmdWriteTimestamp2KHR 0x%llx 0x%llx 0x%llx 0x%llx \n",
16599 ioStream, (unsigned long long)commandBuffer, (unsigned long long)stage,
16600 (unsigned long long)queryPool, (unsigned long long)query);
16601 }
16602 vk->vkCmdWriteTimestamp2KHR(unboxed_commandBuffer, stage, queryPool, query);
16603 vkStream->unsetHandleMapping();
16604 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16605 (uintptr_t)snapshotTraceBegin);
16606 size_t snapshotTraceBytes = vkReadStream->endTrace();
16607 if (m_state->snapshotsEnabled()) {
16608 m_state->snapshot()->vkCmdWriteTimestamp2KHR(
16609 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, stage,
16610 queryPool, query);
16611 }
16612 vkReadStream->clearPool();
16613 if (m_queueSubmitWithCommandsEnabled)
16614 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16615 break;
16616 }
16617 case OP_vkQueueSubmit2KHR: {
16618 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16619 "VkDecoder vkQueueSubmit2KHR");
16620 VkQueue queue;
16621 uint32_t submitCount;
16622 const VkSubmitInfo2* pSubmits;
16623 VkFence fence;
16624 // Begin non wrapped dispatchable handle unboxing for queue;
16625 uint64_t cgen_var_0;
16626 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16627 *readStreamPtrPtr += 1 * 8;
16628 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
16629 auto unboxed_queue = unbox_VkQueue(queue);
16630 auto vk = dispatch_VkQueue(queue);
16631 // End manual dispatchable handle unboxing for queue;
16632 memcpy((uint32_t*)&submitCount, *readStreamPtrPtr, sizeof(uint32_t));
16633 *readStreamPtrPtr += sizeof(uint32_t);
16634 vkReadStream->alloc((void**)&pSubmits,
16635 ((submitCount)) * sizeof(const VkSubmitInfo2));
16636 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
16637 reservedunmarshal_VkSubmitInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16638 (VkSubmitInfo2*)(pSubmits + i),
16639 readStreamPtrPtr);
16640 }
16641 uint64_t cgen_var_1;
16642 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
16643 *readStreamPtrPtr += 1 * 8;
16644 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
16645 if (pSubmits) {
16646 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
16647 transform_tohost_VkSubmitInfo2(m_state, (VkSubmitInfo2*)(pSubmits + i));
16648 }
16649 }
16650 if (m_logCalls) {
16651 fprintf(stderr,
16652 "stream %p: call vkQueueSubmit2KHR 0x%llx 0x%llx 0x%llx 0x%llx \n",
16653 ioStream, (unsigned long long)queue, (unsigned long long)submitCount,
16654 (unsigned long long)pSubmits, (unsigned long long)fence);
16655 }
16656 VkResult vkQueueSubmit2KHR_VkResult_return = (VkResult)0;
16657 vkQueueSubmit2KHR_VkResult_return =
16658 vk->vkQueueSubmit2KHR(unboxed_queue, submitCount, pSubmits, fence);
16659 if ((vkQueueSubmit2KHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
16660 m_state->on_DeviceLost();
16661 m_state->on_CheckOutOfMemory(vkQueueSubmit2KHR_VkResult_return, opcode, context);
16662 vkStream->unsetHandleMapping();
16663 vkStream->write(&vkQueueSubmit2KHR_VkResult_return, sizeof(VkResult));
16664 vkStream->commitWrite();
16665 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16666 (uintptr_t)snapshotTraceBegin);
16667 size_t snapshotTraceBytes = vkReadStream->endTrace();
16668 if (m_state->snapshotsEnabled()) {
16669 m_state->snapshot()->vkQueueSubmit2KHR(
16670 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
16671 vkQueueSubmit2KHR_VkResult_return, queue, submitCount, pSubmits, fence);
16672 }
16673 vkReadStream->clearPool();
16674 if (m_queueSubmitWithCommandsEnabled)
16675 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16676 break;
16677 }
16678 case OP_vkCmdWriteBufferMarker2AMD: {
16679 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16680 "VkDecoder vkCmdWriteBufferMarker2AMD");
16681 VkCommandBuffer commandBuffer;
16682 VkPipelineStageFlags2 stage;
16683 VkBuffer dstBuffer;
16684 VkDeviceSize dstOffset;
16685 uint32_t marker;
16686 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
16687 uint64_t cgen_var_0;
16688 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16689 *readStreamPtrPtr += 1 * 8;
16690 *(VkCommandBuffer*)&commandBuffer =
16691 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16692 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
16693 auto vk = dispatch_VkCommandBuffer(commandBuffer);
16694 // End manual dispatchable handle unboxing for commandBuffer;
16695 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
16696 sizeof(VkPipelineStageFlags2));
16697 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
16698 uint64_t cgen_var_1;
16699 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
16700 *readStreamPtrPtr += 1 * 8;
16701 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
16702 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
16703 *readStreamPtrPtr += sizeof(VkDeviceSize);
16704 memcpy((uint32_t*)&marker, *readStreamPtrPtr, sizeof(uint32_t));
16705 *readStreamPtrPtr += sizeof(uint32_t);
16706 if (m_logCalls) {
16707 fprintf(stderr,
16708 "stream %p: call vkCmdWriteBufferMarker2AMD 0x%llx 0x%llx 0x%llx "
16709 "0x%llx 0x%llx \n",
16710 ioStream, (unsigned long long)commandBuffer, (unsigned long long)stage,
16711 (unsigned long long)dstBuffer, (unsigned long long)dstOffset,
16712 (unsigned long long)marker);
16713 }
16714 vk->vkCmdWriteBufferMarker2AMD(unboxed_commandBuffer, stage, dstBuffer, dstOffset,
16715 marker);
16716 vkStream->unsetHandleMapping();
16717 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16718 (uintptr_t)snapshotTraceBegin);
16719 size_t snapshotTraceBytes = vkReadStream->endTrace();
16720 if (m_state->snapshotsEnabled()) {
16721 m_state->snapshot()->vkCmdWriteBufferMarker2AMD(
16722 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, stage,
16723 dstBuffer, dstOffset, marker);
16724 }
16725 vkReadStream->clearPool();
16726 if (m_queueSubmitWithCommandsEnabled)
16727 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16728 break;
16729 }
16730 case OP_vkGetQueueCheckpointData2NV: {
16731 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16732 "VkDecoder vkGetQueueCheckpointData2NV");
16733 VkQueue queue;
16734 uint32_t* pCheckpointDataCount;
16735 VkCheckpointData2NV* pCheckpointData;
16736 // Begin non wrapped dispatchable handle unboxing for queue;
16737 uint64_t cgen_var_0;
16738 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16739 *readStreamPtrPtr += 1 * 8;
16740 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
16741 auto unboxed_queue = unbox_VkQueue(queue);
16742 auto vk = dispatch_VkQueue(queue);
16743 // End manual dispatchable handle unboxing for queue;
16744 // Begin manual dispatchable handle unboxing for pCheckpointDataCount;
16745 vkReadStream->unsetHandleMapping();
16746 // WARNING PTR CHECK
16747 memcpy((uint32_t**)&pCheckpointDataCount, (*readStreamPtrPtr), 8);
16748 android::base::Stream::fromBe64((uint8_t*)&pCheckpointDataCount);
16749 *readStreamPtrPtr += 8;
16750 if (pCheckpointDataCount) {
16751 vkReadStream->alloc((void**)&pCheckpointDataCount, sizeof(uint32_t));
16752 memcpy((uint32_t*)pCheckpointDataCount, *readStreamPtrPtr, sizeof(uint32_t));
16753 *readStreamPtrPtr += sizeof(uint32_t);
16754 }
16755 // Begin manual dispatchable handle unboxing for pCheckpointData;
16756 vkReadStream->unsetHandleMapping();
16757 // WARNING PTR CHECK
16758 memcpy((VkCheckpointData2NV**)&pCheckpointData, (*readStreamPtrPtr), 8);
16759 android::base::Stream::fromBe64((uint8_t*)&pCheckpointData);
16760 *readStreamPtrPtr += 8;
16761 if (pCheckpointData) {
16762 vkReadStream->alloc((void**)&pCheckpointData,
16763 (*(pCheckpointDataCount)) * sizeof(VkCheckpointData2NV));
16764 for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
16765 reservedunmarshal_VkCheckpointData2NV(
16766 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16767 (VkCheckpointData2NV*)(pCheckpointData + i), readStreamPtrPtr);
16768 }
16769 }
16770 if (pCheckpointDataCount) {
16771 if (pCheckpointData) {
16772 for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
16773 transform_tohost_VkCheckpointData2NV(
16774 m_state, (VkCheckpointData2NV*)(pCheckpointData + i));
16775 }
16776 }
16777 }
16778 if (m_logCalls) {
16779 fprintf(stderr,
16780 "stream %p: call vkGetQueueCheckpointData2NV 0x%llx 0x%llx 0x%llx \n",
16781 ioStream, (unsigned long long)queue,
16782 (unsigned long long)pCheckpointDataCount,
16783 (unsigned long long)pCheckpointData);
16784 }
16785 vk->vkGetQueueCheckpointData2NV(unboxed_queue, pCheckpointDataCount,
16786 pCheckpointData);
16787 vkStream->unsetHandleMapping();
16788 // WARNING PTR CHECK
16789 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pCheckpointDataCount;
16790 vkStream->putBe64(cgen_var_3);
16791 if (pCheckpointDataCount) {
16792 vkStream->write((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
16793 }
16794 if (pCheckpointDataCount) {
16795 if (pCheckpointData) {
16796 for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
16797 transform_fromhost_VkCheckpointData2NV(
16798 m_state, (VkCheckpointData2NV*)(pCheckpointData + i));
16799 }
16800 }
16801 }
16802 // WARNING PTR CHECK
16803 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pCheckpointData;
16804 vkStream->putBe64(cgen_var_4);
16805 if (pCheckpointData) {
16806 if (pCheckpointDataCount) {
16807 for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
16808 marshal_VkCheckpointData2NV(
16809 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16810 (VkCheckpointData2NV*)(pCheckpointData + i));
16811 }
16812 }
16813 }
16814 vkStream->commitWrite();
16815 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16816 (uintptr_t)snapshotTraceBegin);
16817 size_t snapshotTraceBytes = vkReadStream->endTrace();
16818 if (m_state->snapshotsEnabled()) {
16819 m_state->snapshot()->vkGetQueueCheckpointData2NV(
16820 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue,
16821 pCheckpointDataCount, pCheckpointData);
16822 }
16823 vkReadStream->clearPool();
16824 if (m_queueSubmitWithCommandsEnabled)
16825 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16826 break;
16827 }
16828 #endif
16829 #ifdef VK_KHR_copy_commands2
16830 case OP_vkCmdCopyBuffer2KHR: {
16831 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16832 "VkDecoder vkCmdCopyBuffer2KHR");
16833 VkCommandBuffer commandBuffer;
16834 const VkCopyBufferInfo2* pCopyBufferInfo;
16835 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
16836 uint64_t cgen_var_0;
16837 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16838 *readStreamPtrPtr += 1 * 8;
16839 *(VkCommandBuffer*)&commandBuffer =
16840 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16841 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
16842 auto vk = dispatch_VkCommandBuffer(commandBuffer);
16843 // End manual dispatchable handle unboxing for commandBuffer;
16844 vkReadStream->alloc((void**)&pCopyBufferInfo, sizeof(const VkCopyBufferInfo2));
16845 reservedunmarshal_VkCopyBufferInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16846 (VkCopyBufferInfo2*)(pCopyBufferInfo),
16847 readStreamPtrPtr);
16848 if (pCopyBufferInfo) {
16849 transform_tohost_VkCopyBufferInfo2(m_state,
16850 (VkCopyBufferInfo2*)(pCopyBufferInfo));
16851 }
16852 if (m_logCalls) {
16853 fprintf(stderr, "stream %p: call vkCmdCopyBuffer2KHR 0x%llx 0x%llx \n",
16854 ioStream, (unsigned long long)commandBuffer,
16855 (unsigned long long)pCopyBufferInfo);
16856 }
16857 vk->vkCmdCopyBuffer2KHR(unboxed_commandBuffer, pCopyBufferInfo);
16858 vkStream->unsetHandleMapping();
16859 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16860 (uintptr_t)snapshotTraceBegin);
16861 size_t snapshotTraceBytes = vkReadStream->endTrace();
16862 if (m_state->snapshotsEnabled()) {
16863 m_state->snapshot()->vkCmdCopyBuffer2KHR(snapshotTraceBegin, snapshotTraceBytes,
16864 &m_pool, commandBuffer,
16865 pCopyBufferInfo);
16866 }
16867 vkReadStream->clearPool();
16868 if (m_queueSubmitWithCommandsEnabled)
16869 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16870 break;
16871 }
16872 case OP_vkCmdCopyImage2KHR: {
16873 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16874 "VkDecoder vkCmdCopyImage2KHR");
16875 VkCommandBuffer commandBuffer;
16876 const VkCopyImageInfo2* pCopyImageInfo;
16877 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
16878 uint64_t cgen_var_0;
16879 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16880 *readStreamPtrPtr += 1 * 8;
16881 *(VkCommandBuffer*)&commandBuffer =
16882 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16883 vkReadStream->alloc((void**)&pCopyImageInfo, sizeof(const VkCopyImageInfo2));
16884 reservedunmarshal_VkCopyImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16885 (VkCopyImageInfo2*)(pCopyImageInfo),
16886 readStreamPtrPtr);
16887 if (pCopyImageInfo) {
16888 transform_tohost_VkCopyImageInfo2(m_state, (VkCopyImageInfo2*)(pCopyImageInfo));
16889 }
16890 if (m_logCalls) {
16891 fprintf(stderr, "stream %p: call vkCmdCopyImage2KHR 0x%llx 0x%llx \n", ioStream,
16892 (unsigned long long)commandBuffer, (unsigned long long)pCopyImageInfo);
16893 }
16894 m_state->on_vkCmdCopyImage2KHR(&m_pool, commandBuffer, pCopyImageInfo);
16895 vkStream->unsetHandleMapping();
16896 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16897 (uintptr_t)snapshotTraceBegin);
16898 size_t snapshotTraceBytes = vkReadStream->endTrace();
16899 if (m_state->snapshotsEnabled()) {
16900 m_state->snapshot()->vkCmdCopyImage2KHR(snapshotTraceBegin, snapshotTraceBytes,
16901 &m_pool, commandBuffer, pCopyImageInfo);
16902 }
16903 vkReadStream->clearPool();
16904 if (m_queueSubmitWithCommandsEnabled)
16905 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16906 break;
16907 }
16908 case OP_vkCmdCopyBufferToImage2KHR: {
16909 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16910 "VkDecoder vkCmdCopyBufferToImage2KHR");
16911 VkCommandBuffer commandBuffer;
16912 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
16913 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
16914 uint64_t cgen_var_0;
16915 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16916 *readStreamPtrPtr += 1 * 8;
16917 *(VkCommandBuffer*)&commandBuffer =
16918 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16919 vkReadStream->alloc((void**)&pCopyBufferToImageInfo,
16920 sizeof(const VkCopyBufferToImageInfo2));
16921 reservedunmarshal_VkCopyBufferToImageInfo2(
16922 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16923 (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
16924 if (pCopyBufferToImageInfo) {
16925 transform_tohost_VkCopyBufferToImageInfo2(
16926 m_state, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
16927 }
16928 if (m_logCalls) {
16929 fprintf(stderr, "stream %p: call vkCmdCopyBufferToImage2KHR 0x%llx 0x%llx \n",
16930 ioStream, (unsigned long long)commandBuffer,
16931 (unsigned long long)pCopyBufferToImageInfo);
16932 }
16933 m_state->on_vkCmdCopyBufferToImage2KHR(&m_pool, commandBuffer,
16934 pCopyBufferToImageInfo, context);
16935 vkStream->unsetHandleMapping();
16936 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16937 (uintptr_t)snapshotTraceBegin);
16938 size_t snapshotTraceBytes = vkReadStream->endTrace();
16939 if (m_state->snapshotsEnabled()) {
16940 m_state->snapshot()->vkCmdCopyBufferToImage2KHR(
16941 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
16942 pCopyBufferToImageInfo);
16943 }
16944 vkReadStream->clearPool();
16945 if (m_queueSubmitWithCommandsEnabled)
16946 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16947 break;
16948 }
16949 case OP_vkCmdCopyImageToBuffer2KHR: {
16950 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16951 "VkDecoder vkCmdCopyImageToBuffer2KHR");
16952 VkCommandBuffer commandBuffer;
16953 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
16954 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
16955 uint64_t cgen_var_0;
16956 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16957 *readStreamPtrPtr += 1 * 8;
16958 *(VkCommandBuffer*)&commandBuffer =
16959 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
16960 vkReadStream->alloc((void**)&pCopyImageToBufferInfo,
16961 sizeof(const VkCopyImageToBufferInfo2));
16962 reservedunmarshal_VkCopyImageToBufferInfo2(
16963 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
16964 (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
16965 if (pCopyImageToBufferInfo) {
16966 transform_tohost_VkCopyImageToBufferInfo2(
16967 m_state, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
16968 }
16969 if (m_logCalls) {
16970 fprintf(stderr, "stream %p: call vkCmdCopyImageToBuffer2KHR 0x%llx 0x%llx \n",
16971 ioStream, (unsigned long long)commandBuffer,
16972 (unsigned long long)pCopyImageToBufferInfo);
16973 }
16974 m_state->on_vkCmdCopyImageToBuffer2KHR(&m_pool, commandBuffer,
16975 pCopyImageToBufferInfo);
16976 vkStream->unsetHandleMapping();
16977 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
16978 (uintptr_t)snapshotTraceBegin);
16979 size_t snapshotTraceBytes = vkReadStream->endTrace();
16980 if (m_state->snapshotsEnabled()) {
16981 m_state->snapshot()->vkCmdCopyImageToBuffer2KHR(
16982 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
16983 pCopyImageToBufferInfo);
16984 }
16985 vkReadStream->clearPool();
16986 if (m_queueSubmitWithCommandsEnabled)
16987 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
16988 break;
16989 }
16990 case OP_vkCmdBlitImage2KHR: {
16991 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
16992 "VkDecoder vkCmdBlitImage2KHR");
16993 VkCommandBuffer commandBuffer;
16994 const VkBlitImageInfo2* pBlitImageInfo;
16995 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
16996 uint64_t cgen_var_0;
16997 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
16998 *readStreamPtrPtr += 1 * 8;
16999 *(VkCommandBuffer*)&commandBuffer =
17000 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
17001 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
17002 auto vk = dispatch_VkCommandBuffer(commandBuffer);
17003 // End manual dispatchable handle unboxing for commandBuffer;
17004 vkReadStream->alloc((void**)&pBlitImageInfo, sizeof(const VkBlitImageInfo2));
17005 reservedunmarshal_VkBlitImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17006 (VkBlitImageInfo2*)(pBlitImageInfo),
17007 readStreamPtrPtr);
17008 if (pBlitImageInfo) {
17009 transform_tohost_VkBlitImageInfo2(m_state, (VkBlitImageInfo2*)(pBlitImageInfo));
17010 }
17011 if (m_logCalls) {
17012 fprintf(stderr, "stream %p: call vkCmdBlitImage2KHR 0x%llx 0x%llx \n", ioStream,
17013 (unsigned long long)commandBuffer, (unsigned long long)pBlitImageInfo);
17014 }
17015 vk->vkCmdBlitImage2KHR(unboxed_commandBuffer, pBlitImageInfo);
17016 vkStream->unsetHandleMapping();
17017 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17018 (uintptr_t)snapshotTraceBegin);
17019 size_t snapshotTraceBytes = vkReadStream->endTrace();
17020 if (m_state->snapshotsEnabled()) {
17021 m_state->snapshot()->vkCmdBlitImage2KHR(snapshotTraceBegin, snapshotTraceBytes,
17022 &m_pool, commandBuffer, pBlitImageInfo);
17023 }
17024 vkReadStream->clearPool();
17025 if (m_queueSubmitWithCommandsEnabled)
17026 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17027 break;
17028 }
17029 case OP_vkCmdResolveImage2KHR: {
17030 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17031 "VkDecoder vkCmdResolveImage2KHR");
17032 VkCommandBuffer commandBuffer;
17033 const VkResolveImageInfo2* pResolveImageInfo;
17034 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
17035 uint64_t cgen_var_0;
17036 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17037 *readStreamPtrPtr += 1 * 8;
17038 *(VkCommandBuffer*)&commandBuffer =
17039 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
17040 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
17041 auto vk = dispatch_VkCommandBuffer(commandBuffer);
17042 // End manual dispatchable handle unboxing for commandBuffer;
17043 vkReadStream->alloc((void**)&pResolveImageInfo, sizeof(const VkResolveImageInfo2));
17044 reservedunmarshal_VkResolveImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17045 (VkResolveImageInfo2*)(pResolveImageInfo),
17046 readStreamPtrPtr);
17047 if (pResolveImageInfo) {
17048 transform_tohost_VkResolveImageInfo2(m_state,
17049 (VkResolveImageInfo2*)(pResolveImageInfo));
17050 }
17051 if (m_logCalls) {
17052 fprintf(stderr, "stream %p: call vkCmdResolveImage2KHR 0x%llx 0x%llx \n",
17053 ioStream, (unsigned long long)commandBuffer,
17054 (unsigned long long)pResolveImageInfo);
17055 }
17056 vk->vkCmdResolveImage2KHR(unboxed_commandBuffer, pResolveImageInfo);
17057 vkStream->unsetHandleMapping();
17058 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17059 (uintptr_t)snapshotTraceBegin);
17060 size_t snapshotTraceBytes = vkReadStream->endTrace();
17061 if (m_state->snapshotsEnabled()) {
17062 m_state->snapshot()->vkCmdResolveImage2KHR(snapshotTraceBegin,
17063 snapshotTraceBytes, &m_pool,
17064 commandBuffer, pResolveImageInfo);
17065 }
17066 vkReadStream->clearPool();
17067 if (m_queueSubmitWithCommandsEnabled)
17068 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17069 break;
17070 }
17071 #endif
17072 #ifdef VK_KHR_maintenance4
17073 case OP_vkGetDeviceBufferMemoryRequirementsKHR: {
17074 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17075 "VkDecoder vkGetDeviceBufferMemoryRequirementsKHR");
17076 VkDevice device;
17077 const VkDeviceBufferMemoryRequirements* pInfo;
17078 VkMemoryRequirements2* pMemoryRequirements;
17079 // Begin non wrapped dispatchable handle unboxing for device;
17080 uint64_t cgen_var_0;
17081 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17082 *readStreamPtrPtr += 1 * 8;
17083 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
17084 auto unboxed_device = unbox_VkDevice(device);
17085 auto vk = dispatch_VkDevice(device);
17086 // End manual dispatchable handle unboxing for device;
17087 vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceBufferMemoryRequirements));
17088 reservedunmarshal_VkDeviceBufferMemoryRequirements(
17089 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17090 (VkDeviceBufferMemoryRequirements*)(pInfo), readStreamPtrPtr);
17091 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
17092 vkReadStream->unsetHandleMapping();
17093 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
17094 reservedunmarshal_VkMemoryRequirements2(
17095 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17096 (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
17097 if (pInfo) {
17098 transform_tohost_VkDeviceBufferMemoryRequirements(
17099 m_state, (VkDeviceBufferMemoryRequirements*)(pInfo));
17100 }
17101 if (pMemoryRequirements) {
17102 transform_tohost_VkMemoryRequirements2(
17103 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
17104 }
17105 if (m_logCalls) {
17106 fprintf(stderr,
17107 "stream %p: call vkGetDeviceBufferMemoryRequirementsKHR 0x%llx 0x%llx "
17108 "0x%llx \n",
17109 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
17110 (unsigned long long)pMemoryRequirements);
17111 }
17112 vk->vkGetDeviceBufferMemoryRequirementsKHR(unboxed_device, pInfo,
17113 pMemoryRequirements);
17114 vkStream->unsetHandleMapping();
17115 if (pMemoryRequirements) {
17116 transform_fromhost_VkMemoryRequirements2(
17117 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
17118 }
17119 marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17120 (VkMemoryRequirements2*)(pMemoryRequirements));
17121 vkStream->commitWrite();
17122 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17123 (uintptr_t)snapshotTraceBegin);
17124 size_t snapshotTraceBytes = vkReadStream->endTrace();
17125 if (m_state->snapshotsEnabled()) {
17126 m_state->snapshot()->vkGetDeviceBufferMemoryRequirementsKHR(
17127 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
17128 pMemoryRequirements);
17129 }
17130 vkReadStream->clearPool();
17131 if (m_queueSubmitWithCommandsEnabled)
17132 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17133 break;
17134 }
17135 case OP_vkGetDeviceImageMemoryRequirementsKHR: {
17136 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17137 "VkDecoder vkGetDeviceImageMemoryRequirementsKHR");
17138 VkDevice device;
17139 const VkDeviceImageMemoryRequirements* pInfo;
17140 VkMemoryRequirements2* pMemoryRequirements;
17141 // Begin non wrapped dispatchable handle unboxing for device;
17142 uint64_t cgen_var_0;
17143 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17144 *readStreamPtrPtr += 1 * 8;
17145 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
17146 auto unboxed_device = unbox_VkDevice(device);
17147 auto vk = dispatch_VkDevice(device);
17148 // End manual dispatchable handle unboxing for device;
17149 vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageMemoryRequirements));
17150 reservedunmarshal_VkDeviceImageMemoryRequirements(
17151 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17152 (VkDeviceImageMemoryRequirements*)(pInfo), readStreamPtrPtr);
17153 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
17154 vkReadStream->unsetHandleMapping();
17155 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
17156 reservedunmarshal_VkMemoryRequirements2(
17157 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17158 (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
17159 if (pInfo) {
17160 transform_tohost_VkDeviceImageMemoryRequirements(
17161 m_state, (VkDeviceImageMemoryRequirements*)(pInfo));
17162 }
17163 if (pMemoryRequirements) {
17164 transform_tohost_VkMemoryRequirements2(
17165 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
17166 }
17167 if (m_logCalls) {
17168 fprintf(stderr,
17169 "stream %p: call vkGetDeviceImageMemoryRequirementsKHR 0x%llx 0x%llx "
17170 "0x%llx \n",
17171 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
17172 (unsigned long long)pMemoryRequirements);
17173 }
17174 vk->vkGetDeviceImageMemoryRequirementsKHR(unboxed_device, pInfo,
17175 pMemoryRequirements);
17176 vkStream->unsetHandleMapping();
17177 if (pMemoryRequirements) {
17178 transform_fromhost_VkMemoryRequirements2(
17179 m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
17180 }
17181 marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17182 (VkMemoryRequirements2*)(pMemoryRequirements));
17183 vkStream->commitWrite();
17184 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17185 (uintptr_t)snapshotTraceBegin);
17186 size_t snapshotTraceBytes = vkReadStream->endTrace();
17187 if (m_state->snapshotsEnabled()) {
17188 m_state->snapshot()->vkGetDeviceImageMemoryRequirementsKHR(
17189 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
17190 pMemoryRequirements);
17191 }
17192 vkReadStream->clearPool();
17193 if (m_queueSubmitWithCommandsEnabled)
17194 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17195 break;
17196 }
17197 case OP_vkGetDeviceImageSparseMemoryRequirementsKHR: {
17198 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17199 "VkDecoder vkGetDeviceImageSparseMemoryRequirementsKHR");
17200 VkDevice device;
17201 const VkDeviceImageMemoryRequirements* pInfo;
17202 uint32_t* pSparseMemoryRequirementCount;
17203 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements;
17204 // Begin non wrapped dispatchable handle unboxing for device;
17205 uint64_t cgen_var_0;
17206 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17207 *readStreamPtrPtr += 1 * 8;
17208 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
17209 auto unboxed_device = unbox_VkDevice(device);
17210 auto vk = dispatch_VkDevice(device);
17211 // End manual dispatchable handle unboxing for device;
17212 vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageMemoryRequirements));
17213 reservedunmarshal_VkDeviceImageMemoryRequirements(
17214 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17215 (VkDeviceImageMemoryRequirements*)(pInfo), readStreamPtrPtr);
17216 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirementCount;
17217 vkReadStream->unsetHandleMapping();
17218 // WARNING PTR CHECK
17219 memcpy((uint32_t**)&pSparseMemoryRequirementCount, (*readStreamPtrPtr), 8);
17220 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirementCount);
17221 *readStreamPtrPtr += 8;
17222 if (pSparseMemoryRequirementCount) {
17223 vkReadStream->alloc((void**)&pSparseMemoryRequirementCount, sizeof(uint32_t));
17224 memcpy((uint32_t*)pSparseMemoryRequirementCount, *readStreamPtrPtr,
17225 sizeof(uint32_t));
17226 *readStreamPtrPtr += sizeof(uint32_t);
17227 }
17228 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirements;
17229 vkReadStream->unsetHandleMapping();
17230 // WARNING PTR CHECK
17231 memcpy((VkSparseImageMemoryRequirements2**)&pSparseMemoryRequirements,
17232 (*readStreamPtrPtr), 8);
17233 android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirements);
17234 *readStreamPtrPtr += 8;
17235 if (pSparseMemoryRequirements) {
17236 vkReadStream->alloc((void**)&pSparseMemoryRequirements,
17237 (*(pSparseMemoryRequirementCount)) *
17238 sizeof(VkSparseImageMemoryRequirements2));
17239 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
17240 reservedunmarshal_VkSparseImageMemoryRequirements2(
17241 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17242 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i),
17243 readStreamPtrPtr);
17244 }
17245 }
17246 if (pInfo) {
17247 transform_tohost_VkDeviceImageMemoryRequirements(
17248 m_state, (VkDeviceImageMemoryRequirements*)(pInfo));
17249 }
17250 if (pSparseMemoryRequirementCount) {
17251 if (pSparseMemoryRequirements) {
17252 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
17253 ++i) {
17254 transform_tohost_VkSparseImageMemoryRequirements2(
17255 m_state,
17256 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
17257 }
17258 }
17259 }
17260 if (m_logCalls) {
17261 fprintf(stderr,
17262 "stream %p: call vkGetDeviceImageSparseMemoryRequirementsKHR 0x%llx "
17263 "0x%llx 0x%llx 0x%llx \n",
17264 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
17265 (unsigned long long)pSparseMemoryRequirementCount,
17266 (unsigned long long)pSparseMemoryRequirements);
17267 }
17268 vk->vkGetDeviceImageSparseMemoryRequirementsKHR(unboxed_device, pInfo,
17269 pSparseMemoryRequirementCount,
17270 pSparseMemoryRequirements);
17271 vkStream->unsetHandleMapping();
17272 // WARNING PTR CHECK
17273 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
17274 vkStream->putBe64(cgen_var_3);
17275 if (pSparseMemoryRequirementCount) {
17276 vkStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
17277 }
17278 if (pSparseMemoryRequirementCount) {
17279 if (pSparseMemoryRequirements) {
17280 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
17281 ++i) {
17282 transform_fromhost_VkSparseImageMemoryRequirements2(
17283 m_state,
17284 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
17285 }
17286 }
17287 }
17288 // WARNING PTR CHECK
17289 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
17290 vkStream->putBe64(cgen_var_4);
17291 if (pSparseMemoryRequirements) {
17292 if (pSparseMemoryRequirementCount) {
17293 for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
17294 ++i) {
17295 marshal_VkSparseImageMemoryRequirements2(
17296 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17297 (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
17298 }
17299 }
17300 }
17301 vkStream->commitWrite();
17302 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17303 (uintptr_t)snapshotTraceBegin);
17304 size_t snapshotTraceBytes = vkReadStream->endTrace();
17305 if (m_state->snapshotsEnabled()) {
17306 m_state->snapshot()->vkGetDeviceImageSparseMemoryRequirementsKHR(
17307 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
17308 pSparseMemoryRequirementCount, pSparseMemoryRequirements);
17309 }
17310 vkReadStream->clearPool();
17311 if (m_queueSubmitWithCommandsEnabled)
17312 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17313 break;
17314 }
17315 #endif
17316 #ifdef VK_KHR_maintenance5
17317 case OP_vkCmdBindIndexBuffer2KHR: {
17318 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17319 "VkDecoder vkCmdBindIndexBuffer2KHR");
17320 VkCommandBuffer commandBuffer;
17321 VkBuffer buffer;
17322 VkDeviceSize offset;
17323 VkDeviceSize size;
17324 VkIndexType indexType;
17325 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
17326 uint64_t cgen_var_0;
17327 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17328 *readStreamPtrPtr += 1 * 8;
17329 *(VkCommandBuffer*)&commandBuffer =
17330 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
17331 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
17332 auto vk = dispatch_VkCommandBuffer(commandBuffer);
17333 // End manual dispatchable handle unboxing for commandBuffer;
17334 uint64_t cgen_var_1;
17335 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
17336 *readStreamPtrPtr += 1 * 8;
17337 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
17338 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
17339 *readStreamPtrPtr += sizeof(VkDeviceSize);
17340 memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
17341 *readStreamPtrPtr += sizeof(VkDeviceSize);
17342 memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
17343 *readStreamPtrPtr += sizeof(VkIndexType);
17344 if (m_logCalls) {
17345 fprintf(stderr,
17346 "stream %p: call vkCmdBindIndexBuffer2KHR 0x%llx 0x%llx 0x%llx 0x%llx "
17347 "0x%llx \n",
17348 ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
17349 (unsigned long long)offset, (unsigned long long)size,
17350 (unsigned long long)indexType);
17351 }
17352 vk->vkCmdBindIndexBuffer2KHR(unboxed_commandBuffer, buffer, offset, size,
17353 indexType);
17354 vkStream->unsetHandleMapping();
17355 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17356 (uintptr_t)snapshotTraceBegin);
17357 size_t snapshotTraceBytes = vkReadStream->endTrace();
17358 if (m_state->snapshotsEnabled()) {
17359 m_state->snapshot()->vkCmdBindIndexBuffer2KHR(
17360 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, buffer,
17361 offset, size, indexType);
17362 }
17363 vkReadStream->clearPool();
17364 if (m_queueSubmitWithCommandsEnabled)
17365 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17366 break;
17367 }
17368 case OP_vkGetRenderingAreaGranularityKHR: {
17369 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17370 "VkDecoder vkGetRenderingAreaGranularityKHR");
17371 VkDevice device;
17372 const VkRenderingAreaInfoKHR* pRenderingAreaInfo;
17373 VkExtent2D* pGranularity;
17374 // Begin non wrapped dispatchable handle unboxing for device;
17375 uint64_t cgen_var_0;
17376 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17377 *readStreamPtrPtr += 1 * 8;
17378 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
17379 auto unboxed_device = unbox_VkDevice(device);
17380 auto vk = dispatch_VkDevice(device);
17381 // End manual dispatchable handle unboxing for device;
17382 vkReadStream->alloc((void**)&pRenderingAreaInfo,
17383 sizeof(const VkRenderingAreaInfoKHR));
17384 reservedunmarshal_VkRenderingAreaInfoKHR(
17385 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17386 (VkRenderingAreaInfoKHR*)(pRenderingAreaInfo), readStreamPtrPtr);
17387 // Begin manual dispatchable handle unboxing for pGranularity;
17388 vkReadStream->unsetHandleMapping();
17389 vkReadStream->alloc((void**)&pGranularity, sizeof(VkExtent2D));
17390 reservedunmarshal_VkExtent2D(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17391 (VkExtent2D*)(pGranularity), readStreamPtrPtr);
17392 if (pRenderingAreaInfo) {
17393 transform_tohost_VkRenderingAreaInfoKHR(
17394 m_state, (VkRenderingAreaInfoKHR*)(pRenderingAreaInfo));
17395 }
17396 if (pGranularity) {
17397 transform_tohost_VkExtent2D(m_state, (VkExtent2D*)(pGranularity));
17398 }
17399 if (m_logCalls) {
17400 fprintf(
17401 stderr,
17402 "stream %p: call vkGetRenderingAreaGranularityKHR 0x%llx 0x%llx 0x%llx \n",
17403 ioStream, (unsigned long long)device,
17404 (unsigned long long)pRenderingAreaInfo, (unsigned long long)pGranularity);
17405 }
17406 vk->vkGetRenderingAreaGranularityKHR(unboxed_device, pRenderingAreaInfo,
17407 pGranularity);
17408 vkStream->unsetHandleMapping();
17409 if (pGranularity) {
17410 transform_fromhost_VkExtent2D(m_state, (VkExtent2D*)(pGranularity));
17411 }
17412 marshal_VkExtent2D(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17413 (VkExtent2D*)(pGranularity));
17414 vkStream->commitWrite();
17415 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17416 (uintptr_t)snapshotTraceBegin);
17417 size_t snapshotTraceBytes = vkReadStream->endTrace();
17418 if (m_state->snapshotsEnabled()) {
17419 m_state->snapshot()->vkGetRenderingAreaGranularityKHR(
17420 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pRenderingAreaInfo,
17421 pGranularity);
17422 }
17423 vkReadStream->clearPool();
17424 if (m_queueSubmitWithCommandsEnabled)
17425 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17426 break;
17427 }
17428 case OP_vkGetDeviceImageSubresourceLayoutKHR: {
17429 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17430 "VkDecoder vkGetDeviceImageSubresourceLayoutKHR");
17431 VkDevice device;
17432 const VkDeviceImageSubresourceInfoKHR* pInfo;
17433 VkSubresourceLayout2KHR* pLayout;
17434 // Begin non wrapped dispatchable handle unboxing for device;
17435 uint64_t cgen_var_0;
17436 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17437 *readStreamPtrPtr += 1 * 8;
17438 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
17439 auto unboxed_device = unbox_VkDevice(device);
17440 auto vk = dispatch_VkDevice(device);
17441 // End manual dispatchable handle unboxing for device;
17442 vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageSubresourceInfoKHR));
17443 reservedunmarshal_VkDeviceImageSubresourceInfoKHR(
17444 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17445 (VkDeviceImageSubresourceInfoKHR*)(pInfo), readStreamPtrPtr);
17446 // Begin manual dispatchable handle unboxing for pLayout;
17447 vkReadStream->unsetHandleMapping();
17448 vkReadStream->alloc((void**)&pLayout, sizeof(VkSubresourceLayout2KHR));
17449 reservedunmarshal_VkSubresourceLayout2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17450 (VkSubresourceLayout2KHR*)(pLayout),
17451 readStreamPtrPtr);
17452 if (pInfo) {
17453 transform_tohost_VkDeviceImageSubresourceInfoKHR(
17454 m_state, (VkDeviceImageSubresourceInfoKHR*)(pInfo));
17455 }
17456 if (pLayout) {
17457 transform_tohost_VkSubresourceLayout2KHR(m_state,
17458 (VkSubresourceLayout2KHR*)(pLayout));
17459 }
17460 if (m_logCalls) {
17461 fprintf(stderr,
17462 "stream %p: call vkGetDeviceImageSubresourceLayoutKHR 0x%llx 0x%llx "
17463 "0x%llx \n",
17464 ioStream, (unsigned long long)device, (unsigned long long)pInfo,
17465 (unsigned long long)pLayout);
17466 }
17467 vk->vkGetDeviceImageSubresourceLayoutKHR(unboxed_device, pInfo, pLayout);
17468 vkStream->unsetHandleMapping();
17469 if (pLayout) {
17470 transform_fromhost_VkSubresourceLayout2KHR(m_state,
17471 (VkSubresourceLayout2KHR*)(pLayout));
17472 }
17473 marshal_VkSubresourceLayout2KHR(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17474 (VkSubresourceLayout2KHR*)(pLayout));
17475 vkStream->commitWrite();
17476 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17477 (uintptr_t)snapshotTraceBegin);
17478 size_t snapshotTraceBytes = vkReadStream->endTrace();
17479 if (m_state->snapshotsEnabled()) {
17480 m_state->snapshot()->vkGetDeviceImageSubresourceLayoutKHR(
17481 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo, pLayout);
17482 }
17483 vkReadStream->clearPool();
17484 if (m_queueSubmitWithCommandsEnabled)
17485 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17486 break;
17487 }
17488 case OP_vkGetImageSubresourceLayout2KHR: {
17489 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17490 "VkDecoder vkGetImageSubresourceLayout2KHR");
17491 VkDevice device;
17492 VkImage image;
17493 const VkImageSubresource2KHR* pSubresource;
17494 VkSubresourceLayout2KHR* pLayout;
17495 // Begin non wrapped dispatchable handle unboxing for device;
17496 uint64_t cgen_var_0;
17497 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17498 *readStreamPtrPtr += 1 * 8;
17499 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
17500 auto unboxed_device = unbox_VkDevice(device);
17501 auto vk = dispatch_VkDevice(device);
17502 // End manual dispatchable handle unboxing for device;
17503 uint64_t cgen_var_1;
17504 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
17505 *readStreamPtrPtr += 1 * 8;
17506 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
17507 vkReadStream->alloc((void**)&pSubresource, sizeof(const VkImageSubresource2KHR));
17508 reservedunmarshal_VkImageSubresource2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17509 (VkImageSubresource2KHR*)(pSubresource),
17510 readStreamPtrPtr);
17511 // Begin manual dispatchable handle unboxing for pLayout;
17512 vkReadStream->unsetHandleMapping();
17513 vkReadStream->alloc((void**)&pLayout, sizeof(VkSubresourceLayout2KHR));
17514 reservedunmarshal_VkSubresourceLayout2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17515 (VkSubresourceLayout2KHR*)(pLayout),
17516 readStreamPtrPtr);
17517 if (pSubresource) {
17518 transform_tohost_VkImageSubresource2KHR(
17519 m_state, (VkImageSubresource2KHR*)(pSubresource));
17520 }
17521 if (pLayout) {
17522 transform_tohost_VkSubresourceLayout2KHR(m_state,
17523 (VkSubresourceLayout2KHR*)(pLayout));
17524 }
17525 if (m_logCalls) {
17526 fprintf(stderr,
17527 "stream %p: call vkGetImageSubresourceLayout2KHR 0x%llx 0x%llx 0x%llx "
17528 "0x%llx \n",
17529 ioStream, (unsigned long long)device, (unsigned long long)image,
17530 (unsigned long long)pSubresource, (unsigned long long)pLayout);
17531 }
17532 vk->vkGetImageSubresourceLayout2KHR(unboxed_device, image, pSubresource, pLayout);
17533 vkStream->unsetHandleMapping();
17534 if (pLayout) {
17535 transform_fromhost_VkSubresourceLayout2KHR(m_state,
17536 (VkSubresourceLayout2KHR*)(pLayout));
17537 }
17538 marshal_VkSubresourceLayout2KHR(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17539 (VkSubresourceLayout2KHR*)(pLayout));
17540 vkStream->commitWrite();
17541 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17542 (uintptr_t)snapshotTraceBegin);
17543 size_t snapshotTraceBytes = vkReadStream->endTrace();
17544 if (m_state->snapshotsEnabled()) {
17545 m_state->snapshot()->vkGetImageSubresourceLayout2KHR(
17546 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, image,
17547 pSubresource, pLayout);
17548 }
17549 vkReadStream->clearPool();
17550 if (m_queueSubmitWithCommandsEnabled)
17551 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17552 break;
17553 }
17554 #endif
17555 #ifdef VK_KHR_line_rasterization
17556 case OP_vkCmdSetLineStippleKHR: {
17557 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17558 "VkDecoder vkCmdSetLineStippleKHR");
17559 VkCommandBuffer commandBuffer;
17560 uint32_t lineStippleFactor;
17561 uint16_t lineStipplePattern;
17562 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
17563 uint64_t cgen_var_0;
17564 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17565 *readStreamPtrPtr += 1 * 8;
17566 *(VkCommandBuffer*)&commandBuffer =
17567 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
17568 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
17569 auto vk = dispatch_VkCommandBuffer(commandBuffer);
17570 // End manual dispatchable handle unboxing for commandBuffer;
17571 memcpy((uint32_t*)&lineStippleFactor, *readStreamPtrPtr, sizeof(uint32_t));
17572 *readStreamPtrPtr += sizeof(uint32_t);
17573 memcpy((uint16_t*)&lineStipplePattern, *readStreamPtrPtr, sizeof(uint16_t));
17574 *readStreamPtrPtr += sizeof(uint16_t);
17575 if (m_logCalls) {
17576 fprintf(stderr,
17577 "stream %p: call vkCmdSetLineStippleKHR 0x%llx 0x%llx 0x%llx \n",
17578 ioStream, (unsigned long long)commandBuffer,
17579 (unsigned long long)lineStippleFactor,
17580 (unsigned long long)lineStipplePattern);
17581 }
17582 vk->vkCmdSetLineStippleKHR(unboxed_commandBuffer, lineStippleFactor,
17583 lineStipplePattern);
17584 vkStream->unsetHandleMapping();
17585 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17586 (uintptr_t)snapshotTraceBegin);
17587 size_t snapshotTraceBytes = vkReadStream->endTrace();
17588 if (m_state->snapshotsEnabled()) {
17589 m_state->snapshot()->vkCmdSetLineStippleKHR(
17590 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
17591 lineStippleFactor, lineStipplePattern);
17592 }
17593 vkReadStream->clearPool();
17594 if (m_queueSubmitWithCommandsEnabled)
17595 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17596 break;
17597 }
17598 #endif
17599 #ifdef VK_ANDROID_native_buffer
17600 case OP_vkGetSwapchainGrallocUsageANDROID: {
17601 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17602 "VkDecoder vkGetSwapchainGrallocUsageANDROID");
17603 VkDevice device;
17604 VkFormat format;
17605 VkImageUsageFlags imageUsage;
17606 int* grallocUsage;
17607 // Begin global wrapped dispatchable handle unboxing for device;
17608 uint64_t cgen_var_0;
17609 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17610 *readStreamPtrPtr += 1 * 8;
17611 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
17612 memcpy((VkFormat*)&format, *readStreamPtrPtr, sizeof(VkFormat));
17613 *readStreamPtrPtr += sizeof(VkFormat);
17614 memcpy((VkImageUsageFlags*)&imageUsage, *readStreamPtrPtr,
17615 sizeof(VkImageUsageFlags));
17616 *readStreamPtrPtr += sizeof(VkImageUsageFlags);
17617 // Begin manual dispatchable handle unboxing for grallocUsage;
17618 vkReadStream->unsetHandleMapping();
17619 vkReadStream->alloc((void**)&grallocUsage, sizeof(int));
17620 memcpy((int*)grallocUsage, *readStreamPtrPtr, sizeof(int));
17621 *readStreamPtrPtr += sizeof(int);
17622 if (m_logCalls) {
17623 fprintf(stderr,
17624 "stream %p: call vkGetSwapchainGrallocUsageANDROID 0x%llx 0x%llx "
17625 "0x%llx 0x%llx \n",
17626 ioStream, (unsigned long long)device, (unsigned long long)format,
17627 (unsigned long long)imageUsage, (unsigned long long)grallocUsage);
17628 }
17629 VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
17630 vkGetSwapchainGrallocUsageANDROID_VkResult_return =
17631 m_state->on_vkGetSwapchainGrallocUsageANDROID(&m_pool, device, format,
17632 imageUsage, grallocUsage);
17633 if ((vkGetSwapchainGrallocUsageANDROID_VkResult_return) == VK_ERROR_DEVICE_LOST)
17634 m_state->on_DeviceLost();
17635 m_state->on_CheckOutOfMemory(vkGetSwapchainGrallocUsageANDROID_VkResult_return,
17636 opcode, context);
17637 vkStream->unsetHandleMapping();
17638 vkStream->write((int*)grallocUsage, sizeof(int));
17639 vkStream->write(&vkGetSwapchainGrallocUsageANDROID_VkResult_return,
17640 sizeof(VkResult));
17641 vkStream->commitWrite();
17642 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17643 (uintptr_t)snapshotTraceBegin);
17644 size_t snapshotTraceBytes = vkReadStream->endTrace();
17645 if (m_state->snapshotsEnabled()) {
17646 m_state->snapshot()->vkGetSwapchainGrallocUsageANDROID(
17647 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
17648 vkGetSwapchainGrallocUsageANDROID_VkResult_return, device, format,
17649 imageUsage, grallocUsage);
17650 }
17651 vkReadStream->clearPool();
17652 if (m_queueSubmitWithCommandsEnabled)
17653 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17654 break;
17655 }
17656 case OP_vkAcquireImageANDROID: {
17657 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17658 "VkDecoder vkAcquireImageANDROID");
17659 VkDevice device;
17660 VkImage image;
17661 int nativeFenceFd;
17662 VkSemaphore semaphore;
17663 VkFence fence;
17664 // Begin global wrapped dispatchable handle unboxing for device;
17665 uint64_t cgen_var_0;
17666 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17667 *readStreamPtrPtr += 1 * 8;
17668 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
17669 uint64_t cgen_var_1;
17670 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
17671 *readStreamPtrPtr += 1 * 8;
17672 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
17673 memcpy((int*)&nativeFenceFd, *readStreamPtrPtr, sizeof(int));
17674 *readStreamPtrPtr += sizeof(int);
17675 uint64_t cgen_var_2;
17676 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
17677 *readStreamPtrPtr += 1 * 8;
17678 *(VkSemaphore*)&semaphore =
17679 (VkSemaphore)unbox_VkSemaphore((VkSemaphore)(*&cgen_var_2));
17680 uint64_t cgen_var_3;
17681 memcpy((uint64_t*)&cgen_var_3, *readStreamPtrPtr, 1 * 8);
17682 *readStreamPtrPtr += 1 * 8;
17683 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_3));
17684 if (m_logCalls) {
17685 fprintf(stderr,
17686 "stream %p: call vkAcquireImageANDROID 0x%llx 0x%llx 0x%llx 0x%llx "
17687 "0x%llx \n",
17688 ioStream, (unsigned long long)device, (unsigned long long)image,
17689 (unsigned long long)nativeFenceFd, (unsigned long long)semaphore,
17690 (unsigned long long)fence);
17691 }
17692 VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
17693 vkAcquireImageANDROID_VkResult_return = m_state->on_vkAcquireImageANDROID(
17694 &m_pool, device, image, nativeFenceFd, semaphore, fence);
17695 if ((vkAcquireImageANDROID_VkResult_return) == VK_ERROR_DEVICE_LOST)
17696 m_state->on_DeviceLost();
17697 m_state->on_CheckOutOfMemory(vkAcquireImageANDROID_VkResult_return, opcode,
17698 context);
17699 vkStream->unsetHandleMapping();
17700 vkStream->write(&vkAcquireImageANDROID_VkResult_return, sizeof(VkResult));
17701 vkStream->commitWrite();
17702 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17703 (uintptr_t)snapshotTraceBegin);
17704 size_t snapshotTraceBytes = vkReadStream->endTrace();
17705 if (m_state->snapshotsEnabled()) {
17706 m_state->snapshot()->vkAcquireImageANDROID(
17707 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
17708 vkAcquireImageANDROID_VkResult_return, device, image, nativeFenceFd,
17709 semaphore, fence);
17710 }
17711 vkReadStream->clearPool();
17712 if (m_queueSubmitWithCommandsEnabled)
17713 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17714 break;
17715 }
17716 case OP_vkQueueSignalReleaseImageANDROID: {
17717 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17718 "VkDecoder vkQueueSignalReleaseImageANDROID");
17719 VkQueue queue;
17720 uint32_t waitSemaphoreCount;
17721 const VkSemaphore* pWaitSemaphores;
17722 VkImage image;
17723 int* pNativeFenceFd;
17724 // Begin global wrapped dispatchable handle unboxing for queue;
17725 uint64_t cgen_var_0;
17726 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17727 *readStreamPtrPtr += 1 * 8;
17728 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
17729 memcpy((uint32_t*)&waitSemaphoreCount, *readStreamPtrPtr, sizeof(uint32_t));
17730 *readStreamPtrPtr += sizeof(uint32_t);
17731 // WARNING PTR CHECK
17732 memcpy((VkSemaphore**)&pWaitSemaphores, (*readStreamPtrPtr), 8);
17733 android::base::Stream::fromBe64((uint8_t*)&pWaitSemaphores);
17734 *readStreamPtrPtr += 8;
17735 if (pWaitSemaphores) {
17736 vkReadStream->alloc((void**)&pWaitSemaphores,
17737 ((waitSemaphoreCount)) * sizeof(const VkSemaphore));
17738 if (((waitSemaphoreCount))) {
17739 uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*readStreamPtrPtr);
17740 *readStreamPtrPtr += 8 * ((waitSemaphoreCount));
17741 for (uint32_t k = 0; k < ((waitSemaphoreCount)); ++k) {
17742 uint64_t tmpval;
17743 memcpy(&tmpval, cgen_var_1_0_ptr + k * 8, sizeof(uint64_t));
17744 *(((VkSemaphore*)pWaitSemaphores) + k) =
17745 tmpval ? (VkSemaphore)unbox_VkSemaphore((VkSemaphore)tmpval)
17746 : VK_NULL_HANDLE;
17747 }
17748 }
17749 }
17750 uint64_t cgen_var_2;
17751 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
17752 *readStreamPtrPtr += 1 * 8;
17753 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_2));
17754 // Begin manual dispatchable handle unboxing for pNativeFenceFd;
17755 vkReadStream->unsetHandleMapping();
17756 vkReadStream->alloc((void**)&pNativeFenceFd, sizeof(int));
17757 memcpy((int*)pNativeFenceFd, *readStreamPtrPtr, sizeof(int));
17758 *readStreamPtrPtr += sizeof(int);
17759 if (m_logCalls) {
17760 fprintf(stderr,
17761 "stream %p: call vkQueueSignalReleaseImageANDROID 0x%llx 0x%llx 0x%llx "
17762 "0x%llx 0x%llx \n",
17763 ioStream, (unsigned long long)queue,
17764 (unsigned long long)waitSemaphoreCount,
17765 (unsigned long long)pWaitSemaphores, (unsigned long long)image,
17766 (unsigned long long)pNativeFenceFd);
17767 }
17768 VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
17769 vkQueueSignalReleaseImageANDROID_VkResult_return =
17770 m_state->on_vkQueueSignalReleaseImageANDROID(
17771 &m_pool, queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
17772 if ((vkQueueSignalReleaseImageANDROID_VkResult_return) == VK_ERROR_DEVICE_LOST)
17773 m_state->on_DeviceLost();
17774 m_state->on_CheckOutOfMemory(vkQueueSignalReleaseImageANDROID_VkResult_return,
17775 opcode, context);
17776 vkStream->unsetHandleMapping();
17777 vkStream->write((int*)pNativeFenceFd, sizeof(int));
17778 vkStream->write(&vkQueueSignalReleaseImageANDROID_VkResult_return,
17779 sizeof(VkResult));
17780 vkStream->commitWrite();
17781 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17782 (uintptr_t)snapshotTraceBegin);
17783 size_t snapshotTraceBytes = vkReadStream->endTrace();
17784 if (m_state->snapshotsEnabled()) {
17785 m_state->snapshot()->vkQueueSignalReleaseImageANDROID(
17786 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
17787 vkQueueSignalReleaseImageANDROID_VkResult_return, queue, waitSemaphoreCount,
17788 pWaitSemaphores, image, pNativeFenceFd);
17789 }
17790 vkReadStream->clearPool();
17791 if (m_queueSubmitWithCommandsEnabled)
17792 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17793 break;
17794 }
17795 case OP_vkGetSwapchainGrallocUsage2ANDROID: {
17796 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17797 "VkDecoder vkGetSwapchainGrallocUsage2ANDROID");
17798 VkDevice device;
17799 VkFormat format;
17800 VkImageUsageFlags imageUsage;
17801 VkSwapchainImageUsageFlagsANDROID swapchainImageUsage;
17802 uint64_t* grallocConsumerUsage;
17803 uint64_t* grallocProducerUsage;
17804 // Begin global wrapped dispatchable handle unboxing for device;
17805 uint64_t cgen_var_0;
17806 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17807 *readStreamPtrPtr += 1 * 8;
17808 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
17809 memcpy((VkFormat*)&format, *readStreamPtrPtr, sizeof(VkFormat));
17810 *readStreamPtrPtr += sizeof(VkFormat);
17811 memcpy((VkImageUsageFlags*)&imageUsage, *readStreamPtrPtr,
17812 sizeof(VkImageUsageFlags));
17813 *readStreamPtrPtr += sizeof(VkImageUsageFlags);
17814 memcpy((VkSwapchainImageUsageFlagsANDROID*)&swapchainImageUsage, *readStreamPtrPtr,
17815 sizeof(VkSwapchainImageUsageFlagsANDROID));
17816 *readStreamPtrPtr += sizeof(VkSwapchainImageUsageFlagsANDROID);
17817 // Begin manual dispatchable handle unboxing for grallocConsumerUsage;
17818 vkReadStream->unsetHandleMapping();
17819 vkReadStream->alloc((void**)&grallocConsumerUsage, sizeof(uint64_t));
17820 memcpy((uint64_t*)grallocConsumerUsage, *readStreamPtrPtr, sizeof(uint64_t));
17821 *readStreamPtrPtr += sizeof(uint64_t);
17822 // Begin manual dispatchable handle unboxing for grallocProducerUsage;
17823 vkReadStream->unsetHandleMapping();
17824 vkReadStream->alloc((void**)&grallocProducerUsage, sizeof(uint64_t));
17825 memcpy((uint64_t*)grallocProducerUsage, *readStreamPtrPtr, sizeof(uint64_t));
17826 *readStreamPtrPtr += sizeof(uint64_t);
17827 if (m_logCalls) {
17828 fprintf(stderr,
17829 "stream %p: call vkGetSwapchainGrallocUsage2ANDROID 0x%llx 0x%llx "
17830 "0x%llx 0x%llx 0x%llx 0x%llx \n",
17831 ioStream, (unsigned long long)device, (unsigned long long)format,
17832 (unsigned long long)imageUsage, (unsigned long long)swapchainImageUsage,
17833 (unsigned long long)grallocConsumerUsage,
17834 (unsigned long long)grallocProducerUsage);
17835 }
17836 VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
17837 vkGetSwapchainGrallocUsage2ANDROID_VkResult_return =
17838 m_state->on_vkGetSwapchainGrallocUsage2ANDROID(
17839 &m_pool, device, format, imageUsage, swapchainImageUsage,
17840 grallocConsumerUsage, grallocProducerUsage);
17841 if ((vkGetSwapchainGrallocUsage2ANDROID_VkResult_return) == VK_ERROR_DEVICE_LOST)
17842 m_state->on_DeviceLost();
17843 m_state->on_CheckOutOfMemory(vkGetSwapchainGrallocUsage2ANDROID_VkResult_return,
17844 opcode, context);
17845 vkStream->unsetHandleMapping();
17846 vkStream->write((uint64_t*)grallocConsumerUsage, sizeof(uint64_t));
17847 vkStream->write((uint64_t*)grallocProducerUsage, sizeof(uint64_t));
17848 vkStream->write(&vkGetSwapchainGrallocUsage2ANDROID_VkResult_return,
17849 sizeof(VkResult));
17850 vkStream->commitWrite();
17851 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17852 (uintptr_t)snapshotTraceBegin);
17853 size_t snapshotTraceBytes = vkReadStream->endTrace();
17854 if (m_state->snapshotsEnabled()) {
17855 m_state->snapshot()->vkGetSwapchainGrallocUsage2ANDROID(
17856 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
17857 vkGetSwapchainGrallocUsage2ANDROID_VkResult_return, device, format,
17858 imageUsage, swapchainImageUsage, grallocConsumerUsage,
17859 grallocProducerUsage);
17860 }
17861 vkReadStream->clearPool();
17862 if (m_queueSubmitWithCommandsEnabled)
17863 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17864 break;
17865 }
17866 #endif
17867 #ifdef VK_EXT_debug_report
17868 case OP_vkCreateDebugReportCallbackEXT: {
17869 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17870 "VkDecoder vkCreateDebugReportCallbackEXT");
17871 VkInstance instance;
17872 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo;
17873 const VkAllocationCallbacks* pAllocator;
17874 VkDebugReportCallbackEXT* pCallback;
17875 // Begin non wrapped dispatchable handle unboxing for instance;
17876 uint64_t cgen_var_0;
17877 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17878 *readStreamPtrPtr += 1 * 8;
17879 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
17880 auto unboxed_instance = unbox_VkInstance(instance);
17881 auto vk = dispatch_VkInstance(instance);
17882 // End manual dispatchable handle unboxing for instance;
17883 vkReadStream->alloc((void**)&pCreateInfo,
17884 sizeof(const VkDebugReportCallbackCreateInfoEXT));
17885 reservedunmarshal_VkDebugReportCallbackCreateInfoEXT(
17886 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17887 (VkDebugReportCallbackCreateInfoEXT*)(pCreateInfo), readStreamPtrPtr);
17888 // WARNING PTR CHECK
17889 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
17890 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
17891 *readStreamPtrPtr += 8;
17892 if (pAllocator) {
17893 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
17894 reservedunmarshal_VkAllocationCallbacks(
17895 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17896 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
17897 }
17898 // Begin manual dispatchable handle unboxing for pCallback;
17899 vkReadStream->unsetHandleMapping();
17900 vkReadStream->alloc((void**)&pCallback, sizeof(VkDebugReportCallbackEXT));
17901 uint64_t cgen_var_2;
17902 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
17903 *readStreamPtrPtr += 8;
17904 *(VkDebugReportCallbackEXT*)pCallback =
17905 (VkDebugReportCallbackEXT)(VkDebugReportCallbackEXT)((
17906 VkDebugReportCallbackEXT)(*&cgen_var_2));
17907 if (pCreateInfo) {
17908 transform_tohost_VkDebugReportCallbackCreateInfoEXT(
17909 m_state, (VkDebugReportCallbackCreateInfoEXT*)(pCreateInfo));
17910 }
17911 if (pAllocator) {
17912 transform_tohost_VkAllocationCallbacks(m_state,
17913 (VkAllocationCallbacks*)(pAllocator));
17914 }
17915 if (m_logCalls) {
17916 fprintf(stderr,
17917 "stream %p: call vkCreateDebugReportCallbackEXT 0x%llx 0x%llx 0x%llx "
17918 "0x%llx \n",
17919 ioStream, (unsigned long long)instance, (unsigned long long)pCreateInfo,
17920 (unsigned long long)pAllocator, (unsigned long long)pCallback);
17921 }
17922 VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
17923 vkCreateDebugReportCallbackEXT_VkResult_return = vk->vkCreateDebugReportCallbackEXT(
17924 unboxed_instance, pCreateInfo, pAllocator, pCallback);
17925 if ((vkCreateDebugReportCallbackEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
17926 m_state->on_DeviceLost();
17927 m_state->on_CheckOutOfMemory(vkCreateDebugReportCallbackEXT_VkResult_return, opcode,
17928 context);
17929 vkStream->unsetHandleMapping();
17930 // Begin auto non dispatchable handle create for pCallback;
17931 if (vkCreateDebugReportCallbackEXT_VkResult_return == VK_SUCCESS)
17932 vkStream->setHandleMapping(&m_boxedHandleCreateMapping);
17933 uint64_t cgen_var_3;
17934 static_assert(
17935 8 == sizeof(VkDebugReportCallbackEXT),
17936 "handle map overwrite requires VkDebugReportCallbackEXT to be 8 bytes long");
17937 vkStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT(
17938 (VkDebugReportCallbackEXT*)pCallback, 1);
17939 vkStream->write((VkDebugReportCallbackEXT*)pCallback, 8 * 1);
17940 // Begin auto non dispatchable handle create for pCallback;
17941 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
17942 vkStream->write(&vkCreateDebugReportCallbackEXT_VkResult_return, sizeof(VkResult));
17943 vkStream->commitWrite();
17944 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
17945 (uintptr_t)snapshotTraceBegin);
17946 size_t snapshotTraceBytes = vkReadStream->endTrace();
17947 if (m_state->snapshotsEnabled()) {
17948 m_state->snapshot()->vkCreateDebugReportCallbackEXT(
17949 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
17950 vkCreateDebugReportCallbackEXT_VkResult_return, instance, pCreateInfo,
17951 pAllocator, pCallback);
17952 }
17953 vkReadStream->clearPool();
17954 if (m_queueSubmitWithCommandsEnabled)
17955 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
17956 break;
17957 }
17958 case OP_vkDestroyDebugReportCallbackEXT: {
17959 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
17960 "VkDecoder vkDestroyDebugReportCallbackEXT");
17961 VkInstance instance;
17962 VkDebugReportCallbackEXT callback;
17963 const VkAllocationCallbacks* pAllocator;
17964 // Begin non wrapped dispatchable handle unboxing for instance;
17965 uint64_t cgen_var_0;
17966 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
17967 *readStreamPtrPtr += 1 * 8;
17968 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
17969 auto unboxed_instance = unbox_VkInstance(instance);
17970 auto vk = dispatch_VkInstance(instance);
17971 // End manual dispatchable handle unboxing for instance;
17972 // Begin manual non dispatchable handle destroy unboxing for callback;
17973 VkDebugReportCallbackEXT boxed_callback_preserve;
17974 uint64_t cgen_var_1;
17975 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
17976 *readStreamPtrPtr += 1 * 8;
17977 *(VkDebugReportCallbackEXT*)&callback =
17978 (VkDebugReportCallbackEXT)(VkDebugReportCallbackEXT)((
17979 VkDebugReportCallbackEXT)(*&cgen_var_1));
17980 boxed_callback_preserve = callback;
17981 callback = try_unbox_VkDebugReportCallbackEXT(callback);
17982 // WARNING PTR CHECK
17983 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
17984 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
17985 *readStreamPtrPtr += 8;
17986 if (pAllocator) {
17987 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
17988 reservedunmarshal_VkAllocationCallbacks(
17989 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
17990 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
17991 }
17992 if (pAllocator) {
17993 transform_tohost_VkAllocationCallbacks(m_state,
17994 (VkAllocationCallbacks*)(pAllocator));
17995 }
17996 if (m_logCalls) {
17997 fprintf(
17998 stderr,
17999 "stream %p: call vkDestroyDebugReportCallbackEXT 0x%llx 0x%llx 0x%llx \n",
18000 ioStream, (unsigned long long)instance, (unsigned long long)callback,
18001 (unsigned long long)pAllocator);
18002 }
18003 vk->vkDestroyDebugReportCallbackEXT(unboxed_instance, callback, pAllocator);
18004 vkStream->unsetHandleMapping();
18005 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18006 (uintptr_t)snapshotTraceBegin);
18007 size_t snapshotTraceBytes = vkReadStream->endTrace();
18008 if (m_state->snapshotsEnabled()) {
18009 m_state->snapshot()->vkDestroyDebugReportCallbackEXT(
18010 snapshotTraceBegin, snapshotTraceBytes, &m_pool, instance,
18011 boxed_callback_preserve, pAllocator);
18012 }
18013 delete_VkDebugReportCallbackEXT(boxed_callback_preserve);
18014 vkReadStream->clearPool();
18015 if (m_queueSubmitWithCommandsEnabled)
18016 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18017 break;
18018 }
18019 case OP_vkDebugReportMessageEXT: {
18020 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18021 "VkDecoder vkDebugReportMessageEXT");
18022 VkInstance instance;
18023 VkDebugReportFlagsEXT flags;
18024 VkDebugReportObjectTypeEXT objectType;
18025 uint64_t object;
18026 size_t location;
18027 int32_t messageCode;
18028 const char* pLayerPrefix;
18029 const char* pMessage;
18030 // Begin non wrapped dispatchable handle unboxing for instance;
18031 uint64_t cgen_var_0;
18032 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18033 *readStreamPtrPtr += 1 * 8;
18034 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
18035 auto unboxed_instance = unbox_VkInstance(instance);
18036 auto vk = dispatch_VkInstance(instance);
18037 // End manual dispatchable handle unboxing for instance;
18038 memcpy((VkDebugReportFlagsEXT*)&flags, *readStreamPtrPtr,
18039 sizeof(VkDebugReportFlagsEXT));
18040 *readStreamPtrPtr += sizeof(VkDebugReportFlagsEXT);
18041 memcpy((VkDebugReportObjectTypeEXT*)&objectType, *readStreamPtrPtr,
18042 sizeof(VkDebugReportObjectTypeEXT));
18043 *readStreamPtrPtr += sizeof(VkDebugReportObjectTypeEXT);
18044 memcpy((uint64_t*)&object, *readStreamPtrPtr, sizeof(uint64_t));
18045 *readStreamPtrPtr += sizeof(uint64_t);
18046 memcpy((size_t*)&location, (*readStreamPtrPtr), 8);
18047 android::base::Stream::fromBe64((uint8_t*)&location);
18048 *readStreamPtrPtr += 8;
18049 memcpy((int32_t*)&messageCode, *readStreamPtrPtr, sizeof(int32_t));
18050 *readStreamPtrPtr += sizeof(int32_t);
18051 vkReadStream->loadStringInPlaceWithStreamPtr((char**)&pLayerPrefix,
18052 readStreamPtrPtr);
18053 vkReadStream->loadStringInPlaceWithStreamPtr((char**)&pMessage, readStreamPtrPtr);
18054 if (m_logCalls) {
18055 fprintf(stderr,
18056 "stream %p: call vkDebugReportMessageEXT 0x%llx 0x%llx 0x%llx 0x%llx "
18057 "0x%llx 0x%llx 0x%llx 0x%llx \n",
18058 ioStream, (unsigned long long)instance, (unsigned long long)flags,
18059 (unsigned long long)objectType, (unsigned long long)object,
18060 (unsigned long long)location, (unsigned long long)messageCode,
18061 (unsigned long long)pLayerPrefix, (unsigned long long)pMessage);
18062 }
18063 vk->vkDebugReportMessageEXT(unboxed_instance, flags, objectType, object, location,
18064 messageCode, pLayerPrefix, pMessage);
18065 vkStream->unsetHandleMapping();
18066 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18067 (uintptr_t)snapshotTraceBegin);
18068 size_t snapshotTraceBytes = vkReadStream->endTrace();
18069 if (m_state->snapshotsEnabled()) {
18070 m_state->snapshot()->vkDebugReportMessageEXT(
18071 snapshotTraceBegin, snapshotTraceBytes, &m_pool, instance, flags,
18072 objectType, object, location, messageCode, pLayerPrefix, pMessage);
18073 }
18074 vkReadStream->clearPool();
18075 if (m_queueSubmitWithCommandsEnabled)
18076 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18077 break;
18078 }
18079 #endif
18080 #ifdef VK_EXT_transform_feedback
18081 case OP_vkCmdBindTransformFeedbackBuffersEXT: {
18082 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18083 "VkDecoder vkCmdBindTransformFeedbackBuffersEXT");
18084 VkCommandBuffer commandBuffer;
18085 uint32_t firstBinding;
18086 uint32_t bindingCount;
18087 const VkBuffer* pBuffers;
18088 const VkDeviceSize* pOffsets;
18089 const VkDeviceSize* pSizes;
18090 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
18091 uint64_t cgen_var_0;
18092 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18093 *readStreamPtrPtr += 1 * 8;
18094 *(VkCommandBuffer*)&commandBuffer =
18095 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
18096 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
18097 auto vk = dispatch_VkCommandBuffer(commandBuffer);
18098 // End manual dispatchable handle unboxing for commandBuffer;
18099 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
18100 *readStreamPtrPtr += sizeof(uint32_t);
18101 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
18102 *readStreamPtrPtr += sizeof(uint32_t);
18103 vkReadStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
18104 if (((bindingCount))) {
18105 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
18106 *readStreamPtrPtr += 8 * ((bindingCount));
18107 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
18108 uint64_t tmpval;
18109 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
18110 *(((VkBuffer*)pBuffers) + k) =
18111 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval) : VK_NULL_HANDLE;
18112 }
18113 }
18114 vkReadStream->alloc((void**)&pOffsets,
18115 ((bindingCount)) * sizeof(const VkDeviceSize));
18116 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
18117 ((bindingCount)) * sizeof(const VkDeviceSize));
18118 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
18119 // WARNING PTR CHECK
18120 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
18121 android::base::Stream::fromBe64((uint8_t*)&pSizes);
18122 *readStreamPtrPtr += 8;
18123 if (pSizes) {
18124 vkReadStream->alloc((void**)&pSizes,
18125 ((bindingCount)) * sizeof(const VkDeviceSize));
18126 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
18127 ((bindingCount)) * sizeof(const VkDeviceSize));
18128 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
18129 }
18130 if (m_logCalls) {
18131 fprintf(stderr,
18132 "stream %p: call vkCmdBindTransformFeedbackBuffersEXT 0x%llx 0x%llx "
18133 "0x%llx 0x%llx 0x%llx 0x%llx \n",
18134 ioStream, (unsigned long long)commandBuffer,
18135 (unsigned long long)firstBinding, (unsigned long long)bindingCount,
18136 (unsigned long long)pBuffers, (unsigned long long)pOffsets,
18137 (unsigned long long)pSizes);
18138 }
18139 vk->vkCmdBindTransformFeedbackBuffersEXT(unboxed_commandBuffer, firstBinding,
18140 bindingCount, pBuffers, pOffsets, pSizes);
18141 vkStream->unsetHandleMapping();
18142 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18143 (uintptr_t)snapshotTraceBegin);
18144 size_t snapshotTraceBytes = vkReadStream->endTrace();
18145 if (m_state->snapshotsEnabled()) {
18146 m_state->snapshot()->vkCmdBindTransformFeedbackBuffersEXT(
18147 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
18148 firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
18149 }
18150 vkReadStream->clearPool();
18151 if (m_queueSubmitWithCommandsEnabled)
18152 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18153 break;
18154 }
18155 case OP_vkCmdBeginTransformFeedbackEXT: {
18156 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18157 "VkDecoder vkCmdBeginTransformFeedbackEXT");
18158 VkCommandBuffer commandBuffer;
18159 uint32_t firstCounterBuffer;
18160 uint32_t counterBufferCount;
18161 const VkBuffer* pCounterBuffers;
18162 const VkDeviceSize* pCounterBufferOffsets;
18163 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
18164 uint64_t cgen_var_0;
18165 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18166 *readStreamPtrPtr += 1 * 8;
18167 *(VkCommandBuffer*)&commandBuffer =
18168 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
18169 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
18170 auto vk = dispatch_VkCommandBuffer(commandBuffer);
18171 // End manual dispatchable handle unboxing for commandBuffer;
18172 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
18173 *readStreamPtrPtr += sizeof(uint32_t);
18174 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
18175 *readStreamPtrPtr += sizeof(uint32_t);
18176 // WARNING PTR CHECK
18177 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
18178 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
18179 *readStreamPtrPtr += 8;
18180 if (pCounterBuffers) {
18181 vkReadStream->alloc((void**)&pCounterBuffers,
18182 ((counterBufferCount)) * sizeof(const VkBuffer));
18183 if (((counterBufferCount))) {
18184 uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*readStreamPtrPtr);
18185 *readStreamPtrPtr += 8 * ((counterBufferCount));
18186 for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
18187 uint64_t tmpval;
18188 memcpy(&tmpval, cgen_var_1_0_ptr + k * 8, sizeof(uint64_t));
18189 *(((VkBuffer*)pCounterBuffers) + k) =
18190 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
18191 : VK_NULL_HANDLE;
18192 }
18193 }
18194 }
18195 // WARNING PTR CHECK
18196 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
18197 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
18198 *readStreamPtrPtr += 8;
18199 if (pCounterBufferOffsets) {
18200 vkReadStream->alloc((void**)&pCounterBufferOffsets,
18201 ((counterBufferCount)) * sizeof(const VkDeviceSize));
18202 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr,
18203 ((counterBufferCount)) * sizeof(const VkDeviceSize));
18204 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
18205 }
18206 if (m_logCalls) {
18207 fprintf(stderr,
18208 "stream %p: call vkCmdBeginTransformFeedbackEXT 0x%llx 0x%llx 0x%llx "
18209 "0x%llx 0x%llx \n",
18210 ioStream, (unsigned long long)commandBuffer,
18211 (unsigned long long)firstCounterBuffer,
18212 (unsigned long long)counterBufferCount,
18213 (unsigned long long)pCounterBuffers,
18214 (unsigned long long)pCounterBufferOffsets);
18215 }
18216 vk->vkCmdBeginTransformFeedbackEXT(unboxed_commandBuffer, firstCounterBuffer,
18217 counterBufferCount, pCounterBuffers,
18218 pCounterBufferOffsets);
18219 vkStream->unsetHandleMapping();
18220 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18221 (uintptr_t)snapshotTraceBegin);
18222 size_t snapshotTraceBytes = vkReadStream->endTrace();
18223 if (m_state->snapshotsEnabled()) {
18224 m_state->snapshot()->vkCmdBeginTransformFeedbackEXT(
18225 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
18226 firstCounterBuffer, counterBufferCount, pCounterBuffers,
18227 pCounterBufferOffsets);
18228 }
18229 vkReadStream->clearPool();
18230 if (m_queueSubmitWithCommandsEnabled)
18231 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18232 break;
18233 }
18234 case OP_vkCmdEndTransformFeedbackEXT: {
18235 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18236 "VkDecoder vkCmdEndTransformFeedbackEXT");
18237 VkCommandBuffer commandBuffer;
18238 uint32_t firstCounterBuffer;
18239 uint32_t counterBufferCount;
18240 const VkBuffer* pCounterBuffers;
18241 const VkDeviceSize* pCounterBufferOffsets;
18242 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
18243 uint64_t cgen_var_0;
18244 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18245 *readStreamPtrPtr += 1 * 8;
18246 *(VkCommandBuffer*)&commandBuffer =
18247 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
18248 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
18249 auto vk = dispatch_VkCommandBuffer(commandBuffer);
18250 // End manual dispatchable handle unboxing for commandBuffer;
18251 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
18252 *readStreamPtrPtr += sizeof(uint32_t);
18253 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
18254 *readStreamPtrPtr += sizeof(uint32_t);
18255 // WARNING PTR CHECK
18256 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
18257 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
18258 *readStreamPtrPtr += 8;
18259 if (pCounterBuffers) {
18260 vkReadStream->alloc((void**)&pCounterBuffers,
18261 ((counterBufferCount)) * sizeof(const VkBuffer));
18262 if (((counterBufferCount))) {
18263 uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*readStreamPtrPtr);
18264 *readStreamPtrPtr += 8 * ((counterBufferCount));
18265 for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
18266 uint64_t tmpval;
18267 memcpy(&tmpval, cgen_var_1_0_ptr + k * 8, sizeof(uint64_t));
18268 *(((VkBuffer*)pCounterBuffers) + k) =
18269 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
18270 : VK_NULL_HANDLE;
18271 }
18272 }
18273 }
18274 // WARNING PTR CHECK
18275 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
18276 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
18277 *readStreamPtrPtr += 8;
18278 if (pCounterBufferOffsets) {
18279 vkReadStream->alloc((void**)&pCounterBufferOffsets,
18280 ((counterBufferCount)) * sizeof(const VkDeviceSize));
18281 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr,
18282 ((counterBufferCount)) * sizeof(const VkDeviceSize));
18283 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
18284 }
18285 if (m_logCalls) {
18286 fprintf(stderr,
18287 "stream %p: call vkCmdEndTransformFeedbackEXT 0x%llx 0x%llx 0x%llx "
18288 "0x%llx 0x%llx \n",
18289 ioStream, (unsigned long long)commandBuffer,
18290 (unsigned long long)firstCounterBuffer,
18291 (unsigned long long)counterBufferCount,
18292 (unsigned long long)pCounterBuffers,
18293 (unsigned long long)pCounterBufferOffsets);
18294 }
18295 vk->vkCmdEndTransformFeedbackEXT(unboxed_commandBuffer, firstCounterBuffer,
18296 counterBufferCount, pCounterBuffers,
18297 pCounterBufferOffsets);
18298 vkStream->unsetHandleMapping();
18299 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18300 (uintptr_t)snapshotTraceBegin);
18301 size_t snapshotTraceBytes = vkReadStream->endTrace();
18302 if (m_state->snapshotsEnabled()) {
18303 m_state->snapshot()->vkCmdEndTransformFeedbackEXT(
18304 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
18305 firstCounterBuffer, counterBufferCount, pCounterBuffers,
18306 pCounterBufferOffsets);
18307 }
18308 vkReadStream->clearPool();
18309 if (m_queueSubmitWithCommandsEnabled)
18310 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18311 break;
18312 }
18313 case OP_vkCmdBeginQueryIndexedEXT: {
18314 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18315 "VkDecoder vkCmdBeginQueryIndexedEXT");
18316 VkCommandBuffer commandBuffer;
18317 VkQueryPool queryPool;
18318 uint32_t query;
18319 VkQueryControlFlags flags;
18320 uint32_t index;
18321 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
18322 uint64_t cgen_var_0;
18323 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18324 *readStreamPtrPtr += 1 * 8;
18325 *(VkCommandBuffer*)&commandBuffer =
18326 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
18327 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
18328 auto vk = dispatch_VkCommandBuffer(commandBuffer);
18329 // End manual dispatchable handle unboxing for commandBuffer;
18330 uint64_t cgen_var_1;
18331 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
18332 *readStreamPtrPtr += 1 * 8;
18333 *(VkQueryPool*)&queryPool =
18334 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
18335 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
18336 *readStreamPtrPtr += sizeof(uint32_t);
18337 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr,
18338 sizeof(VkQueryControlFlags));
18339 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
18340 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
18341 *readStreamPtrPtr += sizeof(uint32_t);
18342 if (m_logCalls) {
18343 fprintf(stderr,
18344 "stream %p: call vkCmdBeginQueryIndexedEXT 0x%llx 0x%llx 0x%llx 0x%llx "
18345 "0x%llx \n",
18346 ioStream, (unsigned long long)commandBuffer,
18347 (unsigned long long)queryPool, (unsigned long long)query,
18348 (unsigned long long)flags, (unsigned long long)index);
18349 }
18350 vk->vkCmdBeginQueryIndexedEXT(unboxed_commandBuffer, queryPool, query, flags,
18351 index);
18352 vkStream->unsetHandleMapping();
18353 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18354 (uintptr_t)snapshotTraceBegin);
18355 size_t snapshotTraceBytes = vkReadStream->endTrace();
18356 if (m_state->snapshotsEnabled()) {
18357 m_state->snapshot()->vkCmdBeginQueryIndexedEXT(
18358 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, queryPool,
18359 query, flags, index);
18360 }
18361 vkReadStream->clearPool();
18362 if (m_queueSubmitWithCommandsEnabled)
18363 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18364 break;
18365 }
18366 case OP_vkCmdEndQueryIndexedEXT: {
18367 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18368 "VkDecoder vkCmdEndQueryIndexedEXT");
18369 VkCommandBuffer commandBuffer;
18370 VkQueryPool queryPool;
18371 uint32_t query;
18372 uint32_t index;
18373 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
18374 uint64_t cgen_var_0;
18375 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18376 *readStreamPtrPtr += 1 * 8;
18377 *(VkCommandBuffer*)&commandBuffer =
18378 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
18379 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
18380 auto vk = dispatch_VkCommandBuffer(commandBuffer);
18381 // End manual dispatchable handle unboxing for commandBuffer;
18382 uint64_t cgen_var_1;
18383 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
18384 *readStreamPtrPtr += 1 * 8;
18385 *(VkQueryPool*)&queryPool =
18386 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
18387 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
18388 *readStreamPtrPtr += sizeof(uint32_t);
18389 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
18390 *readStreamPtrPtr += sizeof(uint32_t);
18391 if (m_logCalls) {
18392 fprintf(
18393 stderr,
18394 "stream %p: call vkCmdEndQueryIndexedEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
18395 ioStream, (unsigned long long)commandBuffer, (unsigned long long)queryPool,
18396 (unsigned long long)query, (unsigned long long)index);
18397 }
18398 vk->vkCmdEndQueryIndexedEXT(unboxed_commandBuffer, queryPool, query, index);
18399 vkStream->unsetHandleMapping();
18400 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18401 (uintptr_t)snapshotTraceBegin);
18402 size_t snapshotTraceBytes = vkReadStream->endTrace();
18403 if (m_state->snapshotsEnabled()) {
18404 m_state->snapshot()->vkCmdEndQueryIndexedEXT(
18405 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, queryPool,
18406 query, index);
18407 }
18408 vkReadStream->clearPool();
18409 if (m_queueSubmitWithCommandsEnabled)
18410 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18411 break;
18412 }
18413 case OP_vkCmdDrawIndirectByteCountEXT: {
18414 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18415 "VkDecoder vkCmdDrawIndirectByteCountEXT");
18416 VkCommandBuffer commandBuffer;
18417 uint32_t instanceCount;
18418 uint32_t firstInstance;
18419 VkBuffer counterBuffer;
18420 VkDeviceSize counterBufferOffset;
18421 uint32_t counterOffset;
18422 uint32_t vertexStride;
18423 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
18424 uint64_t cgen_var_0;
18425 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18426 *readStreamPtrPtr += 1 * 8;
18427 *(VkCommandBuffer*)&commandBuffer =
18428 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
18429 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
18430 auto vk = dispatch_VkCommandBuffer(commandBuffer);
18431 // End manual dispatchable handle unboxing for commandBuffer;
18432 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
18433 *readStreamPtrPtr += sizeof(uint32_t);
18434 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
18435 *readStreamPtrPtr += sizeof(uint32_t);
18436 uint64_t cgen_var_1;
18437 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
18438 *readStreamPtrPtr += 1 * 8;
18439 *(VkBuffer*)&counterBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
18440 memcpy((VkDeviceSize*)&counterBufferOffset, *readStreamPtrPtr,
18441 sizeof(VkDeviceSize));
18442 *readStreamPtrPtr += sizeof(VkDeviceSize);
18443 memcpy((uint32_t*)&counterOffset, *readStreamPtrPtr, sizeof(uint32_t));
18444 *readStreamPtrPtr += sizeof(uint32_t);
18445 memcpy((uint32_t*)&vertexStride, *readStreamPtrPtr, sizeof(uint32_t));
18446 *readStreamPtrPtr += sizeof(uint32_t);
18447 if (m_logCalls) {
18448 fprintf(stderr,
18449 "stream %p: call vkCmdDrawIndirectByteCountEXT 0x%llx 0x%llx 0x%llx "
18450 "0x%llx 0x%llx 0x%llx 0x%llx \n",
18451 ioStream, (unsigned long long)commandBuffer,
18452 (unsigned long long)instanceCount, (unsigned long long)firstInstance,
18453 (unsigned long long)counterBuffer,
18454 (unsigned long long)counterBufferOffset,
18455 (unsigned long long)counterOffset, (unsigned long long)vertexStride);
18456 }
18457 vk->vkCmdDrawIndirectByteCountEXT(unboxed_commandBuffer, instanceCount,
18458 firstInstance, counterBuffer, counterBufferOffset,
18459 counterOffset, vertexStride);
18460 vkStream->unsetHandleMapping();
18461 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18462 (uintptr_t)snapshotTraceBegin);
18463 size_t snapshotTraceBytes = vkReadStream->endTrace();
18464 if (m_state->snapshotsEnabled()) {
18465 m_state->snapshot()->vkCmdDrawIndirectByteCountEXT(
18466 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
18467 instanceCount, firstInstance, counterBuffer, counterBufferOffset,
18468 counterOffset, vertexStride);
18469 }
18470 vkReadStream->clearPool();
18471 if (m_queueSubmitWithCommandsEnabled)
18472 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18473 break;
18474 }
18475 #endif
18476 #ifdef VK_EXT_debug_utils
18477 case OP_vkSetDebugUtilsObjectNameEXT: {
18478 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18479 "VkDecoder vkSetDebugUtilsObjectNameEXT");
18480 VkDevice device;
18481 const VkDebugUtilsObjectNameInfoEXT* pNameInfo;
18482 // Begin non wrapped dispatchable handle unboxing for device;
18483 uint64_t cgen_var_0;
18484 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18485 *readStreamPtrPtr += 1 * 8;
18486 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
18487 auto unboxed_device = unbox_VkDevice(device);
18488 auto vk = dispatch_VkDevice(device);
18489 // End manual dispatchable handle unboxing for device;
18490 vkReadStream->alloc((void**)&pNameInfo,
18491 sizeof(const VkDebugUtilsObjectNameInfoEXT));
18492 reservedunmarshal_VkDebugUtilsObjectNameInfoEXT(
18493 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18494 (VkDebugUtilsObjectNameInfoEXT*)(pNameInfo), readStreamPtrPtr);
18495 if (pNameInfo) {
18496 transform_tohost_VkDebugUtilsObjectNameInfoEXT(
18497 m_state, (VkDebugUtilsObjectNameInfoEXT*)(pNameInfo));
18498 }
18499 if (m_logCalls) {
18500 fprintf(stderr, "stream %p: call vkSetDebugUtilsObjectNameEXT 0x%llx 0x%llx \n",
18501 ioStream, (unsigned long long)device, (unsigned long long)pNameInfo);
18502 }
18503 VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
18504 vkSetDebugUtilsObjectNameEXT_VkResult_return =
18505 vk->vkSetDebugUtilsObjectNameEXT(unboxed_device, pNameInfo);
18506 if ((vkSetDebugUtilsObjectNameEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
18507 m_state->on_DeviceLost();
18508 m_state->on_CheckOutOfMemory(vkSetDebugUtilsObjectNameEXT_VkResult_return, opcode,
18509 context);
18510 vkStream->unsetHandleMapping();
18511 vkStream->write(&vkSetDebugUtilsObjectNameEXT_VkResult_return, sizeof(VkResult));
18512 vkStream->commitWrite();
18513 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18514 (uintptr_t)snapshotTraceBegin);
18515 size_t snapshotTraceBytes = vkReadStream->endTrace();
18516 if (m_state->snapshotsEnabled()) {
18517 m_state->snapshot()->vkSetDebugUtilsObjectNameEXT(
18518 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
18519 vkSetDebugUtilsObjectNameEXT_VkResult_return, device, pNameInfo);
18520 }
18521 vkReadStream->clearPool();
18522 if (m_queueSubmitWithCommandsEnabled)
18523 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18524 break;
18525 }
18526 case OP_vkSetDebugUtilsObjectTagEXT: {
18527 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18528 "VkDecoder vkSetDebugUtilsObjectTagEXT");
18529 VkDevice device;
18530 const VkDebugUtilsObjectTagInfoEXT* pTagInfo;
18531 // Begin non wrapped dispatchable handle unboxing for device;
18532 uint64_t cgen_var_0;
18533 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18534 *readStreamPtrPtr += 1 * 8;
18535 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
18536 auto unboxed_device = unbox_VkDevice(device);
18537 auto vk = dispatch_VkDevice(device);
18538 // End manual dispatchable handle unboxing for device;
18539 vkReadStream->alloc((void**)&pTagInfo, sizeof(const VkDebugUtilsObjectTagInfoEXT));
18540 reservedunmarshal_VkDebugUtilsObjectTagInfoEXT(
18541 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18542 (VkDebugUtilsObjectTagInfoEXT*)(pTagInfo), readStreamPtrPtr);
18543 if (pTagInfo) {
18544 transform_tohost_VkDebugUtilsObjectTagInfoEXT(
18545 m_state, (VkDebugUtilsObjectTagInfoEXT*)(pTagInfo));
18546 }
18547 if (m_logCalls) {
18548 fprintf(stderr, "stream %p: call vkSetDebugUtilsObjectTagEXT 0x%llx 0x%llx \n",
18549 ioStream, (unsigned long long)device, (unsigned long long)pTagInfo);
18550 }
18551 VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
18552 vkSetDebugUtilsObjectTagEXT_VkResult_return =
18553 vk->vkSetDebugUtilsObjectTagEXT(unboxed_device, pTagInfo);
18554 if ((vkSetDebugUtilsObjectTagEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
18555 m_state->on_DeviceLost();
18556 m_state->on_CheckOutOfMemory(vkSetDebugUtilsObjectTagEXT_VkResult_return, opcode,
18557 context);
18558 vkStream->unsetHandleMapping();
18559 vkStream->write(&vkSetDebugUtilsObjectTagEXT_VkResult_return, sizeof(VkResult));
18560 vkStream->commitWrite();
18561 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18562 (uintptr_t)snapshotTraceBegin);
18563 size_t snapshotTraceBytes = vkReadStream->endTrace();
18564 if (m_state->snapshotsEnabled()) {
18565 m_state->snapshot()->vkSetDebugUtilsObjectTagEXT(
18566 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
18567 vkSetDebugUtilsObjectTagEXT_VkResult_return, device, pTagInfo);
18568 }
18569 vkReadStream->clearPool();
18570 if (m_queueSubmitWithCommandsEnabled)
18571 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18572 break;
18573 }
18574 case OP_vkQueueBeginDebugUtilsLabelEXT: {
18575 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18576 "VkDecoder vkQueueBeginDebugUtilsLabelEXT");
18577 VkQueue queue;
18578 const VkDebugUtilsLabelEXT* pLabelInfo;
18579 // Begin non wrapped dispatchable handle unboxing for queue;
18580 uint64_t cgen_var_0;
18581 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18582 *readStreamPtrPtr += 1 * 8;
18583 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
18584 auto unboxed_queue = unbox_VkQueue(queue);
18585 auto vk = dispatch_VkQueue(queue);
18586 // End manual dispatchable handle unboxing for queue;
18587 vkReadStream->alloc((void**)&pLabelInfo, sizeof(const VkDebugUtilsLabelEXT));
18588 reservedunmarshal_VkDebugUtilsLabelEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18589 (VkDebugUtilsLabelEXT*)(pLabelInfo),
18590 readStreamPtrPtr);
18591 if (pLabelInfo) {
18592 transform_tohost_VkDebugUtilsLabelEXT(m_state,
18593 (VkDebugUtilsLabelEXT*)(pLabelInfo));
18594 }
18595 if (m_logCalls) {
18596 fprintf(stderr,
18597 "stream %p: call vkQueueBeginDebugUtilsLabelEXT 0x%llx 0x%llx \n",
18598 ioStream, (unsigned long long)queue, (unsigned long long)pLabelInfo);
18599 }
18600 vk->vkQueueBeginDebugUtilsLabelEXT(unboxed_queue, pLabelInfo);
18601 vkStream->unsetHandleMapping();
18602 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18603 (uintptr_t)snapshotTraceBegin);
18604 size_t snapshotTraceBytes = vkReadStream->endTrace();
18605 if (m_state->snapshotsEnabled()) {
18606 m_state->snapshot()->vkQueueBeginDebugUtilsLabelEXT(
18607 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, pLabelInfo);
18608 }
18609 vkReadStream->clearPool();
18610 if (m_queueSubmitWithCommandsEnabled)
18611 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18612 break;
18613 }
18614 case OP_vkQueueEndDebugUtilsLabelEXT: {
18615 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18616 "VkDecoder vkQueueEndDebugUtilsLabelEXT");
18617 VkQueue queue;
18618 // Begin non wrapped dispatchable handle unboxing for queue;
18619 uint64_t cgen_var_0;
18620 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18621 *readStreamPtrPtr += 1 * 8;
18622 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
18623 auto unboxed_queue = unbox_VkQueue(queue);
18624 auto vk = dispatch_VkQueue(queue);
18625 // End manual dispatchable handle unboxing for queue;
18626 if (m_logCalls) {
18627 fprintf(stderr, "stream %p: call vkQueueEndDebugUtilsLabelEXT 0x%llx \n",
18628 ioStream, (unsigned long long)queue);
18629 }
18630 vk->vkQueueEndDebugUtilsLabelEXT(unboxed_queue);
18631 vkStream->unsetHandleMapping();
18632 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18633 (uintptr_t)snapshotTraceBegin);
18634 size_t snapshotTraceBytes = vkReadStream->endTrace();
18635 if (m_state->snapshotsEnabled()) {
18636 m_state->snapshot()->vkQueueEndDebugUtilsLabelEXT(
18637 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue);
18638 }
18639 vkReadStream->clearPool();
18640 if (m_queueSubmitWithCommandsEnabled)
18641 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18642 break;
18643 }
18644 case OP_vkQueueInsertDebugUtilsLabelEXT: {
18645 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18646 "VkDecoder vkQueueInsertDebugUtilsLabelEXT");
18647 VkQueue queue;
18648 const VkDebugUtilsLabelEXT* pLabelInfo;
18649 // Begin non wrapped dispatchable handle unboxing for queue;
18650 uint64_t cgen_var_0;
18651 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18652 *readStreamPtrPtr += 1 * 8;
18653 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
18654 auto unboxed_queue = unbox_VkQueue(queue);
18655 auto vk = dispatch_VkQueue(queue);
18656 // End manual dispatchable handle unboxing for queue;
18657 vkReadStream->alloc((void**)&pLabelInfo, sizeof(const VkDebugUtilsLabelEXT));
18658 reservedunmarshal_VkDebugUtilsLabelEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18659 (VkDebugUtilsLabelEXT*)(pLabelInfo),
18660 readStreamPtrPtr);
18661 if (pLabelInfo) {
18662 transform_tohost_VkDebugUtilsLabelEXT(m_state,
18663 (VkDebugUtilsLabelEXT*)(pLabelInfo));
18664 }
18665 if (m_logCalls) {
18666 fprintf(stderr,
18667 "stream %p: call vkQueueInsertDebugUtilsLabelEXT 0x%llx 0x%llx \n",
18668 ioStream, (unsigned long long)queue, (unsigned long long)pLabelInfo);
18669 }
18670 vk->vkQueueInsertDebugUtilsLabelEXT(unboxed_queue, pLabelInfo);
18671 vkStream->unsetHandleMapping();
18672 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18673 (uintptr_t)snapshotTraceBegin);
18674 size_t snapshotTraceBytes = vkReadStream->endTrace();
18675 if (m_state->snapshotsEnabled()) {
18676 m_state->snapshot()->vkQueueInsertDebugUtilsLabelEXT(
18677 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, pLabelInfo);
18678 }
18679 vkReadStream->clearPool();
18680 if (m_queueSubmitWithCommandsEnabled)
18681 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18682 break;
18683 }
18684 case OP_vkCmdBeginDebugUtilsLabelEXT: {
18685 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18686 "VkDecoder vkCmdBeginDebugUtilsLabelEXT");
18687 VkCommandBuffer commandBuffer;
18688 const VkDebugUtilsLabelEXT* pLabelInfo;
18689 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
18690 uint64_t cgen_var_0;
18691 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18692 *readStreamPtrPtr += 1 * 8;
18693 *(VkCommandBuffer*)&commandBuffer =
18694 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
18695 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
18696 auto vk = dispatch_VkCommandBuffer(commandBuffer);
18697 // End manual dispatchable handle unboxing for commandBuffer;
18698 vkReadStream->alloc((void**)&pLabelInfo, sizeof(const VkDebugUtilsLabelEXT));
18699 reservedunmarshal_VkDebugUtilsLabelEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18700 (VkDebugUtilsLabelEXT*)(pLabelInfo),
18701 readStreamPtrPtr);
18702 if (pLabelInfo) {
18703 transform_tohost_VkDebugUtilsLabelEXT(m_state,
18704 (VkDebugUtilsLabelEXT*)(pLabelInfo));
18705 }
18706 if (m_logCalls) {
18707 fprintf(stderr, "stream %p: call vkCmdBeginDebugUtilsLabelEXT 0x%llx 0x%llx \n",
18708 ioStream, (unsigned long long)commandBuffer,
18709 (unsigned long long)pLabelInfo);
18710 }
18711 vk->vkCmdBeginDebugUtilsLabelEXT(unboxed_commandBuffer, pLabelInfo);
18712 vkStream->unsetHandleMapping();
18713 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18714 (uintptr_t)snapshotTraceBegin);
18715 size_t snapshotTraceBytes = vkReadStream->endTrace();
18716 if (m_state->snapshotsEnabled()) {
18717 m_state->snapshot()->vkCmdBeginDebugUtilsLabelEXT(
18718 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, pLabelInfo);
18719 }
18720 vkReadStream->clearPool();
18721 if (m_queueSubmitWithCommandsEnabled)
18722 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18723 break;
18724 }
18725 case OP_vkCmdEndDebugUtilsLabelEXT: {
18726 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18727 "VkDecoder vkCmdEndDebugUtilsLabelEXT");
18728 VkCommandBuffer commandBuffer;
18729 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
18730 uint64_t cgen_var_0;
18731 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18732 *readStreamPtrPtr += 1 * 8;
18733 *(VkCommandBuffer*)&commandBuffer =
18734 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
18735 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
18736 auto vk = dispatch_VkCommandBuffer(commandBuffer);
18737 // End manual dispatchable handle unboxing for commandBuffer;
18738 if (m_logCalls) {
18739 fprintf(stderr, "stream %p: call vkCmdEndDebugUtilsLabelEXT 0x%llx \n",
18740 ioStream, (unsigned long long)commandBuffer);
18741 }
18742 vk->vkCmdEndDebugUtilsLabelEXT(unboxed_commandBuffer);
18743 vkStream->unsetHandleMapping();
18744 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18745 (uintptr_t)snapshotTraceBegin);
18746 size_t snapshotTraceBytes = vkReadStream->endTrace();
18747 if (m_state->snapshotsEnabled()) {
18748 m_state->snapshot()->vkCmdEndDebugUtilsLabelEXT(
18749 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer);
18750 }
18751 vkReadStream->clearPool();
18752 if (m_queueSubmitWithCommandsEnabled)
18753 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18754 break;
18755 }
18756 case OP_vkCmdInsertDebugUtilsLabelEXT: {
18757 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18758 "VkDecoder vkCmdInsertDebugUtilsLabelEXT");
18759 VkCommandBuffer commandBuffer;
18760 const VkDebugUtilsLabelEXT* pLabelInfo;
18761 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
18762 uint64_t cgen_var_0;
18763 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18764 *readStreamPtrPtr += 1 * 8;
18765 *(VkCommandBuffer*)&commandBuffer =
18766 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
18767 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
18768 auto vk = dispatch_VkCommandBuffer(commandBuffer);
18769 // End manual dispatchable handle unboxing for commandBuffer;
18770 vkReadStream->alloc((void**)&pLabelInfo, sizeof(const VkDebugUtilsLabelEXT));
18771 reservedunmarshal_VkDebugUtilsLabelEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18772 (VkDebugUtilsLabelEXT*)(pLabelInfo),
18773 readStreamPtrPtr);
18774 if (pLabelInfo) {
18775 transform_tohost_VkDebugUtilsLabelEXT(m_state,
18776 (VkDebugUtilsLabelEXT*)(pLabelInfo));
18777 }
18778 if (m_logCalls) {
18779 fprintf(stderr,
18780 "stream %p: call vkCmdInsertDebugUtilsLabelEXT 0x%llx 0x%llx \n",
18781 ioStream, (unsigned long long)commandBuffer,
18782 (unsigned long long)pLabelInfo);
18783 }
18784 vk->vkCmdInsertDebugUtilsLabelEXT(unboxed_commandBuffer, pLabelInfo);
18785 vkStream->unsetHandleMapping();
18786 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18787 (uintptr_t)snapshotTraceBegin);
18788 size_t snapshotTraceBytes = vkReadStream->endTrace();
18789 if (m_state->snapshotsEnabled()) {
18790 m_state->snapshot()->vkCmdInsertDebugUtilsLabelEXT(
18791 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, pLabelInfo);
18792 }
18793 vkReadStream->clearPool();
18794 if (m_queueSubmitWithCommandsEnabled)
18795 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18796 break;
18797 }
18798 case OP_vkCreateDebugUtilsMessengerEXT: {
18799 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18800 "VkDecoder vkCreateDebugUtilsMessengerEXT");
18801 VkInstance instance;
18802 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo;
18803 const VkAllocationCallbacks* pAllocator;
18804 VkDebugUtilsMessengerEXT* pMessenger;
18805 // Begin non wrapped dispatchable handle unboxing for instance;
18806 uint64_t cgen_var_0;
18807 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18808 *readStreamPtrPtr += 1 * 8;
18809 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
18810 auto unboxed_instance = unbox_VkInstance(instance);
18811 auto vk = dispatch_VkInstance(instance);
18812 // End manual dispatchable handle unboxing for instance;
18813 vkReadStream->alloc((void**)&pCreateInfo,
18814 sizeof(const VkDebugUtilsMessengerCreateInfoEXT));
18815 reservedunmarshal_VkDebugUtilsMessengerCreateInfoEXT(
18816 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18817 (VkDebugUtilsMessengerCreateInfoEXT*)(pCreateInfo), readStreamPtrPtr);
18818 // WARNING PTR CHECK
18819 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
18820 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
18821 *readStreamPtrPtr += 8;
18822 if (pAllocator) {
18823 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
18824 reservedunmarshal_VkAllocationCallbacks(
18825 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18826 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
18827 }
18828 // Begin manual dispatchable handle unboxing for pMessenger;
18829 vkReadStream->unsetHandleMapping();
18830 vkReadStream->alloc((void**)&pMessenger, sizeof(VkDebugUtilsMessengerEXT));
18831 uint64_t cgen_var_2;
18832 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
18833 *readStreamPtrPtr += 8;
18834 *(VkDebugUtilsMessengerEXT*)pMessenger =
18835 (VkDebugUtilsMessengerEXT)(VkDebugUtilsMessengerEXT)((
18836 VkDebugUtilsMessengerEXT)(*&cgen_var_2));
18837 if (pCreateInfo) {
18838 transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
18839 m_state, (VkDebugUtilsMessengerCreateInfoEXT*)(pCreateInfo));
18840 }
18841 if (pAllocator) {
18842 transform_tohost_VkAllocationCallbacks(m_state,
18843 (VkAllocationCallbacks*)(pAllocator));
18844 }
18845 if (m_logCalls) {
18846 fprintf(stderr,
18847 "stream %p: call vkCreateDebugUtilsMessengerEXT 0x%llx 0x%llx 0x%llx "
18848 "0x%llx \n",
18849 ioStream, (unsigned long long)instance, (unsigned long long)pCreateInfo,
18850 (unsigned long long)pAllocator, (unsigned long long)pMessenger);
18851 }
18852 VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
18853 vkCreateDebugUtilsMessengerEXT_VkResult_return = vk->vkCreateDebugUtilsMessengerEXT(
18854 unboxed_instance, pCreateInfo, pAllocator, pMessenger);
18855 if ((vkCreateDebugUtilsMessengerEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
18856 m_state->on_DeviceLost();
18857 m_state->on_CheckOutOfMemory(vkCreateDebugUtilsMessengerEXT_VkResult_return, opcode,
18858 context);
18859 vkStream->unsetHandleMapping();
18860 // Begin auto non dispatchable handle create for pMessenger;
18861 if (vkCreateDebugUtilsMessengerEXT_VkResult_return == VK_SUCCESS)
18862 vkStream->setHandleMapping(&m_boxedHandleCreateMapping);
18863 uint64_t cgen_var_3;
18864 static_assert(
18865 8 == sizeof(VkDebugUtilsMessengerEXT),
18866 "handle map overwrite requires VkDebugUtilsMessengerEXT to be 8 bytes long");
18867 vkStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT(
18868 (VkDebugUtilsMessengerEXT*)pMessenger, 1);
18869 vkStream->write((VkDebugUtilsMessengerEXT*)pMessenger, 8 * 1);
18870 // Begin auto non dispatchable handle create for pMessenger;
18871 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
18872 vkStream->write(&vkCreateDebugUtilsMessengerEXT_VkResult_return, sizeof(VkResult));
18873 vkStream->commitWrite();
18874 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18875 (uintptr_t)snapshotTraceBegin);
18876 size_t snapshotTraceBytes = vkReadStream->endTrace();
18877 if (m_state->snapshotsEnabled()) {
18878 m_state->snapshot()->vkCreateDebugUtilsMessengerEXT(
18879 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
18880 vkCreateDebugUtilsMessengerEXT_VkResult_return, instance, pCreateInfo,
18881 pAllocator, pMessenger);
18882 }
18883 vkReadStream->clearPool();
18884 if (m_queueSubmitWithCommandsEnabled)
18885 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18886 break;
18887 }
18888 case OP_vkDestroyDebugUtilsMessengerEXT: {
18889 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18890 "VkDecoder vkDestroyDebugUtilsMessengerEXT");
18891 VkInstance instance;
18892 VkDebugUtilsMessengerEXT messenger;
18893 const VkAllocationCallbacks* pAllocator;
18894 // Begin non wrapped dispatchable handle unboxing for instance;
18895 uint64_t cgen_var_0;
18896 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18897 *readStreamPtrPtr += 1 * 8;
18898 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
18899 auto unboxed_instance = unbox_VkInstance(instance);
18900 auto vk = dispatch_VkInstance(instance);
18901 // End manual dispatchable handle unboxing for instance;
18902 // Begin manual non dispatchable handle destroy unboxing for messenger;
18903 VkDebugUtilsMessengerEXT boxed_messenger_preserve;
18904 uint64_t cgen_var_1;
18905 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
18906 *readStreamPtrPtr += 1 * 8;
18907 *(VkDebugUtilsMessengerEXT*)&messenger =
18908 (VkDebugUtilsMessengerEXT)(VkDebugUtilsMessengerEXT)((
18909 VkDebugUtilsMessengerEXT)(*&cgen_var_1));
18910 boxed_messenger_preserve = messenger;
18911 messenger = try_unbox_VkDebugUtilsMessengerEXT(messenger);
18912 // WARNING PTR CHECK
18913 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
18914 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
18915 *readStreamPtrPtr += 8;
18916 if (pAllocator) {
18917 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
18918 reservedunmarshal_VkAllocationCallbacks(
18919 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18920 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
18921 }
18922 if (pAllocator) {
18923 transform_tohost_VkAllocationCallbacks(m_state,
18924 (VkAllocationCallbacks*)(pAllocator));
18925 }
18926 if (m_logCalls) {
18927 fprintf(
18928 stderr,
18929 "stream %p: call vkDestroyDebugUtilsMessengerEXT 0x%llx 0x%llx 0x%llx \n",
18930 ioStream, (unsigned long long)instance, (unsigned long long)messenger,
18931 (unsigned long long)pAllocator);
18932 }
18933 vk->vkDestroyDebugUtilsMessengerEXT(unboxed_instance, messenger, pAllocator);
18934 vkStream->unsetHandleMapping();
18935 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18936 (uintptr_t)snapshotTraceBegin);
18937 size_t snapshotTraceBytes = vkReadStream->endTrace();
18938 if (m_state->snapshotsEnabled()) {
18939 m_state->snapshot()->vkDestroyDebugUtilsMessengerEXT(
18940 snapshotTraceBegin, snapshotTraceBytes, &m_pool, instance,
18941 boxed_messenger_preserve, pAllocator);
18942 }
18943 delete_VkDebugUtilsMessengerEXT(boxed_messenger_preserve);
18944 vkReadStream->clearPool();
18945 if (m_queueSubmitWithCommandsEnabled)
18946 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
18947 break;
18948 }
18949 case OP_vkSubmitDebugUtilsMessageEXT: {
18950 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
18951 "VkDecoder vkSubmitDebugUtilsMessageEXT");
18952 VkInstance instance;
18953 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity;
18954 VkDebugUtilsMessageTypeFlagsEXT messageTypes;
18955 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData;
18956 // Begin non wrapped dispatchable handle unboxing for instance;
18957 uint64_t cgen_var_0;
18958 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
18959 *readStreamPtrPtr += 1 * 8;
18960 *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
18961 auto unboxed_instance = unbox_VkInstance(instance);
18962 auto vk = dispatch_VkInstance(instance);
18963 // End manual dispatchable handle unboxing for instance;
18964 memcpy((VkDebugUtilsMessageSeverityFlagBitsEXT*)&messageSeverity, *readStreamPtrPtr,
18965 sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
18966 *readStreamPtrPtr += sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT);
18967 memcpy((VkDebugUtilsMessageTypeFlagsEXT*)&messageTypes, *readStreamPtrPtr,
18968 sizeof(VkDebugUtilsMessageTypeFlagsEXT));
18969 *readStreamPtrPtr += sizeof(VkDebugUtilsMessageTypeFlagsEXT);
18970 vkReadStream->alloc((void**)&pCallbackData,
18971 sizeof(const VkDebugUtilsMessengerCallbackDataEXT));
18972 reservedunmarshal_VkDebugUtilsMessengerCallbackDataEXT(
18973 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
18974 (VkDebugUtilsMessengerCallbackDataEXT*)(pCallbackData), readStreamPtrPtr);
18975 if (pCallbackData) {
18976 transform_tohost_VkDebugUtilsMessengerCallbackDataEXT(
18977 m_state, (VkDebugUtilsMessengerCallbackDataEXT*)(pCallbackData));
18978 }
18979 if (m_logCalls) {
18980 fprintf(stderr,
18981 "stream %p: call vkSubmitDebugUtilsMessageEXT 0x%llx 0x%llx 0x%llx "
18982 "0x%llx \n",
18983 ioStream, (unsigned long long)instance,
18984 (unsigned long long)messageSeverity, (unsigned long long)messageTypes,
18985 (unsigned long long)pCallbackData);
18986 }
18987 vk->vkSubmitDebugUtilsMessageEXT(unboxed_instance, messageSeverity, messageTypes,
18988 pCallbackData);
18989 vkStream->unsetHandleMapping();
18990 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
18991 (uintptr_t)snapshotTraceBegin);
18992 size_t snapshotTraceBytes = vkReadStream->endTrace();
18993 if (m_state->snapshotsEnabled()) {
18994 m_state->snapshot()->vkSubmitDebugUtilsMessageEXT(
18995 snapshotTraceBegin, snapshotTraceBytes, &m_pool, instance, messageSeverity,
18996 messageTypes, pCallbackData);
18997 }
18998 vkReadStream->clearPool();
18999 if (m_queueSubmitWithCommandsEnabled)
19000 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19001 break;
19002 }
19003 #endif
19004 #ifdef VK_EXT_image_drm_format_modifier
19005 case OP_vkGetImageDrmFormatModifierPropertiesEXT: {
19006 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19007 "VkDecoder vkGetImageDrmFormatModifierPropertiesEXT");
19008 VkDevice device;
19009 VkImage image;
19010 VkImageDrmFormatModifierPropertiesEXT* pProperties;
19011 // Begin non wrapped dispatchable handle unboxing for device;
19012 uint64_t cgen_var_0;
19013 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19014 *readStreamPtrPtr += 1 * 8;
19015 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
19016 auto unboxed_device = unbox_VkDevice(device);
19017 auto vk = dispatch_VkDevice(device);
19018 // End manual dispatchable handle unboxing for device;
19019 uint64_t cgen_var_1;
19020 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
19021 *readStreamPtrPtr += 1 * 8;
19022 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
19023 // Begin manual dispatchable handle unboxing for pProperties;
19024 vkReadStream->unsetHandleMapping();
19025 vkReadStream->alloc((void**)&pProperties,
19026 sizeof(VkImageDrmFormatModifierPropertiesEXT));
19027 reservedunmarshal_VkImageDrmFormatModifierPropertiesEXT(
19028 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19029 (VkImageDrmFormatModifierPropertiesEXT*)(pProperties), readStreamPtrPtr);
19030 if (pProperties) {
19031 transform_tohost_VkImageDrmFormatModifierPropertiesEXT(
19032 m_state, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties));
19033 }
19034 if (m_logCalls) {
19035 fprintf(stderr,
19036 "stream %p: call vkGetImageDrmFormatModifierPropertiesEXT 0x%llx "
19037 "0x%llx 0x%llx \n",
19038 ioStream, (unsigned long long)device, (unsigned long long)image,
19039 (unsigned long long)pProperties);
19040 }
19041 VkResult vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return = (VkResult)0;
19042 vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return =
19043 vk->vkGetImageDrmFormatModifierPropertiesEXT(unboxed_device, image,
19044 pProperties);
19045 if ((vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return) ==
19046 VK_ERROR_DEVICE_LOST)
19047 m_state->on_DeviceLost();
19048 m_state->on_CheckOutOfMemory(
19049 vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return, opcode, context);
19050 vkStream->unsetHandleMapping();
19051 if (pProperties) {
19052 transform_fromhost_VkImageDrmFormatModifierPropertiesEXT(
19053 m_state, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties));
19054 }
19055 marshal_VkImageDrmFormatModifierPropertiesEXT(
19056 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19057 (VkImageDrmFormatModifierPropertiesEXT*)(pProperties));
19058 vkStream->write(&vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return,
19059 sizeof(VkResult));
19060 vkStream->commitWrite();
19061 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19062 (uintptr_t)snapshotTraceBegin);
19063 size_t snapshotTraceBytes = vkReadStream->endTrace();
19064 if (m_state->snapshotsEnabled()) {
19065 m_state->snapshot()->vkGetImageDrmFormatModifierPropertiesEXT(
19066 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
19067 vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return, device, image,
19068 pProperties);
19069 }
19070 vkReadStream->clearPool();
19071 if (m_queueSubmitWithCommandsEnabled)
19072 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19073 break;
19074 }
19075 #endif
19076 #ifdef VK_EXT_external_memory_host
19077 case OP_vkGetMemoryHostPointerPropertiesEXT: {
19078 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19079 "VkDecoder vkGetMemoryHostPointerPropertiesEXT");
19080 VkDevice device;
19081 VkExternalMemoryHandleTypeFlagBits handleType;
19082 const void* pHostPointer;
19083 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties;
19084 // Begin non wrapped dispatchable handle unboxing for device;
19085 uint64_t cgen_var_0;
19086 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19087 *readStreamPtrPtr += 1 * 8;
19088 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
19089 auto unboxed_device = unbox_VkDevice(device);
19090 auto vk = dispatch_VkDevice(device);
19091 // End manual dispatchable handle unboxing for device;
19092 memcpy((VkExternalMemoryHandleTypeFlagBits*)&handleType, *readStreamPtrPtr,
19093 sizeof(VkExternalMemoryHandleTypeFlagBits));
19094 *readStreamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
19095 vkReadStream->alloc((void**)&pHostPointer, sizeof(const uint8_t));
19096 memcpy((void*)pHostPointer, *readStreamPtrPtr, sizeof(const uint8_t));
19097 *readStreamPtrPtr += sizeof(const uint8_t);
19098 // Begin manual dispatchable handle unboxing for pMemoryHostPointerProperties;
19099 vkReadStream->unsetHandleMapping();
19100 vkReadStream->alloc((void**)&pMemoryHostPointerProperties,
19101 sizeof(VkMemoryHostPointerPropertiesEXT));
19102 reservedunmarshal_VkMemoryHostPointerPropertiesEXT(
19103 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19104 (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties),
19105 readStreamPtrPtr);
19106 if (pMemoryHostPointerProperties) {
19107 transform_tohost_VkMemoryHostPointerPropertiesEXT(
19108 m_state, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
19109 }
19110 if (m_logCalls) {
19111 fprintf(stderr,
19112 "stream %p: call vkGetMemoryHostPointerPropertiesEXT 0x%llx 0x%llx "
19113 "0x%llx 0x%llx \n",
19114 ioStream, (unsigned long long)device, (unsigned long long)handleType,
19115 (unsigned long long)pHostPointer,
19116 (unsigned long long)pMemoryHostPointerProperties);
19117 }
19118 VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
19119 vkGetMemoryHostPointerPropertiesEXT_VkResult_return =
19120 vk->vkGetMemoryHostPointerPropertiesEXT(
19121 unboxed_device, handleType, pHostPointer, pMemoryHostPointerProperties);
19122 if ((vkGetMemoryHostPointerPropertiesEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
19123 m_state->on_DeviceLost();
19124 m_state->on_CheckOutOfMemory(vkGetMemoryHostPointerPropertiesEXT_VkResult_return,
19125 opcode, context);
19126 vkStream->unsetHandleMapping();
19127 if (pMemoryHostPointerProperties) {
19128 transform_fromhost_VkMemoryHostPointerPropertiesEXT(
19129 m_state, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
19130 }
19131 marshal_VkMemoryHostPointerPropertiesEXT(
19132 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19133 (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
19134 vkStream->write(&vkGetMemoryHostPointerPropertiesEXT_VkResult_return,
19135 sizeof(VkResult));
19136 vkStream->commitWrite();
19137 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19138 (uintptr_t)snapshotTraceBegin);
19139 size_t snapshotTraceBytes = vkReadStream->endTrace();
19140 if (m_state->snapshotsEnabled()) {
19141 m_state->snapshot()->vkGetMemoryHostPointerPropertiesEXT(
19142 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
19143 vkGetMemoryHostPointerPropertiesEXT_VkResult_return, device, handleType,
19144 pHostPointer, pMemoryHostPointerProperties);
19145 }
19146 vkReadStream->clearPool();
19147 if (m_queueSubmitWithCommandsEnabled)
19148 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19149 break;
19150 }
19151 #endif
19152 #ifdef VK_EXT_tooling_info
19153 case OP_vkGetPhysicalDeviceToolPropertiesEXT: {
19154 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19155 "VkDecoder vkGetPhysicalDeviceToolPropertiesEXT");
19156 VkPhysicalDevice physicalDevice;
19157 uint32_t* pToolCount;
19158 VkPhysicalDeviceToolProperties* pToolProperties;
19159 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
19160 uint64_t cgen_var_0;
19161 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19162 *readStreamPtrPtr += 1 * 8;
19163 *(VkPhysicalDevice*)&physicalDevice =
19164 (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
19165 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
19166 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
19167 // End manual dispatchable handle unboxing for physicalDevice;
19168 // Begin manual dispatchable handle unboxing for pToolCount;
19169 vkReadStream->unsetHandleMapping();
19170 // WARNING PTR CHECK
19171 memcpy((uint32_t**)&pToolCount, (*readStreamPtrPtr), 8);
19172 android::base::Stream::fromBe64((uint8_t*)&pToolCount);
19173 *readStreamPtrPtr += 8;
19174 if (pToolCount) {
19175 vkReadStream->alloc((void**)&pToolCount, sizeof(uint32_t));
19176 memcpy((uint32_t*)pToolCount, *readStreamPtrPtr, sizeof(uint32_t));
19177 *readStreamPtrPtr += sizeof(uint32_t);
19178 }
19179 // Begin manual dispatchable handle unboxing for pToolProperties;
19180 vkReadStream->unsetHandleMapping();
19181 // WARNING PTR CHECK
19182 memcpy((VkPhysicalDeviceToolProperties**)&pToolProperties, (*readStreamPtrPtr), 8);
19183 android::base::Stream::fromBe64((uint8_t*)&pToolProperties);
19184 *readStreamPtrPtr += 8;
19185 if (pToolProperties) {
19186 vkReadStream->alloc((void**)&pToolProperties,
19187 (*(pToolCount)) * sizeof(VkPhysicalDeviceToolProperties));
19188 for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
19189 reservedunmarshal_VkPhysicalDeviceToolProperties(
19190 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19191 (VkPhysicalDeviceToolProperties*)(pToolProperties + i),
19192 readStreamPtrPtr);
19193 }
19194 }
19195 if (pToolCount) {
19196 if (pToolProperties) {
19197 for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
19198 transform_tohost_VkPhysicalDeviceToolProperties(
19199 m_state, (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
19200 }
19201 }
19202 }
19203 if (m_logCalls) {
19204 fprintf(stderr,
19205 "stream %p: call vkGetPhysicalDeviceToolPropertiesEXT 0x%llx 0x%llx "
19206 "0x%llx \n",
19207 ioStream, (unsigned long long)physicalDevice,
19208 (unsigned long long)pToolCount, (unsigned long long)pToolProperties);
19209 }
19210 VkResult vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return = (VkResult)0;
19211 vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
19212 vk->vkGetPhysicalDeviceToolPropertiesEXT(unboxed_physicalDevice, pToolCount,
19213 pToolProperties);
19214 if ((vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
19215 m_state->on_DeviceLost();
19216 m_state->on_CheckOutOfMemory(vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return,
19217 opcode, context);
19218 vkStream->unsetHandleMapping();
19219 // WARNING PTR CHECK
19220 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pToolCount;
19221 vkStream->putBe64(cgen_var_3);
19222 if (pToolCount) {
19223 vkStream->write((uint32_t*)pToolCount, sizeof(uint32_t));
19224 }
19225 if (pToolCount) {
19226 if (pToolProperties) {
19227 for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
19228 transform_fromhost_VkPhysicalDeviceToolProperties(
19229 m_state, (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
19230 }
19231 }
19232 }
19233 // WARNING PTR CHECK
19234 uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pToolProperties;
19235 vkStream->putBe64(cgen_var_4);
19236 if (pToolProperties) {
19237 if (pToolCount) {
19238 for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
19239 marshal_VkPhysicalDeviceToolProperties(
19240 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19241 (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
19242 }
19243 }
19244 }
19245 vkStream->write(&vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return,
19246 sizeof(VkResult));
19247 vkStream->commitWrite();
19248 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19249 (uintptr_t)snapshotTraceBegin);
19250 size_t snapshotTraceBytes = vkReadStream->endTrace();
19251 if (m_state->snapshotsEnabled()) {
19252 m_state->snapshot()->vkGetPhysicalDeviceToolPropertiesEXT(
19253 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
19254 vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return, physicalDevice,
19255 pToolCount, pToolProperties);
19256 }
19257 vkReadStream->clearPool();
19258 if (m_queueSubmitWithCommandsEnabled)
19259 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19260 break;
19261 }
19262 #endif
19263 #ifdef VK_EXT_line_rasterization
19264 case OP_vkCmdSetLineStippleEXT: {
19265 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19266 "VkDecoder vkCmdSetLineStippleEXT");
19267 VkCommandBuffer commandBuffer;
19268 uint32_t lineStippleFactor;
19269 uint16_t lineStipplePattern;
19270 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19271 uint64_t cgen_var_0;
19272 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19273 *readStreamPtrPtr += 1 * 8;
19274 *(VkCommandBuffer*)&commandBuffer =
19275 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19276 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19277 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19278 // End manual dispatchable handle unboxing for commandBuffer;
19279 memcpy((uint32_t*)&lineStippleFactor, *readStreamPtrPtr, sizeof(uint32_t));
19280 *readStreamPtrPtr += sizeof(uint32_t);
19281 memcpy((uint16_t*)&lineStipplePattern, *readStreamPtrPtr, sizeof(uint16_t));
19282 *readStreamPtrPtr += sizeof(uint16_t);
19283 if (m_logCalls) {
19284 fprintf(stderr,
19285 "stream %p: call vkCmdSetLineStippleEXT 0x%llx 0x%llx 0x%llx \n",
19286 ioStream, (unsigned long long)commandBuffer,
19287 (unsigned long long)lineStippleFactor,
19288 (unsigned long long)lineStipplePattern);
19289 }
19290 vk->vkCmdSetLineStippleEXT(unboxed_commandBuffer, lineStippleFactor,
19291 lineStipplePattern);
19292 vkStream->unsetHandleMapping();
19293 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19294 (uintptr_t)snapshotTraceBegin);
19295 size_t snapshotTraceBytes = vkReadStream->endTrace();
19296 if (m_state->snapshotsEnabled()) {
19297 m_state->snapshot()->vkCmdSetLineStippleEXT(
19298 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
19299 lineStippleFactor, lineStipplePattern);
19300 }
19301 vkReadStream->clearPool();
19302 if (m_queueSubmitWithCommandsEnabled)
19303 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19304 break;
19305 }
19306 #endif
19307 #ifdef VK_EXT_extended_dynamic_state
19308 case OP_vkCmdSetCullModeEXT: {
19309 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19310 "VkDecoder vkCmdSetCullModeEXT");
19311 VkCommandBuffer commandBuffer;
19312 VkCullModeFlags cullMode;
19313 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19314 uint64_t cgen_var_0;
19315 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19316 *readStreamPtrPtr += 1 * 8;
19317 *(VkCommandBuffer*)&commandBuffer =
19318 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19319 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19320 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19321 // End manual dispatchable handle unboxing for commandBuffer;
19322 memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
19323 *readStreamPtrPtr += sizeof(VkCullModeFlags);
19324 if (m_logCalls) {
19325 fprintf(stderr, "stream %p: call vkCmdSetCullModeEXT 0x%llx 0x%llx \n",
19326 ioStream, (unsigned long long)commandBuffer,
19327 (unsigned long long)cullMode);
19328 }
19329 vk->vkCmdSetCullModeEXT(unboxed_commandBuffer, cullMode);
19330 vkStream->unsetHandleMapping();
19331 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19332 (uintptr_t)snapshotTraceBegin);
19333 size_t snapshotTraceBytes = vkReadStream->endTrace();
19334 if (m_state->snapshotsEnabled()) {
19335 m_state->snapshot()->vkCmdSetCullModeEXT(snapshotTraceBegin, snapshotTraceBytes,
19336 &m_pool, commandBuffer, cullMode);
19337 }
19338 vkReadStream->clearPool();
19339 if (m_queueSubmitWithCommandsEnabled)
19340 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19341 break;
19342 }
19343 case OP_vkCmdSetFrontFaceEXT: {
19344 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19345 "VkDecoder vkCmdSetFrontFaceEXT");
19346 VkCommandBuffer commandBuffer;
19347 VkFrontFace frontFace;
19348 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19349 uint64_t cgen_var_0;
19350 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19351 *readStreamPtrPtr += 1 * 8;
19352 *(VkCommandBuffer*)&commandBuffer =
19353 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19354 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19355 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19356 // End manual dispatchable handle unboxing for commandBuffer;
19357 memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
19358 *readStreamPtrPtr += sizeof(VkFrontFace);
19359 if (m_logCalls) {
19360 fprintf(stderr, "stream %p: call vkCmdSetFrontFaceEXT 0x%llx 0x%llx \n",
19361 ioStream, (unsigned long long)commandBuffer,
19362 (unsigned long long)frontFace);
19363 }
19364 vk->vkCmdSetFrontFaceEXT(unboxed_commandBuffer, frontFace);
19365 vkStream->unsetHandleMapping();
19366 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19367 (uintptr_t)snapshotTraceBegin);
19368 size_t snapshotTraceBytes = vkReadStream->endTrace();
19369 if (m_state->snapshotsEnabled()) {
19370 m_state->snapshot()->vkCmdSetFrontFaceEXT(
19371 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, frontFace);
19372 }
19373 vkReadStream->clearPool();
19374 if (m_queueSubmitWithCommandsEnabled)
19375 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19376 break;
19377 }
19378 case OP_vkCmdSetPrimitiveTopologyEXT: {
19379 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19380 "VkDecoder vkCmdSetPrimitiveTopologyEXT");
19381 VkCommandBuffer commandBuffer;
19382 VkPrimitiveTopology primitiveTopology;
19383 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19384 uint64_t cgen_var_0;
19385 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19386 *readStreamPtrPtr += 1 * 8;
19387 *(VkCommandBuffer*)&commandBuffer =
19388 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19389 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19390 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19391 // End manual dispatchable handle unboxing for commandBuffer;
19392 memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
19393 sizeof(VkPrimitiveTopology));
19394 *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
19395 if (m_logCalls) {
19396 fprintf(stderr, "stream %p: call vkCmdSetPrimitiveTopologyEXT 0x%llx 0x%llx \n",
19397 ioStream, (unsigned long long)commandBuffer,
19398 (unsigned long long)primitiveTopology);
19399 }
19400 vk->vkCmdSetPrimitiveTopologyEXT(unboxed_commandBuffer, primitiveTopology);
19401 vkStream->unsetHandleMapping();
19402 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19403 (uintptr_t)snapshotTraceBegin);
19404 size_t snapshotTraceBytes = vkReadStream->endTrace();
19405 if (m_state->snapshotsEnabled()) {
19406 m_state->snapshot()->vkCmdSetPrimitiveTopologyEXT(
19407 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
19408 primitiveTopology);
19409 }
19410 vkReadStream->clearPool();
19411 if (m_queueSubmitWithCommandsEnabled)
19412 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19413 break;
19414 }
19415 case OP_vkCmdSetViewportWithCountEXT: {
19416 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19417 "VkDecoder vkCmdSetViewportWithCountEXT");
19418 VkCommandBuffer commandBuffer;
19419 uint32_t viewportCount;
19420 const VkViewport* pViewports;
19421 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19422 uint64_t cgen_var_0;
19423 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19424 *readStreamPtrPtr += 1 * 8;
19425 *(VkCommandBuffer*)&commandBuffer =
19426 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19427 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19428 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19429 // End manual dispatchable handle unboxing for commandBuffer;
19430 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
19431 *readStreamPtrPtr += sizeof(uint32_t);
19432 vkReadStream->alloc((void**)&pViewports,
19433 ((viewportCount)) * sizeof(const VkViewport));
19434 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
19435 reservedunmarshal_VkViewport(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19436 (VkViewport*)(pViewports + i), readStreamPtrPtr);
19437 }
19438 if (pViewports) {
19439 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
19440 transform_tohost_VkViewport(m_state, (VkViewport*)(pViewports + i));
19441 }
19442 }
19443 if (m_logCalls) {
19444 fprintf(stderr,
19445 "stream %p: call vkCmdSetViewportWithCountEXT 0x%llx 0x%llx 0x%llx \n",
19446 ioStream, (unsigned long long)commandBuffer,
19447 (unsigned long long)viewportCount, (unsigned long long)pViewports);
19448 }
19449 vk->vkCmdSetViewportWithCountEXT(unboxed_commandBuffer, viewportCount, pViewports);
19450 vkStream->unsetHandleMapping();
19451 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19452 (uintptr_t)snapshotTraceBegin);
19453 size_t snapshotTraceBytes = vkReadStream->endTrace();
19454 if (m_state->snapshotsEnabled()) {
19455 m_state->snapshot()->vkCmdSetViewportWithCountEXT(
19456 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
19457 viewportCount, pViewports);
19458 }
19459 vkReadStream->clearPool();
19460 if (m_queueSubmitWithCommandsEnabled)
19461 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19462 break;
19463 }
19464 case OP_vkCmdSetScissorWithCountEXT: {
19465 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19466 "VkDecoder vkCmdSetScissorWithCountEXT");
19467 VkCommandBuffer commandBuffer;
19468 uint32_t scissorCount;
19469 const VkRect2D* pScissors;
19470 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19471 uint64_t cgen_var_0;
19472 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19473 *readStreamPtrPtr += 1 * 8;
19474 *(VkCommandBuffer*)&commandBuffer =
19475 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19476 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19477 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19478 // End manual dispatchable handle unboxing for commandBuffer;
19479 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
19480 *readStreamPtrPtr += sizeof(uint32_t);
19481 vkReadStream->alloc((void**)&pScissors, ((scissorCount)) * sizeof(const VkRect2D));
19482 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
19483 reservedunmarshal_VkRect2D(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19484 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
19485 }
19486 if (pScissors) {
19487 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
19488 transform_tohost_VkRect2D(m_state, (VkRect2D*)(pScissors + i));
19489 }
19490 }
19491 if (m_logCalls) {
19492 fprintf(stderr,
19493 "stream %p: call vkCmdSetScissorWithCountEXT 0x%llx 0x%llx 0x%llx \n",
19494 ioStream, (unsigned long long)commandBuffer,
19495 (unsigned long long)scissorCount, (unsigned long long)pScissors);
19496 }
19497 vk->vkCmdSetScissorWithCountEXT(unboxed_commandBuffer, scissorCount, pScissors);
19498 vkStream->unsetHandleMapping();
19499 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19500 (uintptr_t)snapshotTraceBegin);
19501 size_t snapshotTraceBytes = vkReadStream->endTrace();
19502 if (m_state->snapshotsEnabled()) {
19503 m_state->snapshot()->vkCmdSetScissorWithCountEXT(
19504 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
19505 scissorCount, pScissors);
19506 }
19507 vkReadStream->clearPool();
19508 if (m_queueSubmitWithCommandsEnabled)
19509 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19510 break;
19511 }
19512 case OP_vkCmdBindVertexBuffers2EXT: {
19513 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19514 "VkDecoder vkCmdBindVertexBuffers2EXT");
19515 VkCommandBuffer commandBuffer;
19516 uint32_t firstBinding;
19517 uint32_t bindingCount;
19518 const VkBuffer* pBuffers;
19519 const VkDeviceSize* pOffsets;
19520 const VkDeviceSize* pSizes;
19521 const VkDeviceSize* pStrides;
19522 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19523 uint64_t cgen_var_0;
19524 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19525 *readStreamPtrPtr += 1 * 8;
19526 *(VkCommandBuffer*)&commandBuffer =
19527 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19528 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19529 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19530 // End manual dispatchable handle unboxing for commandBuffer;
19531 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
19532 *readStreamPtrPtr += sizeof(uint32_t);
19533 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
19534 *readStreamPtrPtr += sizeof(uint32_t);
19535 // WARNING PTR CHECK
19536 memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
19537 android::base::Stream::fromBe64((uint8_t*)&pBuffers);
19538 *readStreamPtrPtr += 8;
19539 if (pBuffers) {
19540 vkReadStream->alloc((void**)&pBuffers,
19541 ((bindingCount)) * sizeof(const VkBuffer));
19542 if (((bindingCount))) {
19543 uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*readStreamPtrPtr);
19544 *readStreamPtrPtr += 8 * ((bindingCount));
19545 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
19546 uint64_t tmpval;
19547 memcpy(&tmpval, cgen_var_1_0_ptr + k * 8, sizeof(uint64_t));
19548 *(((VkBuffer*)pBuffers) + k) =
19549 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
19550 : VK_NULL_HANDLE;
19551 }
19552 }
19553 }
19554 vkReadStream->alloc((void**)&pOffsets,
19555 ((bindingCount)) * sizeof(const VkDeviceSize));
19556 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
19557 ((bindingCount)) * sizeof(const VkDeviceSize));
19558 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
19559 // WARNING PTR CHECK
19560 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
19561 android::base::Stream::fromBe64((uint8_t*)&pSizes);
19562 *readStreamPtrPtr += 8;
19563 if (pSizes) {
19564 vkReadStream->alloc((void**)&pSizes,
19565 ((bindingCount)) * sizeof(const VkDeviceSize));
19566 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
19567 ((bindingCount)) * sizeof(const VkDeviceSize));
19568 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
19569 }
19570 // WARNING PTR CHECK
19571 memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
19572 android::base::Stream::fromBe64((uint8_t*)&pStrides);
19573 *readStreamPtrPtr += 8;
19574 if (pStrides) {
19575 vkReadStream->alloc((void**)&pStrides,
19576 ((bindingCount)) * sizeof(const VkDeviceSize));
19577 memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
19578 ((bindingCount)) * sizeof(const VkDeviceSize));
19579 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
19580 }
19581 if (m_logCalls) {
19582 fprintf(stderr,
19583 "stream %p: call vkCmdBindVertexBuffers2EXT 0x%llx 0x%llx 0x%llx "
19584 "0x%llx 0x%llx 0x%llx 0x%llx \n",
19585 ioStream, (unsigned long long)commandBuffer,
19586 (unsigned long long)firstBinding, (unsigned long long)bindingCount,
19587 (unsigned long long)pBuffers, (unsigned long long)pOffsets,
19588 (unsigned long long)pSizes, (unsigned long long)pStrides);
19589 }
19590 vk->vkCmdBindVertexBuffers2EXT(unboxed_commandBuffer, firstBinding, bindingCount,
19591 pBuffers, pOffsets, pSizes, pStrides);
19592 vkStream->unsetHandleMapping();
19593 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19594 (uintptr_t)snapshotTraceBegin);
19595 size_t snapshotTraceBytes = vkReadStream->endTrace();
19596 if (m_state->snapshotsEnabled()) {
19597 m_state->snapshot()->vkCmdBindVertexBuffers2EXT(
19598 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
19599 firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
19600 }
19601 vkReadStream->clearPool();
19602 if (m_queueSubmitWithCommandsEnabled)
19603 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19604 break;
19605 }
19606 case OP_vkCmdSetDepthTestEnableEXT: {
19607 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19608 "VkDecoder vkCmdSetDepthTestEnableEXT");
19609 VkCommandBuffer commandBuffer;
19610 VkBool32 depthTestEnable;
19611 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19612 uint64_t cgen_var_0;
19613 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19614 *readStreamPtrPtr += 1 * 8;
19615 *(VkCommandBuffer*)&commandBuffer =
19616 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19617 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19618 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19619 // End manual dispatchable handle unboxing for commandBuffer;
19620 memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
19621 *readStreamPtrPtr += sizeof(VkBool32);
19622 if (m_logCalls) {
19623 fprintf(stderr, "stream %p: call vkCmdSetDepthTestEnableEXT 0x%llx 0x%llx \n",
19624 ioStream, (unsigned long long)commandBuffer,
19625 (unsigned long long)depthTestEnable);
19626 }
19627 vk->vkCmdSetDepthTestEnableEXT(unboxed_commandBuffer, depthTestEnable);
19628 vkStream->unsetHandleMapping();
19629 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19630 (uintptr_t)snapshotTraceBegin);
19631 size_t snapshotTraceBytes = vkReadStream->endTrace();
19632 if (m_state->snapshotsEnabled()) {
19633 m_state->snapshot()->vkCmdSetDepthTestEnableEXT(snapshotTraceBegin,
19634 snapshotTraceBytes, &m_pool,
19635 commandBuffer, depthTestEnable);
19636 }
19637 vkReadStream->clearPool();
19638 if (m_queueSubmitWithCommandsEnabled)
19639 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19640 break;
19641 }
19642 case OP_vkCmdSetDepthWriteEnableEXT: {
19643 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19644 "VkDecoder vkCmdSetDepthWriteEnableEXT");
19645 VkCommandBuffer commandBuffer;
19646 VkBool32 depthWriteEnable;
19647 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19648 uint64_t cgen_var_0;
19649 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19650 *readStreamPtrPtr += 1 * 8;
19651 *(VkCommandBuffer*)&commandBuffer =
19652 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19653 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19654 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19655 // End manual dispatchable handle unboxing for commandBuffer;
19656 memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
19657 *readStreamPtrPtr += sizeof(VkBool32);
19658 if (m_logCalls) {
19659 fprintf(stderr, "stream %p: call vkCmdSetDepthWriteEnableEXT 0x%llx 0x%llx \n",
19660 ioStream, (unsigned long long)commandBuffer,
19661 (unsigned long long)depthWriteEnable);
19662 }
19663 vk->vkCmdSetDepthWriteEnableEXT(unboxed_commandBuffer, depthWriteEnable);
19664 vkStream->unsetHandleMapping();
19665 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19666 (uintptr_t)snapshotTraceBegin);
19667 size_t snapshotTraceBytes = vkReadStream->endTrace();
19668 if (m_state->snapshotsEnabled()) {
19669 m_state->snapshot()->vkCmdSetDepthWriteEnableEXT(
19670 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
19671 depthWriteEnable);
19672 }
19673 vkReadStream->clearPool();
19674 if (m_queueSubmitWithCommandsEnabled)
19675 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19676 break;
19677 }
19678 case OP_vkCmdSetDepthCompareOpEXT: {
19679 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19680 "VkDecoder vkCmdSetDepthCompareOpEXT");
19681 VkCommandBuffer commandBuffer;
19682 VkCompareOp depthCompareOp;
19683 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19684 uint64_t cgen_var_0;
19685 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19686 *readStreamPtrPtr += 1 * 8;
19687 *(VkCommandBuffer*)&commandBuffer =
19688 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19689 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19690 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19691 // End manual dispatchable handle unboxing for commandBuffer;
19692 memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
19693 *readStreamPtrPtr += sizeof(VkCompareOp);
19694 if (m_logCalls) {
19695 fprintf(stderr, "stream %p: call vkCmdSetDepthCompareOpEXT 0x%llx 0x%llx \n",
19696 ioStream, (unsigned long long)commandBuffer,
19697 (unsigned long long)depthCompareOp);
19698 }
19699 vk->vkCmdSetDepthCompareOpEXT(unboxed_commandBuffer, depthCompareOp);
19700 vkStream->unsetHandleMapping();
19701 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19702 (uintptr_t)snapshotTraceBegin);
19703 size_t snapshotTraceBytes = vkReadStream->endTrace();
19704 if (m_state->snapshotsEnabled()) {
19705 m_state->snapshot()->vkCmdSetDepthCompareOpEXT(snapshotTraceBegin,
19706 snapshotTraceBytes, &m_pool,
19707 commandBuffer, depthCompareOp);
19708 }
19709 vkReadStream->clearPool();
19710 if (m_queueSubmitWithCommandsEnabled)
19711 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19712 break;
19713 }
19714 case OP_vkCmdSetDepthBoundsTestEnableEXT: {
19715 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19716 "VkDecoder vkCmdSetDepthBoundsTestEnableEXT");
19717 VkCommandBuffer commandBuffer;
19718 VkBool32 depthBoundsTestEnable;
19719 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19720 uint64_t cgen_var_0;
19721 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19722 *readStreamPtrPtr += 1 * 8;
19723 *(VkCommandBuffer*)&commandBuffer =
19724 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19725 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19726 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19727 // End manual dispatchable handle unboxing for commandBuffer;
19728 memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
19729 *readStreamPtrPtr += sizeof(VkBool32);
19730 if (m_logCalls) {
19731 fprintf(stderr,
19732 "stream %p: call vkCmdSetDepthBoundsTestEnableEXT 0x%llx 0x%llx \n",
19733 ioStream, (unsigned long long)commandBuffer,
19734 (unsigned long long)depthBoundsTestEnable);
19735 }
19736 vk->vkCmdSetDepthBoundsTestEnableEXT(unboxed_commandBuffer, depthBoundsTestEnable);
19737 vkStream->unsetHandleMapping();
19738 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19739 (uintptr_t)snapshotTraceBegin);
19740 size_t snapshotTraceBytes = vkReadStream->endTrace();
19741 if (m_state->snapshotsEnabled()) {
19742 m_state->snapshot()->vkCmdSetDepthBoundsTestEnableEXT(
19743 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
19744 depthBoundsTestEnable);
19745 }
19746 vkReadStream->clearPool();
19747 if (m_queueSubmitWithCommandsEnabled)
19748 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19749 break;
19750 }
19751 case OP_vkCmdSetStencilTestEnableEXT: {
19752 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19753 "VkDecoder vkCmdSetStencilTestEnableEXT");
19754 VkCommandBuffer commandBuffer;
19755 VkBool32 stencilTestEnable;
19756 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19757 uint64_t cgen_var_0;
19758 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19759 *readStreamPtrPtr += 1 * 8;
19760 *(VkCommandBuffer*)&commandBuffer =
19761 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19762 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19763 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19764 // End manual dispatchable handle unboxing for commandBuffer;
19765 memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
19766 *readStreamPtrPtr += sizeof(VkBool32);
19767 if (m_logCalls) {
19768 fprintf(stderr, "stream %p: call vkCmdSetStencilTestEnableEXT 0x%llx 0x%llx \n",
19769 ioStream, (unsigned long long)commandBuffer,
19770 (unsigned long long)stencilTestEnable);
19771 }
19772 vk->vkCmdSetStencilTestEnableEXT(unboxed_commandBuffer, stencilTestEnable);
19773 vkStream->unsetHandleMapping();
19774 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19775 (uintptr_t)snapshotTraceBegin);
19776 size_t snapshotTraceBytes = vkReadStream->endTrace();
19777 if (m_state->snapshotsEnabled()) {
19778 m_state->snapshot()->vkCmdSetStencilTestEnableEXT(
19779 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
19780 stencilTestEnable);
19781 }
19782 vkReadStream->clearPool();
19783 if (m_queueSubmitWithCommandsEnabled)
19784 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19785 break;
19786 }
19787 case OP_vkCmdSetStencilOpEXT: {
19788 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19789 "VkDecoder vkCmdSetStencilOpEXT");
19790 VkCommandBuffer commandBuffer;
19791 VkStencilFaceFlags faceMask;
19792 VkStencilOp failOp;
19793 VkStencilOp passOp;
19794 VkStencilOp depthFailOp;
19795 VkCompareOp compareOp;
19796 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
19797 uint64_t cgen_var_0;
19798 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19799 *readStreamPtrPtr += 1 * 8;
19800 *(VkCommandBuffer*)&commandBuffer =
19801 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
19802 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
19803 auto vk = dispatch_VkCommandBuffer(commandBuffer);
19804 // End manual dispatchable handle unboxing for commandBuffer;
19805 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
19806 sizeof(VkStencilFaceFlags));
19807 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
19808 memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
19809 *readStreamPtrPtr += sizeof(VkStencilOp);
19810 memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
19811 *readStreamPtrPtr += sizeof(VkStencilOp);
19812 memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
19813 *readStreamPtrPtr += sizeof(VkStencilOp);
19814 memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
19815 *readStreamPtrPtr += sizeof(VkCompareOp);
19816 if (m_logCalls) {
19817 fprintf(stderr,
19818 "stream %p: call vkCmdSetStencilOpEXT 0x%llx 0x%llx 0x%llx 0x%llx "
19819 "0x%llx 0x%llx \n",
19820 ioStream, (unsigned long long)commandBuffer,
19821 (unsigned long long)faceMask, (unsigned long long)failOp,
19822 (unsigned long long)passOp, (unsigned long long)depthFailOp,
19823 (unsigned long long)compareOp);
19824 }
19825 vk->vkCmdSetStencilOpEXT(unboxed_commandBuffer, faceMask, failOp, passOp,
19826 depthFailOp, compareOp);
19827 vkStream->unsetHandleMapping();
19828 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19829 (uintptr_t)snapshotTraceBegin);
19830 size_t snapshotTraceBytes = vkReadStream->endTrace();
19831 if (m_state->snapshotsEnabled()) {
19832 m_state->snapshot()->vkCmdSetStencilOpEXT(
19833 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, faceMask,
19834 failOp, passOp, depthFailOp, compareOp);
19835 }
19836 vkReadStream->clearPool();
19837 if (m_queueSubmitWithCommandsEnabled)
19838 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19839 break;
19840 }
19841 #endif
19842 #ifdef VK_EXT_host_image_copy
19843 case OP_vkCopyMemoryToImageEXT: {
19844 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19845 "VkDecoder vkCopyMemoryToImageEXT");
19846 VkDevice device;
19847 const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo;
19848 // Begin non wrapped dispatchable handle unboxing for device;
19849 uint64_t cgen_var_0;
19850 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19851 *readStreamPtrPtr += 1 * 8;
19852 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
19853 auto unboxed_device = unbox_VkDevice(device);
19854 auto vk = dispatch_VkDevice(device);
19855 // End manual dispatchable handle unboxing for device;
19856 vkReadStream->alloc((void**)&pCopyMemoryToImageInfo,
19857 sizeof(const VkCopyMemoryToImageInfoEXT));
19858 reservedunmarshal_VkCopyMemoryToImageInfoEXT(
19859 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19860 (VkCopyMemoryToImageInfoEXT*)(pCopyMemoryToImageInfo), readStreamPtrPtr);
19861 if (pCopyMemoryToImageInfo) {
19862 transform_tohost_VkCopyMemoryToImageInfoEXT(
19863 m_state, (VkCopyMemoryToImageInfoEXT*)(pCopyMemoryToImageInfo));
19864 }
19865 if (m_logCalls) {
19866 fprintf(stderr, "stream %p: call vkCopyMemoryToImageEXT 0x%llx 0x%llx \n",
19867 ioStream, (unsigned long long)device,
19868 (unsigned long long)pCopyMemoryToImageInfo);
19869 }
19870 VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
19871 vkCopyMemoryToImageEXT_VkResult_return =
19872 vk->vkCopyMemoryToImageEXT(unboxed_device, pCopyMemoryToImageInfo);
19873 if ((vkCopyMemoryToImageEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
19874 m_state->on_DeviceLost();
19875 m_state->on_CheckOutOfMemory(vkCopyMemoryToImageEXT_VkResult_return, opcode,
19876 context);
19877 vkStream->unsetHandleMapping();
19878 vkStream->write(&vkCopyMemoryToImageEXT_VkResult_return, sizeof(VkResult));
19879 vkStream->commitWrite();
19880 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19881 (uintptr_t)snapshotTraceBegin);
19882 size_t snapshotTraceBytes = vkReadStream->endTrace();
19883 if (m_state->snapshotsEnabled()) {
19884 m_state->snapshot()->vkCopyMemoryToImageEXT(
19885 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
19886 vkCopyMemoryToImageEXT_VkResult_return, device, pCopyMemoryToImageInfo);
19887 }
19888 vkReadStream->clearPool();
19889 if (m_queueSubmitWithCommandsEnabled)
19890 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19891 break;
19892 }
19893 case OP_vkCopyImageToMemoryEXT: {
19894 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19895 "VkDecoder vkCopyImageToMemoryEXT");
19896 VkDevice device;
19897 const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo;
19898 // Begin non wrapped dispatchable handle unboxing for device;
19899 uint64_t cgen_var_0;
19900 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19901 *readStreamPtrPtr += 1 * 8;
19902 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
19903 auto unboxed_device = unbox_VkDevice(device);
19904 auto vk = dispatch_VkDevice(device);
19905 // End manual dispatchable handle unboxing for device;
19906 vkReadStream->alloc((void**)&pCopyImageToMemoryInfo,
19907 sizeof(const VkCopyImageToMemoryInfoEXT));
19908 reservedunmarshal_VkCopyImageToMemoryInfoEXT(
19909 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19910 (VkCopyImageToMemoryInfoEXT*)(pCopyImageToMemoryInfo), readStreamPtrPtr);
19911 if (pCopyImageToMemoryInfo) {
19912 transform_tohost_VkCopyImageToMemoryInfoEXT(
19913 m_state, (VkCopyImageToMemoryInfoEXT*)(pCopyImageToMemoryInfo));
19914 }
19915 if (m_logCalls) {
19916 fprintf(stderr, "stream %p: call vkCopyImageToMemoryEXT 0x%llx 0x%llx \n",
19917 ioStream, (unsigned long long)device,
19918 (unsigned long long)pCopyImageToMemoryInfo);
19919 }
19920 VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
19921 vkCopyImageToMemoryEXT_VkResult_return =
19922 vk->vkCopyImageToMemoryEXT(unboxed_device, pCopyImageToMemoryInfo);
19923 if ((vkCopyImageToMemoryEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
19924 m_state->on_DeviceLost();
19925 m_state->on_CheckOutOfMemory(vkCopyImageToMemoryEXT_VkResult_return, opcode,
19926 context);
19927 vkStream->unsetHandleMapping();
19928 vkStream->write(&vkCopyImageToMemoryEXT_VkResult_return, sizeof(VkResult));
19929 vkStream->commitWrite();
19930 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19931 (uintptr_t)snapshotTraceBegin);
19932 size_t snapshotTraceBytes = vkReadStream->endTrace();
19933 if (m_state->snapshotsEnabled()) {
19934 m_state->snapshot()->vkCopyImageToMemoryEXT(
19935 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
19936 vkCopyImageToMemoryEXT_VkResult_return, device, pCopyImageToMemoryInfo);
19937 }
19938 vkReadStream->clearPool();
19939 if (m_queueSubmitWithCommandsEnabled)
19940 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19941 break;
19942 }
19943 case OP_vkCopyImageToImageEXT: {
19944 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19945 "VkDecoder vkCopyImageToImageEXT");
19946 VkDevice device;
19947 const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo;
19948 // Begin non wrapped dispatchable handle unboxing for device;
19949 uint64_t cgen_var_0;
19950 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
19951 *readStreamPtrPtr += 1 * 8;
19952 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
19953 auto unboxed_device = unbox_VkDevice(device);
19954 auto vk = dispatch_VkDevice(device);
19955 // End manual dispatchable handle unboxing for device;
19956 vkReadStream->alloc((void**)&pCopyImageToImageInfo,
19957 sizeof(const VkCopyImageToImageInfoEXT));
19958 reservedunmarshal_VkCopyImageToImageInfoEXT(
19959 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
19960 (VkCopyImageToImageInfoEXT*)(pCopyImageToImageInfo), readStreamPtrPtr);
19961 if (pCopyImageToImageInfo) {
19962 transform_tohost_VkCopyImageToImageInfoEXT(
19963 m_state, (VkCopyImageToImageInfoEXT*)(pCopyImageToImageInfo));
19964 }
19965 if (m_logCalls) {
19966 fprintf(stderr, "stream %p: call vkCopyImageToImageEXT 0x%llx 0x%llx \n",
19967 ioStream, (unsigned long long)device,
19968 (unsigned long long)pCopyImageToImageInfo);
19969 }
19970 VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
19971 vkCopyImageToImageEXT_VkResult_return =
19972 vk->vkCopyImageToImageEXT(unboxed_device, pCopyImageToImageInfo);
19973 if ((vkCopyImageToImageEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
19974 m_state->on_DeviceLost();
19975 m_state->on_CheckOutOfMemory(vkCopyImageToImageEXT_VkResult_return, opcode,
19976 context);
19977 vkStream->unsetHandleMapping();
19978 vkStream->write(&vkCopyImageToImageEXT_VkResult_return, sizeof(VkResult));
19979 vkStream->commitWrite();
19980 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
19981 (uintptr_t)snapshotTraceBegin);
19982 size_t snapshotTraceBytes = vkReadStream->endTrace();
19983 if (m_state->snapshotsEnabled()) {
19984 m_state->snapshot()->vkCopyImageToImageEXT(
19985 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
19986 vkCopyImageToImageEXT_VkResult_return, device, pCopyImageToImageInfo);
19987 }
19988 vkReadStream->clearPool();
19989 if (m_queueSubmitWithCommandsEnabled)
19990 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
19991 break;
19992 }
19993 case OP_vkTransitionImageLayoutEXT: {
19994 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
19995 "VkDecoder vkTransitionImageLayoutEXT");
19996 VkDevice device;
19997 uint32_t transitionCount;
19998 const VkHostImageLayoutTransitionInfoEXT* pTransitions;
19999 // Begin non wrapped dispatchable handle unboxing for device;
20000 uint64_t cgen_var_0;
20001 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20002 *readStreamPtrPtr += 1 * 8;
20003 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
20004 auto unboxed_device = unbox_VkDevice(device);
20005 auto vk = dispatch_VkDevice(device);
20006 // End manual dispatchable handle unboxing for device;
20007 memcpy((uint32_t*)&transitionCount, *readStreamPtrPtr, sizeof(uint32_t));
20008 *readStreamPtrPtr += sizeof(uint32_t);
20009 vkReadStream->alloc(
20010 (void**)&pTransitions,
20011 ((transitionCount)) * sizeof(const VkHostImageLayoutTransitionInfoEXT));
20012 for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
20013 reservedunmarshal_VkHostImageLayoutTransitionInfoEXT(
20014 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20015 (VkHostImageLayoutTransitionInfoEXT*)(pTransitions + i), readStreamPtrPtr);
20016 }
20017 if (pTransitions) {
20018 for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
20019 transform_tohost_VkHostImageLayoutTransitionInfoEXT(
20020 m_state, (VkHostImageLayoutTransitionInfoEXT*)(pTransitions + i));
20021 }
20022 }
20023 if (m_logCalls) {
20024 fprintf(stderr,
20025 "stream %p: call vkTransitionImageLayoutEXT 0x%llx 0x%llx 0x%llx \n",
20026 ioStream, (unsigned long long)device,
20027 (unsigned long long)transitionCount, (unsigned long long)pTransitions);
20028 }
20029 VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
20030 vkTransitionImageLayoutEXT_VkResult_return =
20031 vk->vkTransitionImageLayoutEXT(unboxed_device, transitionCount, pTransitions);
20032 if ((vkTransitionImageLayoutEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
20033 m_state->on_DeviceLost();
20034 m_state->on_CheckOutOfMemory(vkTransitionImageLayoutEXT_VkResult_return, opcode,
20035 context);
20036 vkStream->unsetHandleMapping();
20037 vkStream->write(&vkTransitionImageLayoutEXT_VkResult_return, sizeof(VkResult));
20038 vkStream->commitWrite();
20039 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20040 (uintptr_t)snapshotTraceBegin);
20041 size_t snapshotTraceBytes = vkReadStream->endTrace();
20042 if (m_state->snapshotsEnabled()) {
20043 m_state->snapshot()->vkTransitionImageLayoutEXT(
20044 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
20045 vkTransitionImageLayoutEXT_VkResult_return, device, transitionCount,
20046 pTransitions);
20047 }
20048 vkReadStream->clearPool();
20049 if (m_queueSubmitWithCommandsEnabled)
20050 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20051 break;
20052 }
20053 case OP_vkGetImageSubresourceLayout2EXT: {
20054 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20055 "VkDecoder vkGetImageSubresourceLayout2EXT");
20056 VkDevice device;
20057 VkImage image;
20058 const VkImageSubresource2KHR* pSubresource;
20059 VkSubresourceLayout2KHR* pLayout;
20060 // Begin non wrapped dispatchable handle unboxing for device;
20061 uint64_t cgen_var_0;
20062 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20063 *readStreamPtrPtr += 1 * 8;
20064 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
20065 auto unboxed_device = unbox_VkDevice(device);
20066 auto vk = dispatch_VkDevice(device);
20067 // End manual dispatchable handle unboxing for device;
20068 uint64_t cgen_var_1;
20069 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
20070 *readStreamPtrPtr += 1 * 8;
20071 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
20072 vkReadStream->alloc((void**)&pSubresource, sizeof(const VkImageSubresource2KHR));
20073 reservedunmarshal_VkImageSubresource2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20074 (VkImageSubresource2KHR*)(pSubresource),
20075 readStreamPtrPtr);
20076 // Begin manual dispatchable handle unboxing for pLayout;
20077 vkReadStream->unsetHandleMapping();
20078 vkReadStream->alloc((void**)&pLayout, sizeof(VkSubresourceLayout2KHR));
20079 reservedunmarshal_VkSubresourceLayout2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20080 (VkSubresourceLayout2KHR*)(pLayout),
20081 readStreamPtrPtr);
20082 if (pSubresource) {
20083 transform_tohost_VkImageSubresource2KHR(
20084 m_state, (VkImageSubresource2KHR*)(pSubresource));
20085 }
20086 if (pLayout) {
20087 transform_tohost_VkSubresourceLayout2KHR(m_state,
20088 (VkSubresourceLayout2KHR*)(pLayout));
20089 }
20090 if (m_logCalls) {
20091 fprintf(stderr,
20092 "stream %p: call vkGetImageSubresourceLayout2EXT 0x%llx 0x%llx 0x%llx "
20093 "0x%llx \n",
20094 ioStream, (unsigned long long)device, (unsigned long long)image,
20095 (unsigned long long)pSubresource, (unsigned long long)pLayout);
20096 }
20097 vk->vkGetImageSubresourceLayout2EXT(unboxed_device, image, pSubresource, pLayout);
20098 vkStream->unsetHandleMapping();
20099 if (pLayout) {
20100 transform_fromhost_VkSubresourceLayout2KHR(m_state,
20101 (VkSubresourceLayout2KHR*)(pLayout));
20102 }
20103 marshal_VkSubresourceLayout2KHR(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20104 (VkSubresourceLayout2KHR*)(pLayout));
20105 vkStream->commitWrite();
20106 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20107 (uintptr_t)snapshotTraceBegin);
20108 size_t snapshotTraceBytes = vkReadStream->endTrace();
20109 if (m_state->snapshotsEnabled()) {
20110 m_state->snapshot()->vkGetImageSubresourceLayout2EXT(
20111 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, image,
20112 pSubresource, pLayout);
20113 }
20114 vkReadStream->clearPool();
20115 if (m_queueSubmitWithCommandsEnabled)
20116 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20117 break;
20118 }
20119 #endif
20120 #ifdef VK_EXT_swapchain_maintenance1
20121 case OP_vkReleaseSwapchainImagesEXT: {
20122 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20123 "VkDecoder vkReleaseSwapchainImagesEXT");
20124 VkDevice device;
20125 const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo;
20126 // Begin non wrapped dispatchable handle unboxing for device;
20127 uint64_t cgen_var_0;
20128 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20129 *readStreamPtrPtr += 1 * 8;
20130 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
20131 auto unboxed_device = unbox_VkDevice(device);
20132 auto vk = dispatch_VkDevice(device);
20133 // End manual dispatchable handle unboxing for device;
20134 vkReadStream->alloc((void**)&pReleaseInfo,
20135 sizeof(const VkReleaseSwapchainImagesInfoEXT));
20136 reservedunmarshal_VkReleaseSwapchainImagesInfoEXT(
20137 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20138 (VkReleaseSwapchainImagesInfoEXT*)(pReleaseInfo), readStreamPtrPtr);
20139 if (pReleaseInfo) {
20140 transform_tohost_VkReleaseSwapchainImagesInfoEXT(
20141 m_state, (VkReleaseSwapchainImagesInfoEXT*)(pReleaseInfo));
20142 }
20143 if (m_logCalls) {
20144 fprintf(stderr, "stream %p: call vkReleaseSwapchainImagesEXT 0x%llx 0x%llx \n",
20145 ioStream, (unsigned long long)device, (unsigned long long)pReleaseInfo);
20146 }
20147 VkResult vkReleaseSwapchainImagesEXT_VkResult_return = (VkResult)0;
20148 vkReleaseSwapchainImagesEXT_VkResult_return =
20149 vk->vkReleaseSwapchainImagesEXT(unboxed_device, pReleaseInfo);
20150 if ((vkReleaseSwapchainImagesEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
20151 m_state->on_DeviceLost();
20152 m_state->on_CheckOutOfMemory(vkReleaseSwapchainImagesEXT_VkResult_return, opcode,
20153 context);
20154 vkStream->unsetHandleMapping();
20155 vkStream->write(&vkReleaseSwapchainImagesEXT_VkResult_return, sizeof(VkResult));
20156 vkStream->commitWrite();
20157 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20158 (uintptr_t)snapshotTraceBegin);
20159 size_t snapshotTraceBytes = vkReadStream->endTrace();
20160 if (m_state->snapshotsEnabled()) {
20161 m_state->snapshot()->vkReleaseSwapchainImagesEXT(
20162 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
20163 vkReleaseSwapchainImagesEXT_VkResult_return, device, pReleaseInfo);
20164 }
20165 vkReadStream->clearPool();
20166 if (m_queueSubmitWithCommandsEnabled)
20167 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20168 break;
20169 }
20170 #endif
20171 #ifdef VK_EXT_private_data
20172 case OP_vkCreatePrivateDataSlotEXT: {
20173 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20174 "VkDecoder vkCreatePrivateDataSlotEXT");
20175 VkDevice device;
20176 const VkPrivateDataSlotCreateInfo* pCreateInfo;
20177 const VkAllocationCallbacks* pAllocator;
20178 VkPrivateDataSlot* pPrivateDataSlot;
20179 // Begin non wrapped dispatchable handle unboxing for device;
20180 uint64_t cgen_var_0;
20181 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20182 *readStreamPtrPtr += 1 * 8;
20183 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
20184 auto unboxed_device = unbox_VkDevice(device);
20185 auto vk = dispatch_VkDevice(device);
20186 // End manual dispatchable handle unboxing for device;
20187 vkReadStream->alloc((void**)&pCreateInfo,
20188 sizeof(const VkPrivateDataSlotCreateInfo));
20189 reservedunmarshal_VkPrivateDataSlotCreateInfo(
20190 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20191 (VkPrivateDataSlotCreateInfo*)(pCreateInfo), readStreamPtrPtr);
20192 // WARNING PTR CHECK
20193 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
20194 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
20195 *readStreamPtrPtr += 8;
20196 if (pAllocator) {
20197 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
20198 reservedunmarshal_VkAllocationCallbacks(
20199 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20200 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
20201 }
20202 // Begin manual dispatchable handle unboxing for pPrivateDataSlot;
20203 vkReadStream->unsetHandleMapping();
20204 vkReadStream->alloc((void**)&pPrivateDataSlot, sizeof(VkPrivateDataSlot));
20205 uint64_t cgen_var_2;
20206 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
20207 *readStreamPtrPtr += 8;
20208 *(VkPrivateDataSlot*)pPrivateDataSlot =
20209 (VkPrivateDataSlot)(VkPrivateDataSlot)((VkPrivateDataSlot)(*&cgen_var_2));
20210 if (pCreateInfo) {
20211 transform_tohost_VkPrivateDataSlotCreateInfo(
20212 m_state, (VkPrivateDataSlotCreateInfo*)(pCreateInfo));
20213 }
20214 if (pAllocator) {
20215 transform_tohost_VkAllocationCallbacks(m_state,
20216 (VkAllocationCallbacks*)(pAllocator));
20217 }
20218 if (m_logCalls) {
20219 fprintf(
20220 stderr,
20221 "stream %p: call vkCreatePrivateDataSlotEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
20222 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
20223 (unsigned long long)pAllocator, (unsigned long long)pPrivateDataSlot);
20224 }
20225 VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
20226 vkCreatePrivateDataSlotEXT_VkResult_return = vk->vkCreatePrivateDataSlotEXT(
20227 unboxed_device, pCreateInfo, pAllocator, pPrivateDataSlot);
20228 if ((vkCreatePrivateDataSlotEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
20229 m_state->on_DeviceLost();
20230 m_state->on_CheckOutOfMemory(vkCreatePrivateDataSlotEXT_VkResult_return, opcode,
20231 context);
20232 vkStream->unsetHandleMapping();
20233 uint64_t cgen_var_3;
20234 vkStream->handleMapping()->mapHandles_VkPrivateDataSlot_u64(pPrivateDataSlot,
20235 &cgen_var_3, 1);
20236 vkStream->write((uint64_t*)&cgen_var_3, 8);
20237 vkStream->write(&vkCreatePrivateDataSlotEXT_VkResult_return, sizeof(VkResult));
20238 vkStream->commitWrite();
20239 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20240 (uintptr_t)snapshotTraceBegin);
20241 size_t snapshotTraceBytes = vkReadStream->endTrace();
20242 if (m_state->snapshotsEnabled()) {
20243 m_state->snapshot()->vkCreatePrivateDataSlotEXT(
20244 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
20245 vkCreatePrivateDataSlotEXT_VkResult_return, device, pCreateInfo, pAllocator,
20246 pPrivateDataSlot);
20247 }
20248 vkReadStream->clearPool();
20249 if (m_queueSubmitWithCommandsEnabled)
20250 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20251 break;
20252 }
20253 case OP_vkDestroyPrivateDataSlotEXT: {
20254 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20255 "VkDecoder vkDestroyPrivateDataSlotEXT");
20256 VkDevice device;
20257 VkPrivateDataSlot privateDataSlot;
20258 const VkAllocationCallbacks* pAllocator;
20259 // Begin non wrapped dispatchable handle unboxing for device;
20260 uint64_t cgen_var_0;
20261 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20262 *readStreamPtrPtr += 1 * 8;
20263 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
20264 auto unboxed_device = unbox_VkDevice(device);
20265 auto vk = dispatch_VkDevice(device);
20266 // End manual dispatchable handle unboxing for device;
20267 uint64_t cgen_var_1;
20268 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
20269 *readStreamPtrPtr += 1 * 8;
20270 *(VkPrivateDataSlot*)&privateDataSlot =
20271 (VkPrivateDataSlot)unbox_VkPrivateDataSlot((VkPrivateDataSlot)(*&cgen_var_1));
20272 // WARNING PTR CHECK
20273 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
20274 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
20275 *readStreamPtrPtr += 8;
20276 if (pAllocator) {
20277 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
20278 reservedunmarshal_VkAllocationCallbacks(
20279 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20280 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
20281 }
20282 if (pAllocator) {
20283 transform_tohost_VkAllocationCallbacks(m_state,
20284 (VkAllocationCallbacks*)(pAllocator));
20285 }
20286 if (m_logCalls) {
20287 fprintf(stderr,
20288 "stream %p: call vkDestroyPrivateDataSlotEXT 0x%llx 0x%llx 0x%llx \n",
20289 ioStream, (unsigned long long)device,
20290 (unsigned long long)privateDataSlot, (unsigned long long)pAllocator);
20291 }
20292 vk->vkDestroyPrivateDataSlotEXT(unboxed_device, privateDataSlot, pAllocator);
20293 vkStream->unsetHandleMapping();
20294 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20295 (uintptr_t)snapshotTraceBegin);
20296 size_t snapshotTraceBytes = vkReadStream->endTrace();
20297 if (m_state->snapshotsEnabled()) {
20298 m_state->snapshot()->vkDestroyPrivateDataSlotEXT(
20299 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, privateDataSlot,
20300 pAllocator);
20301 }
20302 vkReadStream->clearPool();
20303 if (m_queueSubmitWithCommandsEnabled)
20304 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20305 break;
20306 }
20307 case OP_vkSetPrivateDataEXT: {
20308 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20309 "VkDecoder vkSetPrivateDataEXT");
20310 VkDevice device;
20311 VkObjectType objectType;
20312 uint64_t objectHandle;
20313 VkPrivateDataSlot privateDataSlot;
20314 uint64_t data;
20315 // Begin non wrapped dispatchable handle unboxing for device;
20316 uint64_t cgen_var_0;
20317 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20318 *readStreamPtrPtr += 1 * 8;
20319 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
20320 auto unboxed_device = unbox_VkDevice(device);
20321 auto vk = dispatch_VkDevice(device);
20322 // End manual dispatchable handle unboxing for device;
20323 memcpy((VkObjectType*)&objectType, *readStreamPtrPtr, sizeof(VkObjectType));
20324 *readStreamPtrPtr += sizeof(VkObjectType);
20325 memcpy((uint64_t*)&objectHandle, *readStreamPtrPtr, sizeof(uint64_t));
20326 *readStreamPtrPtr += sizeof(uint64_t);
20327 uint64_t cgen_var_1;
20328 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
20329 *readStreamPtrPtr += 1 * 8;
20330 *(VkPrivateDataSlot*)&privateDataSlot =
20331 (VkPrivateDataSlot)unbox_VkPrivateDataSlot((VkPrivateDataSlot)(*&cgen_var_1));
20332 memcpy((uint64_t*)&data, *readStreamPtrPtr, sizeof(uint64_t));
20333 *readStreamPtrPtr += sizeof(uint64_t);
20334 if (m_logCalls) {
20335 fprintf(
20336 stderr,
20337 "stream %p: call vkSetPrivateDataEXT 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
20338 ioStream, (unsigned long long)device, (unsigned long long)objectType,
20339 (unsigned long long)objectHandle, (unsigned long long)privateDataSlot,
20340 (unsigned long long)data);
20341 }
20342 VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
20343 vkSetPrivateDataEXT_VkResult_return = vk->vkSetPrivateDataEXT(
20344 unboxed_device, objectType, objectHandle, privateDataSlot, data);
20345 if ((vkSetPrivateDataEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
20346 m_state->on_DeviceLost();
20347 m_state->on_CheckOutOfMemory(vkSetPrivateDataEXT_VkResult_return, opcode, context);
20348 vkStream->unsetHandleMapping();
20349 vkStream->write(&vkSetPrivateDataEXT_VkResult_return, sizeof(VkResult));
20350 vkStream->commitWrite();
20351 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20352 (uintptr_t)snapshotTraceBegin);
20353 size_t snapshotTraceBytes = vkReadStream->endTrace();
20354 if (m_state->snapshotsEnabled()) {
20355 m_state->snapshot()->vkSetPrivateDataEXT(
20356 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
20357 vkSetPrivateDataEXT_VkResult_return, device, objectType, objectHandle,
20358 privateDataSlot, data);
20359 }
20360 vkReadStream->clearPool();
20361 if (m_queueSubmitWithCommandsEnabled)
20362 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20363 break;
20364 }
20365 case OP_vkGetPrivateDataEXT: {
20366 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20367 "VkDecoder vkGetPrivateDataEXT");
20368 VkDevice device;
20369 VkObjectType objectType;
20370 uint64_t objectHandle;
20371 VkPrivateDataSlot privateDataSlot;
20372 uint64_t* pData;
20373 // Begin non wrapped dispatchable handle unboxing for device;
20374 uint64_t cgen_var_0;
20375 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20376 *readStreamPtrPtr += 1 * 8;
20377 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
20378 auto unboxed_device = unbox_VkDevice(device);
20379 auto vk = dispatch_VkDevice(device);
20380 // End manual dispatchable handle unboxing for device;
20381 memcpy((VkObjectType*)&objectType, *readStreamPtrPtr, sizeof(VkObjectType));
20382 *readStreamPtrPtr += sizeof(VkObjectType);
20383 memcpy((uint64_t*)&objectHandle, *readStreamPtrPtr, sizeof(uint64_t));
20384 *readStreamPtrPtr += sizeof(uint64_t);
20385 uint64_t cgen_var_1;
20386 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
20387 *readStreamPtrPtr += 1 * 8;
20388 *(VkPrivateDataSlot*)&privateDataSlot =
20389 (VkPrivateDataSlot)unbox_VkPrivateDataSlot((VkPrivateDataSlot)(*&cgen_var_1));
20390 // Begin manual dispatchable handle unboxing for pData;
20391 vkReadStream->unsetHandleMapping();
20392 vkReadStream->alloc((void**)&pData, sizeof(uint64_t));
20393 memcpy((uint64_t*)pData, *readStreamPtrPtr, sizeof(uint64_t));
20394 *readStreamPtrPtr += sizeof(uint64_t);
20395 if (m_logCalls) {
20396 fprintf(
20397 stderr,
20398 "stream %p: call vkGetPrivateDataEXT 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
20399 ioStream, (unsigned long long)device, (unsigned long long)objectType,
20400 (unsigned long long)objectHandle, (unsigned long long)privateDataSlot,
20401 (unsigned long long)pData);
20402 }
20403 vk->vkGetPrivateDataEXT(unboxed_device, objectType, objectHandle, privateDataSlot,
20404 pData);
20405 vkStream->unsetHandleMapping();
20406 vkStream->write((uint64_t*)pData, sizeof(uint64_t));
20407 vkStream->commitWrite();
20408 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20409 (uintptr_t)snapshotTraceBegin);
20410 size_t snapshotTraceBytes = vkReadStream->endTrace();
20411 if (m_state->snapshotsEnabled()) {
20412 m_state->snapshot()->vkGetPrivateDataEXT(snapshotTraceBegin, snapshotTraceBytes,
20413 &m_pool, device, objectType,
20414 objectHandle, privateDataSlot, pData);
20415 }
20416 vkReadStream->clearPool();
20417 if (m_queueSubmitWithCommandsEnabled)
20418 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20419 break;
20420 }
20421 #endif
20422 #ifdef VK_EXT_extended_dynamic_state2
20423 case OP_vkCmdSetPatchControlPointsEXT: {
20424 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20425 "VkDecoder vkCmdSetPatchControlPointsEXT");
20426 VkCommandBuffer commandBuffer;
20427 uint32_t patchControlPoints;
20428 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
20429 uint64_t cgen_var_0;
20430 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20431 *readStreamPtrPtr += 1 * 8;
20432 *(VkCommandBuffer*)&commandBuffer =
20433 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20434 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
20435 auto vk = dispatch_VkCommandBuffer(commandBuffer);
20436 // End manual dispatchable handle unboxing for commandBuffer;
20437 memcpy((uint32_t*)&patchControlPoints, *readStreamPtrPtr, sizeof(uint32_t));
20438 *readStreamPtrPtr += sizeof(uint32_t);
20439 if (m_logCalls) {
20440 fprintf(stderr,
20441 "stream %p: call vkCmdSetPatchControlPointsEXT 0x%llx 0x%llx \n",
20442 ioStream, (unsigned long long)commandBuffer,
20443 (unsigned long long)patchControlPoints);
20444 }
20445 vk->vkCmdSetPatchControlPointsEXT(unboxed_commandBuffer, patchControlPoints);
20446 vkStream->unsetHandleMapping();
20447 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20448 (uintptr_t)snapshotTraceBegin);
20449 size_t snapshotTraceBytes = vkReadStream->endTrace();
20450 if (m_state->snapshotsEnabled()) {
20451 m_state->snapshot()->vkCmdSetPatchControlPointsEXT(
20452 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
20453 patchControlPoints);
20454 }
20455 vkReadStream->clearPool();
20456 if (m_queueSubmitWithCommandsEnabled)
20457 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20458 break;
20459 }
20460 case OP_vkCmdSetRasterizerDiscardEnableEXT: {
20461 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20462 "VkDecoder vkCmdSetRasterizerDiscardEnableEXT");
20463 VkCommandBuffer commandBuffer;
20464 VkBool32 rasterizerDiscardEnable;
20465 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
20466 uint64_t cgen_var_0;
20467 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20468 *readStreamPtrPtr += 1 * 8;
20469 *(VkCommandBuffer*)&commandBuffer =
20470 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20471 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
20472 auto vk = dispatch_VkCommandBuffer(commandBuffer);
20473 // End manual dispatchable handle unboxing for commandBuffer;
20474 memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
20475 *readStreamPtrPtr += sizeof(VkBool32);
20476 if (m_logCalls) {
20477 fprintf(stderr,
20478 "stream %p: call vkCmdSetRasterizerDiscardEnableEXT 0x%llx 0x%llx \n",
20479 ioStream, (unsigned long long)commandBuffer,
20480 (unsigned long long)rasterizerDiscardEnable);
20481 }
20482 vk->vkCmdSetRasterizerDiscardEnableEXT(unboxed_commandBuffer,
20483 rasterizerDiscardEnable);
20484 vkStream->unsetHandleMapping();
20485 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20486 (uintptr_t)snapshotTraceBegin);
20487 size_t snapshotTraceBytes = vkReadStream->endTrace();
20488 if (m_state->snapshotsEnabled()) {
20489 m_state->snapshot()->vkCmdSetRasterizerDiscardEnableEXT(
20490 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
20491 rasterizerDiscardEnable);
20492 }
20493 vkReadStream->clearPool();
20494 if (m_queueSubmitWithCommandsEnabled)
20495 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20496 break;
20497 }
20498 case OP_vkCmdSetDepthBiasEnableEXT: {
20499 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20500 "VkDecoder vkCmdSetDepthBiasEnableEXT");
20501 VkCommandBuffer commandBuffer;
20502 VkBool32 depthBiasEnable;
20503 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
20504 uint64_t cgen_var_0;
20505 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20506 *readStreamPtrPtr += 1 * 8;
20507 *(VkCommandBuffer*)&commandBuffer =
20508 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20509 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
20510 auto vk = dispatch_VkCommandBuffer(commandBuffer);
20511 // End manual dispatchable handle unboxing for commandBuffer;
20512 memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
20513 *readStreamPtrPtr += sizeof(VkBool32);
20514 if (m_logCalls) {
20515 fprintf(stderr, "stream %p: call vkCmdSetDepthBiasEnableEXT 0x%llx 0x%llx \n",
20516 ioStream, (unsigned long long)commandBuffer,
20517 (unsigned long long)depthBiasEnable);
20518 }
20519 vk->vkCmdSetDepthBiasEnableEXT(unboxed_commandBuffer, depthBiasEnable);
20520 vkStream->unsetHandleMapping();
20521 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20522 (uintptr_t)snapshotTraceBegin);
20523 size_t snapshotTraceBytes = vkReadStream->endTrace();
20524 if (m_state->snapshotsEnabled()) {
20525 m_state->snapshot()->vkCmdSetDepthBiasEnableEXT(snapshotTraceBegin,
20526 snapshotTraceBytes, &m_pool,
20527 commandBuffer, depthBiasEnable);
20528 }
20529 vkReadStream->clearPool();
20530 if (m_queueSubmitWithCommandsEnabled)
20531 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20532 break;
20533 }
20534 case OP_vkCmdSetLogicOpEXT: {
20535 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20536 "VkDecoder vkCmdSetLogicOpEXT");
20537 VkCommandBuffer commandBuffer;
20538 VkLogicOp logicOp;
20539 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
20540 uint64_t cgen_var_0;
20541 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20542 *readStreamPtrPtr += 1 * 8;
20543 *(VkCommandBuffer*)&commandBuffer =
20544 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20545 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
20546 auto vk = dispatch_VkCommandBuffer(commandBuffer);
20547 // End manual dispatchable handle unboxing for commandBuffer;
20548 memcpy((VkLogicOp*)&logicOp, *readStreamPtrPtr, sizeof(VkLogicOp));
20549 *readStreamPtrPtr += sizeof(VkLogicOp);
20550 if (m_logCalls) {
20551 fprintf(stderr, "stream %p: call vkCmdSetLogicOpEXT 0x%llx 0x%llx \n", ioStream,
20552 (unsigned long long)commandBuffer, (unsigned long long)logicOp);
20553 }
20554 vk->vkCmdSetLogicOpEXT(unboxed_commandBuffer, logicOp);
20555 vkStream->unsetHandleMapping();
20556 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20557 (uintptr_t)snapshotTraceBegin);
20558 size_t snapshotTraceBytes = vkReadStream->endTrace();
20559 if (m_state->snapshotsEnabled()) {
20560 m_state->snapshot()->vkCmdSetLogicOpEXT(snapshotTraceBegin, snapshotTraceBytes,
20561 &m_pool, commandBuffer, logicOp);
20562 }
20563 vkReadStream->clearPool();
20564 if (m_queueSubmitWithCommandsEnabled)
20565 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20566 break;
20567 }
20568 case OP_vkCmdSetPrimitiveRestartEnableEXT: {
20569 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20570 "VkDecoder vkCmdSetPrimitiveRestartEnableEXT");
20571 VkCommandBuffer commandBuffer;
20572 VkBool32 primitiveRestartEnable;
20573 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
20574 uint64_t cgen_var_0;
20575 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20576 *readStreamPtrPtr += 1 * 8;
20577 *(VkCommandBuffer*)&commandBuffer =
20578 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20579 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
20580 auto vk = dispatch_VkCommandBuffer(commandBuffer);
20581 // End manual dispatchable handle unboxing for commandBuffer;
20582 memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
20583 *readStreamPtrPtr += sizeof(VkBool32);
20584 if (m_logCalls) {
20585 fprintf(stderr,
20586 "stream %p: call vkCmdSetPrimitiveRestartEnableEXT 0x%llx 0x%llx \n",
20587 ioStream, (unsigned long long)commandBuffer,
20588 (unsigned long long)primitiveRestartEnable);
20589 }
20590 vk->vkCmdSetPrimitiveRestartEnableEXT(unboxed_commandBuffer,
20591 primitiveRestartEnable);
20592 vkStream->unsetHandleMapping();
20593 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20594 (uintptr_t)snapshotTraceBegin);
20595 size_t snapshotTraceBytes = vkReadStream->endTrace();
20596 if (m_state->snapshotsEnabled()) {
20597 m_state->snapshot()->vkCmdSetPrimitiveRestartEnableEXT(
20598 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
20599 primitiveRestartEnable);
20600 }
20601 vkReadStream->clearPool();
20602 if (m_queueSubmitWithCommandsEnabled)
20603 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20604 break;
20605 }
20606 #endif
20607 #ifdef VK_EXT_color_write_enable
20608 case OP_vkCmdSetColorWriteEnableEXT: {
20609 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20610 "VkDecoder vkCmdSetColorWriteEnableEXT");
20611 VkCommandBuffer commandBuffer;
20612 uint32_t attachmentCount;
20613 const VkBool32* pColorWriteEnables;
20614 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
20615 uint64_t cgen_var_0;
20616 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20617 *readStreamPtrPtr += 1 * 8;
20618 *(VkCommandBuffer*)&commandBuffer =
20619 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20620 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
20621 auto vk = dispatch_VkCommandBuffer(commandBuffer);
20622 // End manual dispatchable handle unboxing for commandBuffer;
20623 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
20624 *readStreamPtrPtr += sizeof(uint32_t);
20625 vkReadStream->alloc((void**)&pColorWriteEnables,
20626 ((attachmentCount)) * sizeof(const VkBool32));
20627 memcpy((VkBool32*)pColorWriteEnables, *readStreamPtrPtr,
20628 ((attachmentCount)) * sizeof(const VkBool32));
20629 *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
20630 if (m_logCalls) {
20631 fprintf(stderr,
20632 "stream %p: call vkCmdSetColorWriteEnableEXT 0x%llx 0x%llx 0x%llx \n",
20633 ioStream, (unsigned long long)commandBuffer,
20634 (unsigned long long)attachmentCount,
20635 (unsigned long long)pColorWriteEnables);
20636 }
20637 vk->vkCmdSetColorWriteEnableEXT(unboxed_commandBuffer, attachmentCount,
20638 pColorWriteEnables);
20639 vkStream->unsetHandleMapping();
20640 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20641 (uintptr_t)snapshotTraceBegin);
20642 size_t snapshotTraceBytes = vkReadStream->endTrace();
20643 if (m_state->snapshotsEnabled()) {
20644 m_state->snapshot()->vkCmdSetColorWriteEnableEXT(
20645 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
20646 attachmentCount, pColorWriteEnables);
20647 }
20648 vkReadStream->clearPool();
20649 if (m_queueSubmitWithCommandsEnabled)
20650 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20651 break;
20652 }
20653 #endif
20654 #ifdef VK_GOOGLE_gfxstream
20655 case OP_vkMapMemoryIntoAddressSpaceGOOGLE: {
20656 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20657 "VkDecoder vkMapMemoryIntoAddressSpaceGOOGLE");
20658 VkDevice device;
20659 VkDeviceMemory memory;
20660 uint64_t* pAddress;
20661 // Begin global wrapped dispatchable handle unboxing for device;
20662 uint64_t cgen_var_0;
20663 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20664 *readStreamPtrPtr += 1 * 8;
20665 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
20666 uint64_t cgen_var_1;
20667 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
20668 *readStreamPtrPtr += 1 * 8;
20669 *(VkDeviceMemory*)&memory =
20670 (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_1));
20671 // Begin manual dispatchable handle unboxing for pAddress;
20672 vkReadStream->unsetHandleMapping();
20673 // WARNING PTR CHECK
20674 memcpy((uint64_t**)&pAddress, (*readStreamPtrPtr), 8);
20675 android::base::Stream::fromBe64((uint8_t*)&pAddress);
20676 *readStreamPtrPtr += 8;
20677 if (pAddress) {
20678 vkReadStream->alloc((void**)&pAddress, sizeof(uint64_t));
20679 memcpy((uint64_t*)pAddress, *readStreamPtrPtr, sizeof(uint64_t));
20680 *readStreamPtrPtr += sizeof(uint64_t);
20681 }
20682 if (m_logCalls) {
20683 fprintf(
20684 stderr,
20685 "stream %p: call vkMapMemoryIntoAddressSpaceGOOGLE 0x%llx 0x%llx 0x%llx \n",
20686 ioStream, (unsigned long long)device, (unsigned long long)memory,
20687 (unsigned long long)pAddress);
20688 }
20689 VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
20690 vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
20691 m_state->on_vkMapMemoryIntoAddressSpaceGOOGLE(&m_pool, device, memory,
20692 pAddress);
20693 if ((vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return) == VK_ERROR_DEVICE_LOST)
20694 m_state->on_DeviceLost();
20695 m_state->on_CheckOutOfMemory(vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return,
20696 opcode, context);
20697 vkStream->unsetHandleMapping();
20698 // WARNING PTR CHECK
20699 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pAddress;
20700 vkStream->putBe64(cgen_var_3);
20701 if (pAddress) {
20702 vkStream->write((uint64_t*)pAddress, sizeof(uint64_t));
20703 }
20704 vkStream->write(&vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return,
20705 sizeof(VkResult));
20706 vkStream->commitWrite();
20707 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20708 (uintptr_t)snapshotTraceBegin);
20709 size_t snapshotTraceBytes = vkReadStream->endTrace();
20710 if (m_state->snapshotsEnabled()) {
20711 m_state->snapshot()->vkMapMemoryIntoAddressSpaceGOOGLE(
20712 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
20713 vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, device, memory,
20714 pAddress);
20715 }
20716 vkReadStream->clearPool();
20717 if (m_queueSubmitWithCommandsEnabled)
20718 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20719 break;
20720 }
20721 case OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE: {
20722 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20723 "VkDecoder vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
20724 VkDevice device;
20725 VkDescriptorSet descriptorSet;
20726 VkDescriptorUpdateTemplate descriptorUpdateTemplate;
20727 uint32_t imageInfoCount;
20728 uint32_t bufferInfoCount;
20729 uint32_t bufferViewCount;
20730 const uint32_t* pImageInfoEntryIndices;
20731 const uint32_t* pBufferInfoEntryIndices;
20732 const uint32_t* pBufferViewEntryIndices;
20733 const VkDescriptorImageInfo* pImageInfos;
20734 const VkDescriptorBufferInfo* pBufferInfos;
20735 const VkBufferView* pBufferViews;
20736 // Begin global wrapped dispatchable handle unboxing for device;
20737 uint64_t cgen_var_0;
20738 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20739 *readStreamPtrPtr += 1 * 8;
20740 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
20741 uint64_t cgen_var_1;
20742 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
20743 *readStreamPtrPtr += 1 * 8;
20744 *(VkDescriptorSet*)&descriptorSet =
20745 (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)(*&cgen_var_1));
20746 uint64_t cgen_var_2;
20747 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
20748 *readStreamPtrPtr += 1 * 8;
20749 *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate =
20750 (VkDescriptorUpdateTemplate)unbox_VkDescriptorUpdateTemplate(
20751 (VkDescriptorUpdateTemplate)(*&cgen_var_2));
20752 memcpy((uint32_t*)&imageInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
20753 *readStreamPtrPtr += sizeof(uint32_t);
20754 memcpy((uint32_t*)&bufferInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
20755 *readStreamPtrPtr += sizeof(uint32_t);
20756 memcpy((uint32_t*)&bufferViewCount, *readStreamPtrPtr, sizeof(uint32_t));
20757 *readStreamPtrPtr += sizeof(uint32_t);
20758 // WARNING PTR CHECK
20759 memcpy((uint32_t**)&pImageInfoEntryIndices, (*readStreamPtrPtr), 8);
20760 android::base::Stream::fromBe64((uint8_t*)&pImageInfoEntryIndices);
20761 *readStreamPtrPtr += 8;
20762 if (pImageInfoEntryIndices) {
20763 vkReadStream->alloc((void**)&pImageInfoEntryIndices,
20764 ((imageInfoCount)) * sizeof(const uint32_t));
20765 memcpy((uint32_t*)pImageInfoEntryIndices, *readStreamPtrPtr,
20766 ((imageInfoCount)) * sizeof(const uint32_t));
20767 *readStreamPtrPtr += ((imageInfoCount)) * sizeof(const uint32_t);
20768 }
20769 // WARNING PTR CHECK
20770 memcpy((uint32_t**)&pBufferInfoEntryIndices, (*readStreamPtrPtr), 8);
20771 android::base::Stream::fromBe64((uint8_t*)&pBufferInfoEntryIndices);
20772 *readStreamPtrPtr += 8;
20773 if (pBufferInfoEntryIndices) {
20774 vkReadStream->alloc((void**)&pBufferInfoEntryIndices,
20775 ((bufferInfoCount)) * sizeof(const uint32_t));
20776 memcpy((uint32_t*)pBufferInfoEntryIndices, *readStreamPtrPtr,
20777 ((bufferInfoCount)) * sizeof(const uint32_t));
20778 *readStreamPtrPtr += ((bufferInfoCount)) * sizeof(const uint32_t);
20779 }
20780 // WARNING PTR CHECK
20781 memcpy((uint32_t**)&pBufferViewEntryIndices, (*readStreamPtrPtr), 8);
20782 android::base::Stream::fromBe64((uint8_t*)&pBufferViewEntryIndices);
20783 *readStreamPtrPtr += 8;
20784 if (pBufferViewEntryIndices) {
20785 vkReadStream->alloc((void**)&pBufferViewEntryIndices,
20786 ((bufferViewCount)) * sizeof(const uint32_t));
20787 memcpy((uint32_t*)pBufferViewEntryIndices, *readStreamPtrPtr,
20788 ((bufferViewCount)) * sizeof(const uint32_t));
20789 *readStreamPtrPtr += ((bufferViewCount)) * sizeof(const uint32_t);
20790 }
20791 // WARNING PTR CHECK
20792 memcpy((VkDescriptorImageInfo**)&pImageInfos, (*readStreamPtrPtr), 8);
20793 android::base::Stream::fromBe64((uint8_t*)&pImageInfos);
20794 *readStreamPtrPtr += 8;
20795 if (pImageInfos) {
20796 vkReadStream->alloc((void**)&pImageInfos,
20797 ((imageInfoCount)) * sizeof(const VkDescriptorImageInfo));
20798 for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
20799 reservedunmarshal_VkDescriptorImageInfo(
20800 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20801 (VkDescriptorImageInfo*)(pImageInfos + i), readStreamPtrPtr);
20802 }
20803 }
20804 // WARNING PTR CHECK
20805 memcpy((VkDescriptorBufferInfo**)&pBufferInfos, (*readStreamPtrPtr), 8);
20806 android::base::Stream::fromBe64((uint8_t*)&pBufferInfos);
20807 *readStreamPtrPtr += 8;
20808 if (pBufferInfos) {
20809 vkReadStream->alloc((void**)&pBufferInfos,
20810 ((bufferInfoCount)) * sizeof(const VkDescriptorBufferInfo));
20811 for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
20812 reservedunmarshal_VkDescriptorBufferInfo(
20813 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20814 (VkDescriptorBufferInfo*)(pBufferInfos + i), readStreamPtrPtr);
20815 }
20816 }
20817 // WARNING PTR CHECK
20818 memcpy((VkBufferView**)&pBufferViews, (*readStreamPtrPtr), 8);
20819 android::base::Stream::fromBe64((uint8_t*)&pBufferViews);
20820 *readStreamPtrPtr += 8;
20821 if (pBufferViews) {
20822 vkReadStream->alloc((void**)&pBufferViews,
20823 ((bufferViewCount)) * sizeof(const VkBufferView));
20824 if (((bufferViewCount))) {
20825 uint8_t* cgen_var_8_0_ptr = (uint8_t*)(*readStreamPtrPtr);
20826 *readStreamPtrPtr += 8 * ((bufferViewCount));
20827 for (uint32_t k = 0; k < ((bufferViewCount)); ++k) {
20828 uint64_t tmpval;
20829 memcpy(&tmpval, cgen_var_8_0_ptr + k * 8, sizeof(uint64_t));
20830 *(((VkBufferView*)pBufferViews) + k) =
20831 tmpval ? (VkBufferView)unbox_VkBufferView((VkBufferView)tmpval)
20832 : VK_NULL_HANDLE;
20833 }
20834 }
20835 }
20836 if (pImageInfos) {
20837 for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
20838 transform_tohost_VkDescriptorImageInfo(
20839 m_state, (VkDescriptorImageInfo*)(pImageInfos + i));
20840 }
20841 }
20842 if (pBufferInfos) {
20843 for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
20844 transform_tohost_VkDescriptorBufferInfo(
20845 m_state, (VkDescriptorBufferInfo*)(pBufferInfos + i));
20846 }
20847 }
20848 if (m_logCalls) {
20849 fprintf(stderr,
20850 "stream %p: call vkUpdateDescriptorSetWithTemplateSizedGOOGLE 0x%llx "
20851 "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
20852 "0x%llx \n",
20853 ioStream, (unsigned long long)device, (unsigned long long)descriptorSet,
20854 (unsigned long long)descriptorUpdateTemplate,
20855 (unsigned long long)imageInfoCount, (unsigned long long)bufferInfoCount,
20856 (unsigned long long)bufferViewCount,
20857 (unsigned long long)pImageInfoEntryIndices,
20858 (unsigned long long)pBufferInfoEntryIndices,
20859 (unsigned long long)pBufferViewEntryIndices,
20860 (unsigned long long)pImageInfos, (unsigned long long)pBufferInfos,
20861 (unsigned long long)pBufferViews);
20862 }
20863 m_state->on_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
20864 &m_pool, device, descriptorSet, descriptorUpdateTemplate, imageInfoCount,
20865 bufferInfoCount, bufferViewCount, pImageInfoEntryIndices,
20866 pBufferInfoEntryIndices, pBufferViewEntryIndices, pImageInfos, pBufferInfos,
20867 pBufferViews);
20868 vkStream->unsetHandleMapping();
20869 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20870 (uintptr_t)snapshotTraceBegin);
20871 size_t snapshotTraceBytes = vkReadStream->endTrace();
20872 if (m_state->snapshotsEnabled()) {
20873 m_state->snapshot()->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
20874 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, descriptorSet,
20875 descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount,
20876 pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
20877 pImageInfos, pBufferInfos, pBufferViews);
20878 }
20879 vkReadStream->clearPool();
20880 if (m_queueSubmitWithCommandsEnabled)
20881 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20882 break;
20883 }
20884 case OP_vkBeginCommandBufferAsyncGOOGLE: {
20885 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20886 "VkDecoder vkBeginCommandBufferAsyncGOOGLE");
20887 VkCommandBuffer commandBuffer;
20888 const VkCommandBufferBeginInfo* pBeginInfo;
20889 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
20890 uint64_t cgen_var_0;
20891 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20892 *readStreamPtrPtr += 1 * 8;
20893 *(VkCommandBuffer*)&commandBuffer =
20894 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20895 vkReadStream->alloc((void**)&pBeginInfo, sizeof(const VkCommandBufferBeginInfo));
20896 reservedunmarshal_VkCommandBufferBeginInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
20897 (VkCommandBufferBeginInfo*)(pBeginInfo),
20898 readStreamPtrPtr);
20899 if (pBeginInfo) {
20900 transform_tohost_VkCommandBufferBeginInfo(
20901 m_state, (VkCommandBufferBeginInfo*)(pBeginInfo));
20902 }
20903 if (m_logCalls) {
20904 fprintf(stderr,
20905 "stream %p: call vkBeginCommandBufferAsyncGOOGLE 0x%llx 0x%llx \n",
20906 ioStream, (unsigned long long)commandBuffer,
20907 (unsigned long long)pBeginInfo);
20908 }
20909 m_state->on_vkBeginCommandBufferAsyncGOOGLE(&m_pool, commandBuffer, pBeginInfo,
20910 context);
20911 vkStream->unsetHandleMapping();
20912 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20913 (uintptr_t)snapshotTraceBegin);
20914 size_t snapshotTraceBytes = vkReadStream->endTrace();
20915 if (m_state->snapshotsEnabled()) {
20916 m_state->snapshot()->vkBeginCommandBufferAsyncGOOGLE(
20917 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, pBeginInfo);
20918 }
20919 vkReadStream->clearPool();
20920 if (m_queueSubmitWithCommandsEnabled)
20921 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20922 break;
20923 }
20924 case OP_vkEndCommandBufferAsyncGOOGLE: {
20925 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20926 "VkDecoder vkEndCommandBufferAsyncGOOGLE");
20927 VkCommandBuffer commandBuffer;
20928 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
20929 uint64_t cgen_var_0;
20930 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20931 *readStreamPtrPtr += 1 * 8;
20932 *(VkCommandBuffer*)&commandBuffer =
20933 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20934 if (m_logCalls) {
20935 fprintf(stderr, "stream %p: call vkEndCommandBufferAsyncGOOGLE 0x%llx \n",
20936 ioStream, (unsigned long long)commandBuffer);
20937 }
20938 m_state->on_vkEndCommandBufferAsyncGOOGLE(&m_pool, commandBuffer, context);
20939 vkStream->unsetHandleMapping();
20940 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20941 (uintptr_t)snapshotTraceBegin);
20942 size_t snapshotTraceBytes = vkReadStream->endTrace();
20943 if (m_state->snapshotsEnabled()) {
20944 m_state->snapshot()->vkEndCommandBufferAsyncGOOGLE(
20945 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer);
20946 }
20947 vkReadStream->clearPool();
20948 if (m_queueSubmitWithCommandsEnabled)
20949 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20950 break;
20951 }
20952 case OP_vkResetCommandBufferAsyncGOOGLE: {
20953 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20954 "VkDecoder vkResetCommandBufferAsyncGOOGLE");
20955 VkCommandBuffer commandBuffer;
20956 VkCommandBufferResetFlags flags;
20957 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
20958 uint64_t cgen_var_0;
20959 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20960 *readStreamPtrPtr += 1 * 8;
20961 *(VkCommandBuffer*)&commandBuffer =
20962 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20963 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr,
20964 sizeof(VkCommandBufferResetFlags));
20965 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
20966 if (m_logCalls) {
20967 fprintf(stderr,
20968 "stream %p: call vkResetCommandBufferAsyncGOOGLE 0x%llx 0x%llx \n",
20969 ioStream, (unsigned long long)commandBuffer, (unsigned long long)flags);
20970 }
20971 m_state->on_vkResetCommandBufferAsyncGOOGLE(&m_pool, commandBuffer, flags);
20972 vkStream->unsetHandleMapping();
20973 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
20974 (uintptr_t)snapshotTraceBegin);
20975 size_t snapshotTraceBytes = vkReadStream->endTrace();
20976 if (m_state->snapshotsEnabled()) {
20977 m_state->snapshot()->vkResetCommandBufferAsyncGOOGLE(
20978 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, flags);
20979 }
20980 vkReadStream->clearPool();
20981 if (m_queueSubmitWithCommandsEnabled)
20982 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
20983 break;
20984 }
20985 case OP_vkCommandBufferHostSyncGOOGLE: {
20986 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
20987 "VkDecoder vkCommandBufferHostSyncGOOGLE");
20988 VkCommandBuffer commandBuffer;
20989 uint32_t needHostSync;
20990 uint32_t sequenceNumber;
20991 // Begin global wrapped dispatchable handle unboxing for commandBuffer;
20992 uint64_t cgen_var_0;
20993 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
20994 *readStreamPtrPtr += 1 * 8;
20995 *(VkCommandBuffer*)&commandBuffer =
20996 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
20997 memcpy((uint32_t*)&needHostSync, *readStreamPtrPtr, sizeof(uint32_t));
20998 *readStreamPtrPtr += sizeof(uint32_t);
20999 memcpy((uint32_t*)&sequenceNumber, *readStreamPtrPtr, sizeof(uint32_t));
21000 *readStreamPtrPtr += sizeof(uint32_t);
21001 if (m_logCalls) {
21002 fprintf(stderr,
21003 "stream %p: call vkCommandBufferHostSyncGOOGLE 0x%llx 0x%llx 0x%llx \n",
21004 ioStream, (unsigned long long)commandBuffer,
21005 (unsigned long long)needHostSync, (unsigned long long)sequenceNumber);
21006 }
21007 m_state->on_vkCommandBufferHostSyncGOOGLE(&m_pool, commandBuffer, needHostSync,
21008 sequenceNumber);
21009 vkStream->unsetHandleMapping();
21010 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21011 (uintptr_t)snapshotTraceBegin);
21012 size_t snapshotTraceBytes = vkReadStream->endTrace();
21013 if (m_state->snapshotsEnabled()) {
21014 m_state->snapshot()->vkCommandBufferHostSyncGOOGLE(
21015 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
21016 needHostSync, sequenceNumber);
21017 }
21018 vkReadStream->clearPool();
21019 if (m_queueSubmitWithCommandsEnabled)
21020 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21021 break;
21022 }
21023 case OP_vkCreateImageWithRequirementsGOOGLE: {
21024 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21025 "VkDecoder vkCreateImageWithRequirementsGOOGLE");
21026 VkDevice device;
21027 const VkImageCreateInfo* pCreateInfo;
21028 const VkAllocationCallbacks* pAllocator;
21029 VkImage* pImage;
21030 VkMemoryRequirements* pMemoryRequirements;
21031 // Begin global wrapped dispatchable handle unboxing for device;
21032 uint64_t cgen_var_0;
21033 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21034 *readStreamPtrPtr += 1 * 8;
21035 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
21036 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkImageCreateInfo));
21037 reservedunmarshal_VkImageCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21038 (VkImageCreateInfo*)(pCreateInfo),
21039 readStreamPtrPtr);
21040 // WARNING PTR CHECK
21041 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
21042 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
21043 *readStreamPtrPtr += 8;
21044 if (pAllocator) {
21045 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
21046 reservedunmarshal_VkAllocationCallbacks(
21047 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21048 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
21049 }
21050 // Begin manual dispatchable handle unboxing for pImage;
21051 vkReadStream->unsetHandleMapping();
21052 vkReadStream->alloc((void**)&pImage, sizeof(VkImage));
21053 uint64_t cgen_var_2;
21054 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
21055 *readStreamPtrPtr += 8;
21056 *(VkImage*)pImage = (VkImage)(VkImage)((VkImage)(*&cgen_var_2));
21057 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
21058 vkReadStream->unsetHandleMapping();
21059 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements));
21060 reservedunmarshal_VkMemoryRequirements(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21061 (VkMemoryRequirements*)(pMemoryRequirements),
21062 readStreamPtrPtr);
21063 if (pCreateInfo) {
21064 m_state->transformImpl_VkImageCreateInfo_tohost(pCreateInfo, 1);
21065 transform_tohost_VkImageCreateInfo(m_state, (VkImageCreateInfo*)(pCreateInfo));
21066 }
21067 if (pAllocator) {
21068 transform_tohost_VkAllocationCallbacks(m_state,
21069 (VkAllocationCallbacks*)(pAllocator));
21070 }
21071 if (pMemoryRequirements) {
21072 transform_tohost_VkMemoryRequirements(
21073 m_state, (VkMemoryRequirements*)(pMemoryRequirements));
21074 }
21075 if (m_logCalls) {
21076 fprintf(stderr,
21077 "stream %p: call vkCreateImageWithRequirementsGOOGLE 0x%llx 0x%llx "
21078 "0x%llx 0x%llx 0x%llx \n",
21079 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
21080 (unsigned long long)pAllocator, (unsigned long long)pImage,
21081 (unsigned long long)pMemoryRequirements);
21082 }
21083 VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
21084 vkCreateImageWithRequirementsGOOGLE_VkResult_return =
21085 m_state->on_vkCreateImageWithRequirementsGOOGLE(
21086 &m_pool, device, pCreateInfo, pAllocator, pImage, pMemoryRequirements);
21087 if ((vkCreateImageWithRequirementsGOOGLE_VkResult_return) == VK_ERROR_DEVICE_LOST)
21088 m_state->on_DeviceLost();
21089 m_state->on_CheckOutOfMemory(vkCreateImageWithRequirementsGOOGLE_VkResult_return,
21090 opcode, context);
21091 vkStream->unsetHandleMapping();
21092 // Begin manual non dispatchable handle create for pImage;
21093 vkStream->unsetHandleMapping();
21094 uint64_t cgen_var_3;
21095 static_assert(8 == sizeof(VkImage),
21096 "handle map overwrite requires VkImage to be 8 bytes long");
21097 vkStream->handleMapping()->mapHandles_VkImage((VkImage*)pImage, 1);
21098 vkStream->write((VkImage*)pImage, 8 * 1);
21099 // Begin manual non dispatchable handle create for pImage;
21100 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
21101 if (pMemoryRequirements) {
21102 transform_fromhost_VkMemoryRequirements(
21103 m_state, (VkMemoryRequirements*)(pMemoryRequirements));
21104 }
21105 marshal_VkMemoryRequirements(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21106 (VkMemoryRequirements*)(pMemoryRequirements));
21107 vkStream->write(&vkCreateImageWithRequirementsGOOGLE_VkResult_return,
21108 sizeof(VkResult));
21109 vkStream->commitWrite();
21110 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21111 (uintptr_t)snapshotTraceBegin);
21112 size_t snapshotTraceBytes = vkReadStream->endTrace();
21113 if (m_state->snapshotsEnabled()) {
21114 m_state->snapshot()->vkCreateImageWithRequirementsGOOGLE(
21115 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
21116 vkCreateImageWithRequirementsGOOGLE_VkResult_return, device, pCreateInfo,
21117 pAllocator, pImage, pMemoryRequirements);
21118 }
21119 vkReadStream->clearPool();
21120 if (m_queueSubmitWithCommandsEnabled)
21121 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21122 break;
21123 }
21124 case OP_vkCreateBufferWithRequirementsGOOGLE: {
21125 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21126 "VkDecoder vkCreateBufferWithRequirementsGOOGLE");
21127 VkDevice device;
21128 const VkBufferCreateInfo* pCreateInfo;
21129 const VkAllocationCallbacks* pAllocator;
21130 VkBuffer* pBuffer;
21131 VkMemoryRequirements* pMemoryRequirements;
21132 // Begin global wrapped dispatchable handle unboxing for device;
21133 uint64_t cgen_var_0;
21134 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21135 *readStreamPtrPtr += 1 * 8;
21136 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
21137 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkBufferCreateInfo));
21138 reservedunmarshal_VkBufferCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21139 (VkBufferCreateInfo*)(pCreateInfo),
21140 readStreamPtrPtr);
21141 // WARNING PTR CHECK
21142 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
21143 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
21144 *readStreamPtrPtr += 8;
21145 if (pAllocator) {
21146 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
21147 reservedunmarshal_VkAllocationCallbacks(
21148 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21149 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
21150 }
21151 // Begin manual dispatchable handle unboxing for pBuffer;
21152 vkReadStream->unsetHandleMapping();
21153 vkReadStream->alloc((void**)&pBuffer, sizeof(VkBuffer));
21154 uint64_t cgen_var_2;
21155 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
21156 *readStreamPtrPtr += 8;
21157 *(VkBuffer*)pBuffer = (VkBuffer)(VkBuffer)((VkBuffer)(*&cgen_var_2));
21158 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
21159 vkReadStream->unsetHandleMapping();
21160 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements));
21161 reservedunmarshal_VkMemoryRequirements(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21162 (VkMemoryRequirements*)(pMemoryRequirements),
21163 readStreamPtrPtr);
21164 if (pCreateInfo) {
21165 transform_tohost_VkBufferCreateInfo(m_state,
21166 (VkBufferCreateInfo*)(pCreateInfo));
21167 }
21168 if (pAllocator) {
21169 transform_tohost_VkAllocationCallbacks(m_state,
21170 (VkAllocationCallbacks*)(pAllocator));
21171 }
21172 if (pMemoryRequirements) {
21173 transform_tohost_VkMemoryRequirements(
21174 m_state, (VkMemoryRequirements*)(pMemoryRequirements));
21175 }
21176 if (m_logCalls) {
21177 fprintf(stderr,
21178 "stream %p: call vkCreateBufferWithRequirementsGOOGLE 0x%llx 0x%llx "
21179 "0x%llx 0x%llx 0x%llx \n",
21180 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
21181 (unsigned long long)pAllocator, (unsigned long long)pBuffer,
21182 (unsigned long long)pMemoryRequirements);
21183 }
21184 VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
21185 vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
21186 m_state->on_vkCreateBufferWithRequirementsGOOGLE(
21187 &m_pool, device, pCreateInfo, pAllocator, pBuffer, pMemoryRequirements);
21188 if ((vkCreateBufferWithRequirementsGOOGLE_VkResult_return) == VK_ERROR_DEVICE_LOST)
21189 m_state->on_DeviceLost();
21190 m_state->on_CheckOutOfMemory(vkCreateBufferWithRequirementsGOOGLE_VkResult_return,
21191 opcode, context);
21192 vkStream->unsetHandleMapping();
21193 // Begin manual non dispatchable handle create for pBuffer;
21194 vkStream->unsetHandleMapping();
21195 uint64_t cgen_var_3;
21196 static_assert(8 == sizeof(VkBuffer),
21197 "handle map overwrite requires VkBuffer to be 8 bytes long");
21198 vkStream->handleMapping()->mapHandles_VkBuffer((VkBuffer*)pBuffer, 1);
21199 vkStream->write((VkBuffer*)pBuffer, 8 * 1);
21200 // Begin manual non dispatchable handle create for pBuffer;
21201 vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
21202 if (pMemoryRequirements) {
21203 transform_fromhost_VkMemoryRequirements(
21204 m_state, (VkMemoryRequirements*)(pMemoryRequirements));
21205 }
21206 marshal_VkMemoryRequirements(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21207 (VkMemoryRequirements*)(pMemoryRequirements));
21208 vkStream->write(&vkCreateBufferWithRequirementsGOOGLE_VkResult_return,
21209 sizeof(VkResult));
21210 vkStream->commitWrite();
21211 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21212 (uintptr_t)snapshotTraceBegin);
21213 size_t snapshotTraceBytes = vkReadStream->endTrace();
21214 if (m_state->snapshotsEnabled()) {
21215 m_state->snapshot()->vkCreateBufferWithRequirementsGOOGLE(
21216 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
21217 vkCreateBufferWithRequirementsGOOGLE_VkResult_return, device, pCreateInfo,
21218 pAllocator, pBuffer, pMemoryRequirements);
21219 }
21220 vkReadStream->clearPool();
21221 if (m_queueSubmitWithCommandsEnabled)
21222 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21223 break;
21224 }
21225 case OP_vkGetMemoryHostAddressInfoGOOGLE: {
21226 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21227 "VkDecoder vkGetMemoryHostAddressInfoGOOGLE");
21228 VkDevice device;
21229 VkDeviceMemory memory;
21230 uint64_t* pAddress;
21231 uint64_t* pSize;
21232 uint64_t* pHostmemId;
21233 // Begin global wrapped dispatchable handle unboxing for device;
21234 uint64_t cgen_var_0;
21235 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21236 *readStreamPtrPtr += 1 * 8;
21237 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
21238 uint64_t cgen_var_1;
21239 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
21240 *readStreamPtrPtr += 1 * 8;
21241 *(VkDeviceMemory*)&memory =
21242 (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_1));
21243 // Begin manual dispatchable handle unboxing for pAddress;
21244 vkReadStream->unsetHandleMapping();
21245 // WARNING PTR CHECK
21246 memcpy((uint64_t**)&pAddress, (*readStreamPtrPtr), 8);
21247 android::base::Stream::fromBe64((uint8_t*)&pAddress);
21248 *readStreamPtrPtr += 8;
21249 if (pAddress) {
21250 vkReadStream->alloc((void**)&pAddress, sizeof(uint64_t));
21251 memcpy((uint64_t*)pAddress, *readStreamPtrPtr, sizeof(uint64_t));
21252 *readStreamPtrPtr += sizeof(uint64_t);
21253 }
21254 // Begin manual dispatchable handle unboxing for pSize;
21255 vkReadStream->unsetHandleMapping();
21256 // WARNING PTR CHECK
21257 memcpy((uint64_t**)&pSize, (*readStreamPtrPtr), 8);
21258 android::base::Stream::fromBe64((uint8_t*)&pSize);
21259 *readStreamPtrPtr += 8;
21260 if (pSize) {
21261 vkReadStream->alloc((void**)&pSize, sizeof(uint64_t));
21262 memcpy((uint64_t*)pSize, *readStreamPtrPtr, sizeof(uint64_t));
21263 *readStreamPtrPtr += sizeof(uint64_t);
21264 }
21265 // Begin manual dispatchable handle unboxing for pHostmemId;
21266 vkReadStream->unsetHandleMapping();
21267 // WARNING PTR CHECK
21268 memcpy((uint64_t**)&pHostmemId, (*readStreamPtrPtr), 8);
21269 android::base::Stream::fromBe64((uint8_t*)&pHostmemId);
21270 *readStreamPtrPtr += 8;
21271 if (pHostmemId) {
21272 vkReadStream->alloc((void**)&pHostmemId, sizeof(uint64_t));
21273 memcpy((uint64_t*)pHostmemId, *readStreamPtrPtr, sizeof(uint64_t));
21274 *readStreamPtrPtr += sizeof(uint64_t);
21275 }
21276 if (m_logCalls) {
21277 fprintf(stderr,
21278 "stream %p: call vkGetMemoryHostAddressInfoGOOGLE 0x%llx 0x%llx 0x%llx "
21279 "0x%llx 0x%llx \n",
21280 ioStream, (unsigned long long)device, (unsigned long long)memory,
21281 (unsigned long long)pAddress, (unsigned long long)pSize,
21282 (unsigned long long)pHostmemId);
21283 }
21284 VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
21285 vkGetMemoryHostAddressInfoGOOGLE_VkResult_return =
21286 m_state->on_vkGetMemoryHostAddressInfoGOOGLE(&m_pool, device, memory, pAddress,
21287 pSize, pHostmemId);
21288 if ((vkGetMemoryHostAddressInfoGOOGLE_VkResult_return) == VK_ERROR_DEVICE_LOST)
21289 m_state->on_DeviceLost();
21290 m_state->on_CheckOutOfMemory(vkGetMemoryHostAddressInfoGOOGLE_VkResult_return,
21291 opcode, context);
21292 vkStream->unsetHandleMapping();
21293 // WARNING PTR CHECK
21294 uint64_t cgen_var_5 = (uint64_t)(uintptr_t)pAddress;
21295 vkStream->putBe64(cgen_var_5);
21296 if (pAddress) {
21297 vkStream->write((uint64_t*)pAddress, sizeof(uint64_t));
21298 }
21299 // WARNING PTR CHECK
21300 uint64_t cgen_var_6 = (uint64_t)(uintptr_t)pSize;
21301 vkStream->putBe64(cgen_var_6);
21302 if (pSize) {
21303 vkStream->write((uint64_t*)pSize, sizeof(uint64_t));
21304 }
21305 // WARNING PTR CHECK
21306 uint64_t cgen_var_7 = (uint64_t)(uintptr_t)pHostmemId;
21307 vkStream->putBe64(cgen_var_7);
21308 if (pHostmemId) {
21309 vkStream->write((uint64_t*)pHostmemId, sizeof(uint64_t));
21310 }
21311 vkStream->write(&vkGetMemoryHostAddressInfoGOOGLE_VkResult_return,
21312 sizeof(VkResult));
21313 vkStream->commitWrite();
21314 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21315 (uintptr_t)snapshotTraceBegin);
21316 size_t snapshotTraceBytes = vkReadStream->endTrace();
21317 if (m_state->snapshotsEnabled()) {
21318 m_state->snapshot()->vkGetMemoryHostAddressInfoGOOGLE(
21319 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
21320 vkGetMemoryHostAddressInfoGOOGLE_VkResult_return, device, memory, pAddress,
21321 pSize, pHostmemId);
21322 }
21323 vkReadStream->clearPool();
21324 if (m_queueSubmitWithCommandsEnabled)
21325 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21326 break;
21327 }
21328 case OP_vkFreeMemorySyncGOOGLE: {
21329 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21330 "VkDecoder vkFreeMemorySyncGOOGLE");
21331 VkDevice device;
21332 VkDeviceMemory memory;
21333 const VkAllocationCallbacks* pAllocator;
21334 // Begin global wrapped dispatchable handle unboxing for device;
21335 uint64_t cgen_var_0;
21336 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21337 *readStreamPtrPtr += 1 * 8;
21338 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
21339 // Begin manual non dispatchable handle destroy unboxing for memory;
21340 VkDeviceMemory boxed_memory_preserve;
21341 uint64_t cgen_var_1;
21342 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
21343 *readStreamPtrPtr += 1 * 8;
21344 *(VkDeviceMemory*)&memory =
21345 (VkDeviceMemory)(VkDeviceMemory)((VkDeviceMemory)(*&cgen_var_1));
21346 boxed_memory_preserve = memory;
21347 memory = try_unbox_VkDeviceMemory(memory);
21348 // WARNING PTR CHECK
21349 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
21350 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
21351 *readStreamPtrPtr += 8;
21352 if (pAllocator) {
21353 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
21354 reservedunmarshal_VkAllocationCallbacks(
21355 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21356 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
21357 }
21358 if (pAllocator) {
21359 transform_tohost_VkAllocationCallbacks(m_state,
21360 (VkAllocationCallbacks*)(pAllocator));
21361 }
21362 if (m_logCalls) {
21363 fprintf(stderr,
21364 "stream %p: call vkFreeMemorySyncGOOGLE 0x%llx 0x%llx 0x%llx \n",
21365 ioStream, (unsigned long long)device, (unsigned long long)memory,
21366 (unsigned long long)pAllocator);
21367 }
21368 VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
21369 vkFreeMemorySyncGOOGLE_VkResult_return =
21370 m_state->on_vkFreeMemorySyncGOOGLE(&m_pool, device, memory, pAllocator);
21371 if ((vkFreeMemorySyncGOOGLE_VkResult_return) == VK_ERROR_DEVICE_LOST)
21372 m_state->on_DeviceLost();
21373 m_state->on_CheckOutOfMemory(vkFreeMemorySyncGOOGLE_VkResult_return, opcode,
21374 context);
21375 vkStream->unsetHandleMapping();
21376 vkStream->write(&vkFreeMemorySyncGOOGLE_VkResult_return, sizeof(VkResult));
21377 vkStream->commitWrite();
21378 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21379 (uintptr_t)snapshotTraceBegin);
21380 size_t snapshotTraceBytes = vkReadStream->endTrace();
21381 if (m_state->snapshotsEnabled()) {
21382 m_state->snapshot()->vkFreeMemorySyncGOOGLE(
21383 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
21384 vkFreeMemorySyncGOOGLE_VkResult_return, device, boxed_memory_preserve,
21385 pAllocator);
21386 }
21387 delete_VkDeviceMemory(boxed_memory_preserve);
21388 vkReadStream->clearPool();
21389 if (m_queueSubmitWithCommandsEnabled)
21390 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21391 break;
21392 }
21393 case OP_vkQueueHostSyncGOOGLE: {
21394 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21395 "VkDecoder vkQueueHostSyncGOOGLE");
21396 VkQueue queue;
21397 uint32_t needHostSync;
21398 uint32_t sequenceNumber;
21399 // Begin global wrapped dispatchable handle unboxing for queue;
21400 uint64_t cgen_var_0;
21401 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21402 *readStreamPtrPtr += 1 * 8;
21403 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
21404 memcpy((uint32_t*)&needHostSync, *readStreamPtrPtr, sizeof(uint32_t));
21405 *readStreamPtrPtr += sizeof(uint32_t);
21406 memcpy((uint32_t*)&sequenceNumber, *readStreamPtrPtr, sizeof(uint32_t));
21407 *readStreamPtrPtr += sizeof(uint32_t);
21408 if (m_logCalls) {
21409 fprintf(stderr, "stream %p: call vkQueueHostSyncGOOGLE 0x%llx 0x%llx 0x%llx \n",
21410 ioStream, (unsigned long long)queue, (unsigned long long)needHostSync,
21411 (unsigned long long)sequenceNumber);
21412 }
21413 m_state->on_vkQueueHostSyncGOOGLE(&m_pool, queue, needHostSync, sequenceNumber);
21414 vkStream->unsetHandleMapping();
21415 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21416 (uintptr_t)snapshotTraceBegin);
21417 size_t snapshotTraceBytes = vkReadStream->endTrace();
21418 if (m_state->snapshotsEnabled()) {
21419 m_state->snapshot()->vkQueueHostSyncGOOGLE(snapshotTraceBegin,
21420 snapshotTraceBytes, &m_pool, queue,
21421 needHostSync, sequenceNumber);
21422 }
21423 vkReadStream->clearPool();
21424 if (m_queueSubmitWithCommandsEnabled)
21425 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21426 break;
21427 }
21428 case OP_vkQueueSubmitAsyncGOOGLE: {
21429 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21430 "VkDecoder vkQueueSubmitAsyncGOOGLE");
21431 VkQueue queue;
21432 uint32_t submitCount;
21433 const VkSubmitInfo* pSubmits;
21434 VkFence fence;
21435 // Begin global wrapped dispatchable handle unboxing for queue;
21436 uint64_t cgen_var_0;
21437 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21438 *readStreamPtrPtr += 1 * 8;
21439 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
21440 memcpy((uint32_t*)&submitCount, *readStreamPtrPtr, sizeof(uint32_t));
21441 *readStreamPtrPtr += sizeof(uint32_t);
21442 vkReadStream->alloc((void**)&pSubmits,
21443 ((submitCount)) * sizeof(const VkSubmitInfo));
21444 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
21445 reservedunmarshal_VkSubmitInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21446 (VkSubmitInfo*)(pSubmits + i), readStreamPtrPtr);
21447 }
21448 uint64_t cgen_var_1;
21449 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
21450 *readStreamPtrPtr += 1 * 8;
21451 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
21452 if (pSubmits) {
21453 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
21454 transform_tohost_VkSubmitInfo(m_state, (VkSubmitInfo*)(pSubmits + i));
21455 }
21456 }
21457 if (m_logCalls) {
21458 fprintf(
21459 stderr,
21460 "stream %p: call vkQueueSubmitAsyncGOOGLE 0x%llx 0x%llx 0x%llx 0x%llx \n",
21461 ioStream, (unsigned long long)queue, (unsigned long long)submitCount,
21462 (unsigned long long)pSubmits, (unsigned long long)fence);
21463 }
21464 m_state->on_vkQueueSubmitAsyncGOOGLE(&m_pool, queue, submitCount, pSubmits, fence);
21465 vkStream->unsetHandleMapping();
21466 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21467 (uintptr_t)snapshotTraceBegin);
21468 size_t snapshotTraceBytes = vkReadStream->endTrace();
21469 if (m_state->snapshotsEnabled()) {
21470 m_state->snapshot()->vkQueueSubmitAsyncGOOGLE(
21471 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, submitCount,
21472 pSubmits, fence);
21473 }
21474 vkReadStream->clearPool();
21475 if (m_queueSubmitWithCommandsEnabled)
21476 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21477 break;
21478 }
21479 case OP_vkQueueWaitIdleAsyncGOOGLE: {
21480 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21481 "VkDecoder vkQueueWaitIdleAsyncGOOGLE");
21482 VkQueue queue;
21483 // Begin global wrapped dispatchable handle unboxing for queue;
21484 uint64_t cgen_var_0;
21485 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21486 *readStreamPtrPtr += 1 * 8;
21487 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
21488 if (m_logCalls) {
21489 fprintf(stderr, "stream %p: call vkQueueWaitIdleAsyncGOOGLE 0x%llx \n",
21490 ioStream, (unsigned long long)queue);
21491 }
21492 m_state->on_vkQueueWaitIdleAsyncGOOGLE(&m_pool, queue);
21493 vkStream->unsetHandleMapping();
21494 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21495 (uintptr_t)snapshotTraceBegin);
21496 size_t snapshotTraceBytes = vkReadStream->endTrace();
21497 if (m_state->snapshotsEnabled()) {
21498 m_state->snapshot()->vkQueueWaitIdleAsyncGOOGLE(
21499 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue);
21500 }
21501 vkReadStream->clearPool();
21502 if (m_queueSubmitWithCommandsEnabled)
21503 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21504 break;
21505 }
21506 case OP_vkQueueBindSparseAsyncGOOGLE: {
21507 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21508 "VkDecoder vkQueueBindSparseAsyncGOOGLE");
21509 VkQueue queue;
21510 uint32_t bindInfoCount;
21511 const VkBindSparseInfo* pBindInfo;
21512 VkFence fence;
21513 // Begin global wrapped dispatchable handle unboxing for queue;
21514 uint64_t cgen_var_0;
21515 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21516 *readStreamPtrPtr += 1 * 8;
21517 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
21518 memcpy((uint32_t*)&bindInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
21519 *readStreamPtrPtr += sizeof(uint32_t);
21520 vkReadStream->alloc((void**)&pBindInfo,
21521 ((bindInfoCount)) * sizeof(const VkBindSparseInfo));
21522 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
21523 reservedunmarshal_VkBindSparseInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21524 (VkBindSparseInfo*)(pBindInfo + i),
21525 readStreamPtrPtr);
21526 }
21527 uint64_t cgen_var_1;
21528 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
21529 *readStreamPtrPtr += 1 * 8;
21530 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
21531 if (pBindInfo) {
21532 for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
21533 transform_tohost_VkBindSparseInfo(m_state,
21534 (VkBindSparseInfo*)(pBindInfo + i));
21535 }
21536 }
21537 if (m_logCalls) {
21538 fprintf(stderr,
21539 "stream %p: call vkQueueBindSparseAsyncGOOGLE 0x%llx 0x%llx 0x%llx "
21540 "0x%llx \n",
21541 ioStream, (unsigned long long)queue, (unsigned long long)bindInfoCount,
21542 (unsigned long long)pBindInfo, (unsigned long long)fence);
21543 }
21544 m_state->on_vkQueueBindSparseAsyncGOOGLE(&m_pool, queue, bindInfoCount, pBindInfo,
21545 fence);
21546 vkStream->unsetHandleMapping();
21547 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21548 (uintptr_t)snapshotTraceBegin);
21549 size_t snapshotTraceBytes = vkReadStream->endTrace();
21550 if (m_state->snapshotsEnabled()) {
21551 m_state->snapshot()->vkQueueBindSparseAsyncGOOGLE(
21552 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, bindInfoCount,
21553 pBindInfo, fence);
21554 }
21555 vkReadStream->clearPool();
21556 if (m_queueSubmitWithCommandsEnabled)
21557 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21558 break;
21559 }
21560 case OP_vkGetLinearImageLayoutGOOGLE: {
21561 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21562 "VkDecoder vkGetLinearImageLayoutGOOGLE");
21563 VkDevice device;
21564 VkFormat format;
21565 VkDeviceSize* pOffset;
21566 VkDeviceSize* pRowPitchAlignment;
21567 // Begin global wrapped dispatchable handle unboxing for device;
21568 uint64_t cgen_var_0;
21569 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21570 *readStreamPtrPtr += 1 * 8;
21571 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
21572 memcpy((VkFormat*)&format, *readStreamPtrPtr, sizeof(VkFormat));
21573 *readStreamPtrPtr += sizeof(VkFormat);
21574 // Begin manual dispatchable handle unboxing for pOffset;
21575 vkReadStream->unsetHandleMapping();
21576 vkReadStream->alloc((void**)&pOffset, sizeof(VkDeviceSize));
21577 memcpy((VkDeviceSize*)pOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
21578 *readStreamPtrPtr += sizeof(VkDeviceSize);
21579 // Begin manual dispatchable handle unboxing for pRowPitchAlignment;
21580 vkReadStream->unsetHandleMapping();
21581 vkReadStream->alloc((void**)&pRowPitchAlignment, sizeof(VkDeviceSize));
21582 memcpy((VkDeviceSize*)pRowPitchAlignment, *readStreamPtrPtr, sizeof(VkDeviceSize));
21583 *readStreamPtrPtr += sizeof(VkDeviceSize);
21584 if (m_logCalls) {
21585 fprintf(stderr,
21586 "stream %p: call vkGetLinearImageLayoutGOOGLE 0x%llx 0x%llx 0x%llx "
21587 "0x%llx \n",
21588 ioStream, (unsigned long long)device, (unsigned long long)format,
21589 (unsigned long long)pOffset, (unsigned long long)pRowPitchAlignment);
21590 }
21591 m_state->on_vkGetLinearImageLayoutGOOGLE(&m_pool, device, format, pOffset,
21592 pRowPitchAlignment);
21593 vkStream->unsetHandleMapping();
21594 vkStream->write((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
21595 vkStream->write((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
21596 vkStream->commitWrite();
21597 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21598 (uintptr_t)snapshotTraceBegin);
21599 size_t snapshotTraceBytes = vkReadStream->endTrace();
21600 if (m_state->snapshotsEnabled()) {
21601 m_state->snapshot()->vkGetLinearImageLayoutGOOGLE(
21602 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, format, pOffset,
21603 pRowPitchAlignment);
21604 }
21605 vkReadStream->clearPool();
21606 if (m_queueSubmitWithCommandsEnabled)
21607 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21608 break;
21609 }
21610 case OP_vkGetLinearImageLayout2GOOGLE: {
21611 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21612 "VkDecoder vkGetLinearImageLayout2GOOGLE");
21613 VkDevice device;
21614 const VkImageCreateInfo* pCreateInfo;
21615 VkDeviceSize* pOffset;
21616 VkDeviceSize* pRowPitchAlignment;
21617 // Begin global wrapped dispatchable handle unboxing for device;
21618 uint64_t cgen_var_0;
21619 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21620 *readStreamPtrPtr += 1 * 8;
21621 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
21622 vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkImageCreateInfo));
21623 reservedunmarshal_VkImageCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21624 (VkImageCreateInfo*)(pCreateInfo),
21625 readStreamPtrPtr);
21626 // Begin manual dispatchable handle unboxing for pOffset;
21627 vkReadStream->unsetHandleMapping();
21628 vkReadStream->alloc((void**)&pOffset, sizeof(VkDeviceSize));
21629 memcpy((VkDeviceSize*)pOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
21630 *readStreamPtrPtr += sizeof(VkDeviceSize);
21631 // Begin manual dispatchable handle unboxing for pRowPitchAlignment;
21632 vkReadStream->unsetHandleMapping();
21633 vkReadStream->alloc((void**)&pRowPitchAlignment, sizeof(VkDeviceSize));
21634 memcpy((VkDeviceSize*)pRowPitchAlignment, *readStreamPtrPtr, sizeof(VkDeviceSize));
21635 *readStreamPtrPtr += sizeof(VkDeviceSize);
21636 if (pCreateInfo) {
21637 m_state->transformImpl_VkImageCreateInfo_tohost(pCreateInfo, 1);
21638 transform_tohost_VkImageCreateInfo(m_state, (VkImageCreateInfo*)(pCreateInfo));
21639 }
21640 if (m_logCalls) {
21641 fprintf(stderr,
21642 "stream %p: call vkGetLinearImageLayout2GOOGLE 0x%llx 0x%llx 0x%llx "
21643 "0x%llx \n",
21644 ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
21645 (unsigned long long)pOffset, (unsigned long long)pRowPitchAlignment);
21646 }
21647 m_state->on_vkGetLinearImageLayout2GOOGLE(&m_pool, device, pCreateInfo, pOffset,
21648 pRowPitchAlignment);
21649 vkStream->unsetHandleMapping();
21650 vkStream->write((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
21651 vkStream->write((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
21652 vkStream->commitWrite();
21653 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21654 (uintptr_t)snapshotTraceBegin);
21655 size_t snapshotTraceBytes = vkReadStream->endTrace();
21656 if (m_state->snapshotsEnabled()) {
21657 m_state->snapshot()->vkGetLinearImageLayout2GOOGLE(
21658 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pCreateInfo,
21659 pOffset, pRowPitchAlignment);
21660 }
21661 vkReadStream->clearPool();
21662 if (m_queueSubmitWithCommandsEnabled)
21663 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21664 break;
21665 }
21666 case OP_vkQueueFlushCommandsGOOGLE: {
21667 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21668 "VkDecoder vkQueueFlushCommandsGOOGLE");
21669 VkQueue queue;
21670 VkCommandBuffer commandBuffer;
21671 VkDeviceSize dataSize;
21672 const void* pData;
21673 // Begin global wrapped dispatchable handle unboxing for queue;
21674 uint64_t cgen_var_0;
21675 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21676 *readStreamPtrPtr += 1 * 8;
21677 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
21678 // No unbox for commandBuffer
21679 uint64_t cgen_var_1;
21680 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
21681 *readStreamPtrPtr += 1 * 8;
21682 *(VkCommandBuffer*)&commandBuffer =
21683 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_1));
21684 memcpy((VkDeviceSize*)&dataSize, *readStreamPtrPtr, sizeof(VkDeviceSize));
21685 *readStreamPtrPtr += sizeof(VkDeviceSize);
21686 vkReadStream->alloc((void**)&pData, ((dataSize)) * sizeof(const uint8_t));
21687 memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(const uint8_t));
21688 *readStreamPtrPtr += ((dataSize)) * sizeof(const uint8_t);
21689 if (m_logCalls) {
21690 fprintf(
21691 stderr,
21692 "stream %p: call vkQueueFlushCommandsGOOGLE 0x%llx 0x%llx 0x%llx 0x%llx \n",
21693 ioStream, (unsigned long long)queue, (unsigned long long)commandBuffer,
21694 (unsigned long long)dataSize, (unsigned long long)pData);
21695 }
21696 if (m_queueSubmitWithCommandsEnabled)
21697 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21698 m_state->on_vkQueueFlushCommandsGOOGLE(&m_pool, queue, commandBuffer, dataSize,
21699 pData, context);
21700 vkStream->unsetHandleMapping();
21701 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21702 (uintptr_t)snapshotTraceBegin);
21703 size_t snapshotTraceBytes = vkReadStream->endTrace();
21704 if (m_state->snapshotsEnabled()) {
21705 m_state->snapshot()->vkQueueFlushCommandsGOOGLE(
21706 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, commandBuffer,
21707 dataSize, pData);
21708 }
21709 vkReadStream->clearPool();
21710 break;
21711 }
21712 case OP_vkQueueCommitDescriptorSetUpdatesGOOGLE: {
21713 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21714 "VkDecoder vkQueueCommitDescriptorSetUpdatesGOOGLE");
21715 VkQueue queue;
21716 uint32_t descriptorPoolCount;
21717 const VkDescriptorPool* pDescriptorPools;
21718 uint32_t descriptorSetCount;
21719 const VkDescriptorSetLayout* pSetLayouts;
21720 const uint64_t* pDescriptorSetPoolIds;
21721 const uint32_t* pDescriptorSetWhichPool;
21722 const uint32_t* pDescriptorSetPendingAllocation;
21723 const uint32_t* pDescriptorWriteStartingIndices;
21724 uint32_t pendingDescriptorWriteCount;
21725 const VkWriteDescriptorSet* pPendingDescriptorWrites;
21726 // Begin global wrapped dispatchable handle unboxing for queue;
21727 uint64_t cgen_var_0;
21728 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21729 *readStreamPtrPtr += 1 * 8;
21730 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
21731 memcpy((uint32_t*)&descriptorPoolCount, *readStreamPtrPtr, sizeof(uint32_t));
21732 *readStreamPtrPtr += sizeof(uint32_t);
21733 vkReadStream->alloc((void**)&pDescriptorPools,
21734 ((descriptorPoolCount)) * sizeof(const VkDescriptorPool));
21735 if (((descriptorPoolCount))) {
21736 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
21737 *readStreamPtrPtr += 8 * ((descriptorPoolCount));
21738 for (uint32_t k = 0; k < ((descriptorPoolCount)); ++k) {
21739 uint64_t tmpval;
21740 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
21741 *(((VkDescriptorPool*)pDescriptorPools) + k) =
21742 tmpval
21743 ? (VkDescriptorPool)unbox_VkDescriptorPool((VkDescriptorPool)tmpval)
21744 : VK_NULL_HANDLE;
21745 }
21746 }
21747 memcpy((uint32_t*)&descriptorSetCount, *readStreamPtrPtr, sizeof(uint32_t));
21748 *readStreamPtrPtr += sizeof(uint32_t);
21749 vkReadStream->alloc((void**)&pSetLayouts,
21750 ((descriptorSetCount)) * sizeof(const VkDescriptorSetLayout));
21751 if (((descriptorSetCount))) {
21752 uint8_t* cgen_var_2_ptr = (uint8_t*)(*readStreamPtrPtr);
21753 *readStreamPtrPtr += 8 * ((descriptorSetCount));
21754 for (uint32_t k = 0; k < ((descriptorSetCount)); ++k) {
21755 uint64_t tmpval;
21756 memcpy(&tmpval, cgen_var_2_ptr + k * 8, sizeof(uint64_t));
21757 *(((VkDescriptorSetLayout*)pSetLayouts) + k) =
21758 tmpval ? (VkDescriptorSetLayout)unbox_VkDescriptorSetLayout(
21759 (VkDescriptorSetLayout)tmpval)
21760 : VK_NULL_HANDLE;
21761 }
21762 }
21763 vkReadStream->alloc((void**)&pDescriptorSetPoolIds,
21764 ((descriptorSetCount)) * sizeof(const uint64_t));
21765 memcpy((uint64_t*)pDescriptorSetPoolIds, *readStreamPtrPtr,
21766 ((descriptorSetCount)) * sizeof(const uint64_t));
21767 *readStreamPtrPtr += ((descriptorSetCount)) * sizeof(const uint64_t);
21768 vkReadStream->alloc((void**)&pDescriptorSetWhichPool,
21769 ((descriptorSetCount)) * sizeof(const uint32_t));
21770 memcpy((uint32_t*)pDescriptorSetWhichPool, *readStreamPtrPtr,
21771 ((descriptorSetCount)) * sizeof(const uint32_t));
21772 *readStreamPtrPtr += ((descriptorSetCount)) * sizeof(const uint32_t);
21773 vkReadStream->alloc((void**)&pDescriptorSetPendingAllocation,
21774 ((descriptorSetCount)) * sizeof(const uint32_t));
21775 memcpy((uint32_t*)pDescriptorSetPendingAllocation, *readStreamPtrPtr,
21776 ((descriptorSetCount)) * sizeof(const uint32_t));
21777 *readStreamPtrPtr += ((descriptorSetCount)) * sizeof(const uint32_t);
21778 vkReadStream->alloc((void**)&pDescriptorWriteStartingIndices,
21779 ((descriptorSetCount)) * sizeof(const uint32_t));
21780 memcpy((uint32_t*)pDescriptorWriteStartingIndices, *readStreamPtrPtr,
21781 ((descriptorSetCount)) * sizeof(const uint32_t));
21782 *readStreamPtrPtr += ((descriptorSetCount)) * sizeof(const uint32_t);
21783 memcpy((uint32_t*)&pendingDescriptorWriteCount, *readStreamPtrPtr,
21784 sizeof(uint32_t));
21785 *readStreamPtrPtr += sizeof(uint32_t);
21786 vkReadStream->alloc(
21787 (void**)&pPendingDescriptorWrites,
21788 ((pendingDescriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
21789 for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i) {
21790 reservedunmarshal_VkWriteDescriptorSet(
21791 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
21792 (VkWriteDescriptorSet*)(pPendingDescriptorWrites + i), readStreamPtrPtr);
21793 }
21794 if (pPendingDescriptorWrites) {
21795 for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i) {
21796 transform_tohost_VkWriteDescriptorSet(
21797 m_state, (VkWriteDescriptorSet*)(pPendingDescriptorWrites + i));
21798 }
21799 }
21800 if (m_logCalls) {
21801 fprintf(stderr,
21802 "stream %p: call vkQueueCommitDescriptorSetUpdatesGOOGLE 0x%llx 0x%llx "
21803 "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
21804 ioStream, (unsigned long long)queue,
21805 (unsigned long long)descriptorPoolCount,
21806 (unsigned long long)pDescriptorPools,
21807 (unsigned long long)descriptorSetCount, (unsigned long long)pSetLayouts,
21808 (unsigned long long)pDescriptorSetPoolIds,
21809 (unsigned long long)pDescriptorSetWhichPool,
21810 (unsigned long long)pDescriptorSetPendingAllocation,
21811 (unsigned long long)pDescriptorWriteStartingIndices,
21812 (unsigned long long)pendingDescriptorWriteCount,
21813 (unsigned long long)pPendingDescriptorWrites);
21814 }
21815 m_state->on_vkQueueCommitDescriptorSetUpdatesGOOGLE(
21816 &m_pool, queue, descriptorPoolCount, pDescriptorPools, descriptorSetCount,
21817 pSetLayouts, pDescriptorSetPoolIds, pDescriptorSetWhichPool,
21818 pDescriptorSetPendingAllocation, pDescriptorWriteStartingIndices,
21819 pendingDescriptorWriteCount, pPendingDescriptorWrites);
21820 vkStream->unsetHandleMapping();
21821 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21822 (uintptr_t)snapshotTraceBegin);
21823 size_t snapshotTraceBytes = vkReadStream->endTrace();
21824 if (m_state->snapshotsEnabled()) {
21825 m_state->snapshot()->vkQueueCommitDescriptorSetUpdatesGOOGLE(
21826 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, descriptorPoolCount,
21827 pDescriptorPools, descriptorSetCount, pSetLayouts, pDescriptorSetPoolIds,
21828 pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
21829 pDescriptorWriteStartingIndices, pendingDescriptorWriteCount,
21830 pPendingDescriptorWrites);
21831 }
21832 vkReadStream->clearPool();
21833 if (m_queueSubmitWithCommandsEnabled)
21834 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21835 break;
21836 }
21837 case OP_vkCollectDescriptorPoolIdsGOOGLE: {
21838 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21839 "VkDecoder vkCollectDescriptorPoolIdsGOOGLE");
21840 VkDevice device;
21841 VkDescriptorPool descriptorPool;
21842 uint32_t* pPoolIdCount;
21843 uint64_t* pPoolIds;
21844 // Begin global wrapped dispatchable handle unboxing for device;
21845 uint64_t cgen_var_0;
21846 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21847 *readStreamPtrPtr += 1 * 8;
21848 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
21849 uint64_t cgen_var_1;
21850 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
21851 *readStreamPtrPtr += 1 * 8;
21852 *(VkDescriptorPool*)&descriptorPool =
21853 (VkDescriptorPool)unbox_VkDescriptorPool((VkDescriptorPool)(*&cgen_var_1));
21854 // Begin manual dispatchable handle unboxing for pPoolIdCount;
21855 vkReadStream->unsetHandleMapping();
21856 vkReadStream->alloc((void**)&pPoolIdCount, sizeof(uint32_t));
21857 memcpy((uint32_t*)pPoolIdCount, *readStreamPtrPtr, sizeof(uint32_t));
21858 *readStreamPtrPtr += sizeof(uint32_t);
21859 // Begin manual dispatchable handle unboxing for pPoolIds;
21860 vkReadStream->unsetHandleMapping();
21861 // WARNING PTR CHECK
21862 memcpy((uint64_t**)&pPoolIds, (*readStreamPtrPtr), 8);
21863 android::base::Stream::fromBe64((uint8_t*)&pPoolIds);
21864 *readStreamPtrPtr += 8;
21865 if (pPoolIds) {
21866 vkReadStream->alloc((void**)&pPoolIds, (*(pPoolIdCount)) * sizeof(uint64_t));
21867 memcpy((uint64_t*)pPoolIds, *readStreamPtrPtr,
21868 (*(pPoolIdCount)) * sizeof(uint64_t));
21869 *readStreamPtrPtr += (*(pPoolIdCount)) * sizeof(uint64_t);
21870 }
21871 if (m_logCalls) {
21872 fprintf(stderr,
21873 "stream %p: call vkCollectDescriptorPoolIdsGOOGLE 0x%llx 0x%llx 0x%llx "
21874 "0x%llx \n",
21875 ioStream, (unsigned long long)device,
21876 (unsigned long long)descriptorPool, (unsigned long long)pPoolIdCount,
21877 (unsigned long long)pPoolIds);
21878 }
21879 m_state->on_vkCollectDescriptorPoolIdsGOOGLE(&m_pool, device, descriptorPool,
21880 pPoolIdCount, pPoolIds);
21881 vkStream->unsetHandleMapping();
21882 vkStream->write((uint32_t*)pPoolIdCount, sizeof(uint32_t));
21883 // WARNING PTR CHECK
21884 uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pPoolIds;
21885 vkStream->putBe64(cgen_var_3);
21886 if (pPoolIds) {
21887 vkStream->write((uint64_t*)pPoolIds, (*(pPoolIdCount)) * sizeof(uint64_t));
21888 }
21889 vkStream->commitWrite();
21890 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21891 (uintptr_t)snapshotTraceBegin);
21892 size_t snapshotTraceBytes = vkReadStream->endTrace();
21893 if (m_state->snapshotsEnabled()) {
21894 m_state->snapshot()->vkCollectDescriptorPoolIdsGOOGLE(
21895 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, descriptorPool,
21896 pPoolIdCount, pPoolIds);
21897 }
21898 vkReadStream->clearPool();
21899 if (m_queueSubmitWithCommandsEnabled)
21900 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21901 break;
21902 }
21903 case OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE: {
21904 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21905 "VkDecoder vkQueueSignalReleaseImageANDROIDAsyncGOOGLE");
21906 VkQueue queue;
21907 uint32_t waitSemaphoreCount;
21908 const VkSemaphore* pWaitSemaphores;
21909 VkImage image;
21910 // Begin global wrapped dispatchable handle unboxing for queue;
21911 uint64_t cgen_var_0;
21912 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21913 *readStreamPtrPtr += 1 * 8;
21914 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
21915 memcpy((uint32_t*)&waitSemaphoreCount, *readStreamPtrPtr, sizeof(uint32_t));
21916 *readStreamPtrPtr += sizeof(uint32_t);
21917 // WARNING PTR CHECK
21918 memcpy((VkSemaphore**)&pWaitSemaphores, (*readStreamPtrPtr), 8);
21919 android::base::Stream::fromBe64((uint8_t*)&pWaitSemaphores);
21920 *readStreamPtrPtr += 8;
21921 if (pWaitSemaphores) {
21922 vkReadStream->alloc((void**)&pWaitSemaphores,
21923 ((waitSemaphoreCount)) * sizeof(const VkSemaphore));
21924 if (((waitSemaphoreCount))) {
21925 uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*readStreamPtrPtr);
21926 *readStreamPtrPtr += 8 * ((waitSemaphoreCount));
21927 for (uint32_t k = 0; k < ((waitSemaphoreCount)); ++k) {
21928 uint64_t tmpval;
21929 memcpy(&tmpval, cgen_var_1_0_ptr + k * 8, sizeof(uint64_t));
21930 *(((VkSemaphore*)pWaitSemaphores) + k) =
21931 tmpval ? (VkSemaphore)unbox_VkSemaphore((VkSemaphore)tmpval)
21932 : VK_NULL_HANDLE;
21933 }
21934 }
21935 }
21936 uint64_t cgen_var_2;
21937 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
21938 *readStreamPtrPtr += 1 * 8;
21939 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_2));
21940 if (m_logCalls) {
21941 fprintf(stderr,
21942 "stream %p: call vkQueueSignalReleaseImageANDROIDAsyncGOOGLE 0x%llx "
21943 "0x%llx 0x%llx 0x%llx \n",
21944 ioStream, (unsigned long long)queue,
21945 (unsigned long long)waitSemaphoreCount,
21946 (unsigned long long)pWaitSemaphores, (unsigned long long)image);
21947 }
21948 m_state->on_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
21949 &m_pool, queue, waitSemaphoreCount, pWaitSemaphores, image);
21950 vkStream->unsetHandleMapping();
21951 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
21952 (uintptr_t)snapshotTraceBegin);
21953 size_t snapshotTraceBytes = vkReadStream->endTrace();
21954 if (m_state->snapshotsEnabled()) {
21955 m_state->snapshot()->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
21956 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, waitSemaphoreCount,
21957 pWaitSemaphores, image);
21958 }
21959 vkReadStream->clearPool();
21960 if (m_queueSubmitWithCommandsEnabled)
21961 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
21962 break;
21963 }
21964 case OP_vkQueueFlushCommandsFromAuxMemoryGOOGLE: {
21965 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
21966 "VkDecoder vkQueueFlushCommandsFromAuxMemoryGOOGLE");
21967 VkQueue queue;
21968 VkCommandBuffer commandBuffer;
21969 VkDeviceMemory deviceMemory;
21970 VkDeviceSize dataOffset;
21971 VkDeviceSize dataSize;
21972 // Begin global wrapped dispatchable handle unboxing for queue;
21973 uint64_t cgen_var_0;
21974 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
21975 *readStreamPtrPtr += 1 * 8;
21976 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
21977 // No unbox for commandBuffer
21978 uint64_t cgen_var_1;
21979 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
21980 *readStreamPtrPtr += 1 * 8;
21981 *(VkCommandBuffer*)&commandBuffer =
21982 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_1));
21983 uint64_t cgen_var_2;
21984 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
21985 *readStreamPtrPtr += 1 * 8;
21986 *(VkDeviceMemory*)&deviceMemory =
21987 (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_2));
21988 memcpy((VkDeviceSize*)&dataOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
21989 *readStreamPtrPtr += sizeof(VkDeviceSize);
21990 memcpy((VkDeviceSize*)&dataSize, *readStreamPtrPtr, sizeof(VkDeviceSize));
21991 *readStreamPtrPtr += sizeof(VkDeviceSize);
21992 if (m_logCalls) {
21993 fprintf(stderr,
21994 "stream %p: call vkQueueFlushCommandsFromAuxMemoryGOOGLE 0x%llx 0x%llx "
21995 "0x%llx 0x%llx 0x%llx \n",
21996 ioStream, (unsigned long long)queue, (unsigned long long)commandBuffer,
21997 (unsigned long long)deviceMemory, (unsigned long long)dataOffset,
21998 (unsigned long long)dataSize);
21999 }
22000 m_state->on_vkQueueFlushCommandsFromAuxMemoryGOOGLE(
22001 &m_pool, queue, commandBuffer, deviceMemory, dataOffset, dataSize, context);
22002 vkStream->unsetHandleMapping();
22003 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22004 (uintptr_t)snapshotTraceBegin);
22005 size_t snapshotTraceBytes = vkReadStream->endTrace();
22006 if (m_state->snapshotsEnabled()) {
22007 m_state->snapshot()->vkQueueFlushCommandsFromAuxMemoryGOOGLE(
22008 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, commandBuffer,
22009 deviceMemory, dataOffset, dataSize);
22010 }
22011 vkReadStream->clearPool();
22012 if (m_queueSubmitWithCommandsEnabled)
22013 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22014 break;
22015 }
22016 case OP_vkGetBlobGOOGLE: {
22017 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
22018 "VkDecoder vkGetBlobGOOGLE");
22019 VkDevice device;
22020 VkDeviceMemory memory;
22021 // Begin global wrapped dispatchable handle unboxing for device;
22022 uint64_t cgen_var_0;
22023 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22024 *readStreamPtrPtr += 1 * 8;
22025 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
22026 uint64_t cgen_var_1;
22027 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
22028 *readStreamPtrPtr += 1 * 8;
22029 *(VkDeviceMemory*)&memory =
22030 (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_1));
22031 if (m_logCalls) {
22032 fprintf(stderr, "stream %p: call vkGetBlobGOOGLE 0x%llx 0x%llx \n", ioStream,
22033 (unsigned long long)device, (unsigned long long)memory);
22034 }
22035 VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
22036 vkGetBlobGOOGLE_VkResult_return =
22037 m_state->on_vkGetBlobGOOGLE(&m_pool, device, memory);
22038 if ((vkGetBlobGOOGLE_VkResult_return) == VK_ERROR_DEVICE_LOST)
22039 m_state->on_DeviceLost();
22040 m_state->on_CheckOutOfMemory(vkGetBlobGOOGLE_VkResult_return, opcode, context);
22041 vkStream->unsetHandleMapping();
22042 vkStream->write(&vkGetBlobGOOGLE_VkResult_return, sizeof(VkResult));
22043 vkStream->commitWrite();
22044 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22045 (uintptr_t)snapshotTraceBegin);
22046 size_t snapshotTraceBytes = vkReadStream->endTrace();
22047 if (m_state->snapshotsEnabled()) {
22048 m_state->snapshot()->vkGetBlobGOOGLE(snapshotTraceBegin, snapshotTraceBytes,
22049 &m_pool, vkGetBlobGOOGLE_VkResult_return,
22050 device, memory);
22051 }
22052 vkReadStream->clearPool();
22053 if (m_queueSubmitWithCommandsEnabled)
22054 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22055 break;
22056 }
22057 case OP_vkUpdateDescriptorSetWithTemplateSized2GOOGLE: {
22058 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
22059 "VkDecoder vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
22060 VkDevice device;
22061 VkDescriptorSet descriptorSet;
22062 VkDescriptorUpdateTemplate descriptorUpdateTemplate;
22063 uint32_t imageInfoCount;
22064 uint32_t bufferInfoCount;
22065 uint32_t bufferViewCount;
22066 uint32_t inlineUniformBlockCount;
22067 const uint32_t* pImageInfoEntryIndices;
22068 const uint32_t* pBufferInfoEntryIndices;
22069 const uint32_t* pBufferViewEntryIndices;
22070 const VkDescriptorImageInfo* pImageInfos;
22071 const VkDescriptorBufferInfo* pBufferInfos;
22072 const VkBufferView* pBufferViews;
22073 const uint8_t* pInlineUniformBlockData;
22074 // Begin global wrapped dispatchable handle unboxing for device;
22075 uint64_t cgen_var_0;
22076 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22077 *readStreamPtrPtr += 1 * 8;
22078 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
22079 uint64_t cgen_var_1;
22080 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
22081 *readStreamPtrPtr += 1 * 8;
22082 *(VkDescriptorSet*)&descriptorSet =
22083 (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)(*&cgen_var_1));
22084 uint64_t cgen_var_2;
22085 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
22086 *readStreamPtrPtr += 1 * 8;
22087 *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate =
22088 (VkDescriptorUpdateTemplate)unbox_VkDescriptorUpdateTemplate(
22089 (VkDescriptorUpdateTemplate)(*&cgen_var_2));
22090 memcpy((uint32_t*)&imageInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
22091 *readStreamPtrPtr += sizeof(uint32_t);
22092 memcpy((uint32_t*)&bufferInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
22093 *readStreamPtrPtr += sizeof(uint32_t);
22094 memcpy((uint32_t*)&bufferViewCount, *readStreamPtrPtr, sizeof(uint32_t));
22095 *readStreamPtrPtr += sizeof(uint32_t);
22096 memcpy((uint32_t*)&inlineUniformBlockCount, *readStreamPtrPtr, sizeof(uint32_t));
22097 *readStreamPtrPtr += sizeof(uint32_t);
22098 // WARNING PTR CHECK
22099 memcpy((uint32_t**)&pImageInfoEntryIndices, (*readStreamPtrPtr), 8);
22100 android::base::Stream::fromBe64((uint8_t*)&pImageInfoEntryIndices);
22101 *readStreamPtrPtr += 8;
22102 if (pImageInfoEntryIndices) {
22103 vkReadStream->alloc((void**)&pImageInfoEntryIndices,
22104 ((imageInfoCount)) * sizeof(const uint32_t));
22105 memcpy((uint32_t*)pImageInfoEntryIndices, *readStreamPtrPtr,
22106 ((imageInfoCount)) * sizeof(const uint32_t));
22107 *readStreamPtrPtr += ((imageInfoCount)) * sizeof(const uint32_t);
22108 }
22109 // WARNING PTR CHECK
22110 memcpy((uint32_t**)&pBufferInfoEntryIndices, (*readStreamPtrPtr), 8);
22111 android::base::Stream::fromBe64((uint8_t*)&pBufferInfoEntryIndices);
22112 *readStreamPtrPtr += 8;
22113 if (pBufferInfoEntryIndices) {
22114 vkReadStream->alloc((void**)&pBufferInfoEntryIndices,
22115 ((bufferInfoCount)) * sizeof(const uint32_t));
22116 memcpy((uint32_t*)pBufferInfoEntryIndices, *readStreamPtrPtr,
22117 ((bufferInfoCount)) * sizeof(const uint32_t));
22118 *readStreamPtrPtr += ((bufferInfoCount)) * sizeof(const uint32_t);
22119 }
22120 // WARNING PTR CHECK
22121 memcpy((uint32_t**)&pBufferViewEntryIndices, (*readStreamPtrPtr), 8);
22122 android::base::Stream::fromBe64((uint8_t*)&pBufferViewEntryIndices);
22123 *readStreamPtrPtr += 8;
22124 if (pBufferViewEntryIndices) {
22125 vkReadStream->alloc((void**)&pBufferViewEntryIndices,
22126 ((bufferViewCount)) * sizeof(const uint32_t));
22127 memcpy((uint32_t*)pBufferViewEntryIndices, *readStreamPtrPtr,
22128 ((bufferViewCount)) * sizeof(const uint32_t));
22129 *readStreamPtrPtr += ((bufferViewCount)) * sizeof(const uint32_t);
22130 }
22131 // WARNING PTR CHECK
22132 memcpy((VkDescriptorImageInfo**)&pImageInfos, (*readStreamPtrPtr), 8);
22133 android::base::Stream::fromBe64((uint8_t*)&pImageInfos);
22134 *readStreamPtrPtr += 8;
22135 if (pImageInfos) {
22136 vkReadStream->alloc((void**)&pImageInfos,
22137 ((imageInfoCount)) * sizeof(const VkDescriptorImageInfo));
22138 for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
22139 reservedunmarshal_VkDescriptorImageInfo(
22140 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22141 (VkDescriptorImageInfo*)(pImageInfos + i), readStreamPtrPtr);
22142 }
22143 }
22144 // WARNING PTR CHECK
22145 memcpy((VkDescriptorBufferInfo**)&pBufferInfos, (*readStreamPtrPtr), 8);
22146 android::base::Stream::fromBe64((uint8_t*)&pBufferInfos);
22147 *readStreamPtrPtr += 8;
22148 if (pBufferInfos) {
22149 vkReadStream->alloc((void**)&pBufferInfos,
22150 ((bufferInfoCount)) * sizeof(const VkDescriptorBufferInfo));
22151 for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
22152 reservedunmarshal_VkDescriptorBufferInfo(
22153 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22154 (VkDescriptorBufferInfo*)(pBufferInfos + i), readStreamPtrPtr);
22155 }
22156 }
22157 // WARNING PTR CHECK
22158 memcpy((VkBufferView**)&pBufferViews, (*readStreamPtrPtr), 8);
22159 android::base::Stream::fromBe64((uint8_t*)&pBufferViews);
22160 *readStreamPtrPtr += 8;
22161 if (pBufferViews) {
22162 vkReadStream->alloc((void**)&pBufferViews,
22163 ((bufferViewCount)) * sizeof(const VkBufferView));
22164 if (((bufferViewCount))) {
22165 uint8_t* cgen_var_8_0_ptr = (uint8_t*)(*readStreamPtrPtr);
22166 *readStreamPtrPtr += 8 * ((bufferViewCount));
22167 for (uint32_t k = 0; k < ((bufferViewCount)); ++k) {
22168 uint64_t tmpval;
22169 memcpy(&tmpval, cgen_var_8_0_ptr + k * 8, sizeof(uint64_t));
22170 *(((VkBufferView*)pBufferViews) + k) =
22171 tmpval ? (VkBufferView)unbox_VkBufferView((VkBufferView)tmpval)
22172 : VK_NULL_HANDLE;
22173 }
22174 }
22175 }
22176 // WARNING PTR CHECK
22177 memcpy((uint8_t**)&pInlineUniformBlockData, (*readStreamPtrPtr), 8);
22178 android::base::Stream::fromBe64((uint8_t*)&pInlineUniformBlockData);
22179 *readStreamPtrPtr += 8;
22180 if (pInlineUniformBlockData) {
22181 vkReadStream->alloc((void**)&pInlineUniformBlockData,
22182 ((inlineUniformBlockCount)) * sizeof(const uint8_t));
22183 memcpy((uint8_t*)pInlineUniformBlockData, *readStreamPtrPtr,
22184 ((inlineUniformBlockCount)) * sizeof(const uint8_t));
22185 *readStreamPtrPtr += ((inlineUniformBlockCount)) * sizeof(const uint8_t);
22186 }
22187 if (pImageInfos) {
22188 for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
22189 transform_tohost_VkDescriptorImageInfo(
22190 m_state, (VkDescriptorImageInfo*)(pImageInfos + i));
22191 }
22192 }
22193 if (pBufferInfos) {
22194 for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
22195 transform_tohost_VkDescriptorBufferInfo(
22196 m_state, (VkDescriptorBufferInfo*)(pBufferInfos + i));
22197 }
22198 }
22199 if (m_logCalls) {
22200 fprintf(stderr,
22201 "stream %p: call vkUpdateDescriptorSetWithTemplateSized2GOOGLE 0x%llx "
22202 "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
22203 "0x%llx 0x%llx 0x%llx \n",
22204 ioStream, (unsigned long long)device, (unsigned long long)descriptorSet,
22205 (unsigned long long)descriptorUpdateTemplate,
22206 (unsigned long long)imageInfoCount, (unsigned long long)bufferInfoCount,
22207 (unsigned long long)bufferViewCount,
22208 (unsigned long long)inlineUniformBlockCount,
22209 (unsigned long long)pImageInfoEntryIndices,
22210 (unsigned long long)pBufferInfoEntryIndices,
22211 (unsigned long long)pBufferViewEntryIndices,
22212 (unsigned long long)pImageInfos, (unsigned long long)pBufferInfos,
22213 (unsigned long long)pBufferViews,
22214 (unsigned long long)pInlineUniformBlockData);
22215 }
22216 m_state->on_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
22217 &m_pool, device, descriptorSet, descriptorUpdateTemplate, imageInfoCount,
22218 bufferInfoCount, bufferViewCount, inlineUniformBlockCount,
22219 pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
22220 pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData);
22221 vkStream->unsetHandleMapping();
22222 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22223 (uintptr_t)snapshotTraceBegin);
22224 size_t snapshotTraceBytes = vkReadStream->endTrace();
22225 if (m_state->snapshotsEnabled()) {
22226 m_state->snapshot()->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
22227 snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, descriptorSet,
22228 descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount,
22229 inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
22230 pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews,
22231 pInlineUniformBlockData);
22232 }
22233 vkReadStream->clearPool();
22234 if (m_queueSubmitWithCommandsEnabled)
22235 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22236 break;
22237 }
22238 case OP_vkQueueSubmitAsync2GOOGLE: {
22239 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
22240 "VkDecoder vkQueueSubmitAsync2GOOGLE");
22241 VkQueue queue;
22242 uint32_t submitCount;
22243 const VkSubmitInfo2* pSubmits;
22244 VkFence fence;
22245 // Begin global wrapped dispatchable handle unboxing for queue;
22246 uint64_t cgen_var_0;
22247 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22248 *readStreamPtrPtr += 1 * 8;
22249 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
22250 memcpy((uint32_t*)&submitCount, *readStreamPtrPtr, sizeof(uint32_t));
22251 *readStreamPtrPtr += sizeof(uint32_t);
22252 vkReadStream->alloc((void**)&pSubmits,
22253 ((submitCount)) * sizeof(const VkSubmitInfo2));
22254 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
22255 reservedunmarshal_VkSubmitInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22256 (VkSubmitInfo2*)(pSubmits + i),
22257 readStreamPtrPtr);
22258 }
22259 uint64_t cgen_var_1;
22260 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
22261 *readStreamPtrPtr += 1 * 8;
22262 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
22263 if (pSubmits) {
22264 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
22265 transform_tohost_VkSubmitInfo2(m_state, (VkSubmitInfo2*)(pSubmits + i));
22266 }
22267 }
22268 if (m_logCalls) {
22269 fprintf(
22270 stderr,
22271 "stream %p: call vkQueueSubmitAsync2GOOGLE 0x%llx 0x%llx 0x%llx 0x%llx \n",
22272 ioStream, (unsigned long long)queue, (unsigned long long)submitCount,
22273 (unsigned long long)pSubmits, (unsigned long long)fence);
22274 }
22275 m_state->on_vkQueueSubmitAsync2GOOGLE(&m_pool, queue, submitCount, pSubmits, fence);
22276 vkStream->unsetHandleMapping();
22277 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22278 (uintptr_t)snapshotTraceBegin);
22279 size_t snapshotTraceBytes = vkReadStream->endTrace();
22280 if (m_state->snapshotsEnabled()) {
22281 m_state->snapshot()->vkQueueSubmitAsync2GOOGLE(
22282 snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, submitCount,
22283 pSubmits, fence);
22284 }
22285 vkReadStream->clearPool();
22286 if (m_queueSubmitWithCommandsEnabled)
22287 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22288 break;
22289 }
22290 case OP_vkGetSemaphoreGOOGLE: {
22291 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
22292 "VkDecoder vkGetSemaphoreGOOGLE");
22293 VkDevice device;
22294 VkSemaphore semaphore;
22295 uint64_t syncId;
22296 // Begin global wrapped dispatchable handle unboxing for device;
22297 uint64_t cgen_var_0;
22298 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22299 *readStreamPtrPtr += 1 * 8;
22300 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
22301 uint64_t cgen_var_1;
22302 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
22303 *readStreamPtrPtr += 1 * 8;
22304 *(VkSemaphore*)&semaphore =
22305 (VkSemaphore)unbox_VkSemaphore((VkSemaphore)(*&cgen_var_1));
22306 memcpy((uint64_t*)&syncId, *readStreamPtrPtr, sizeof(uint64_t));
22307 *readStreamPtrPtr += sizeof(uint64_t);
22308 if (m_logCalls) {
22309 fprintf(stderr, "stream %p: call vkGetSemaphoreGOOGLE 0x%llx 0x%llx 0x%llx \n",
22310 ioStream, (unsigned long long)device, (unsigned long long)semaphore,
22311 (unsigned long long)syncId);
22312 }
22313 VkResult vkGetSemaphoreGOOGLE_VkResult_return = (VkResult)0;
22314 vkGetSemaphoreGOOGLE_VkResult_return =
22315 m_state->on_vkGetSemaphoreGOOGLE(&m_pool, device, semaphore, syncId);
22316 if ((vkGetSemaphoreGOOGLE_VkResult_return) == VK_ERROR_DEVICE_LOST)
22317 m_state->on_DeviceLost();
22318 m_state->on_CheckOutOfMemory(vkGetSemaphoreGOOGLE_VkResult_return, opcode, context);
22319 vkStream->unsetHandleMapping();
22320 vkStream->write(&vkGetSemaphoreGOOGLE_VkResult_return, sizeof(VkResult));
22321 vkStream->commitWrite();
22322 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22323 (uintptr_t)snapshotTraceBegin);
22324 size_t snapshotTraceBytes = vkReadStream->endTrace();
22325 if (m_state->snapshotsEnabled()) {
22326 m_state->snapshot()->vkGetSemaphoreGOOGLE(
22327 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
22328 vkGetSemaphoreGOOGLE_VkResult_return, device, semaphore, syncId);
22329 }
22330 vkReadStream->clearPool();
22331 if (m_queueSubmitWithCommandsEnabled)
22332 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22333 break;
22334 }
22335 #endif
22336 #ifdef VK_KHR_ray_tracing_pipeline
22337 case OP_vkCmdTraceRaysKHR: {
22338 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
22339 "VkDecoder vkCmdTraceRaysKHR");
22340 VkCommandBuffer commandBuffer;
22341 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
22342 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
22343 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
22344 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
22345 uint32_t width;
22346 uint32_t height;
22347 uint32_t depth;
22348 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
22349 uint64_t cgen_var_0;
22350 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22351 *readStreamPtrPtr += 1 * 8;
22352 *(VkCommandBuffer*)&commandBuffer =
22353 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
22354 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
22355 auto vk = dispatch_VkCommandBuffer(commandBuffer);
22356 // End manual dispatchable handle unboxing for commandBuffer;
22357 vkReadStream->alloc((void**)&pRaygenShaderBindingTable,
22358 sizeof(const VkStridedDeviceAddressRegionKHR));
22359 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
22360 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22361 (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
22362 readStreamPtrPtr);
22363 vkReadStream->alloc((void**)&pMissShaderBindingTable,
22364 sizeof(const VkStridedDeviceAddressRegionKHR));
22365 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
22366 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22367 (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
22368 vkReadStream->alloc((void**)&pHitShaderBindingTable,
22369 sizeof(const VkStridedDeviceAddressRegionKHR));
22370 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
22371 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22372 (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
22373 vkReadStream->alloc((void**)&pCallableShaderBindingTable,
22374 sizeof(const VkStridedDeviceAddressRegionKHR));
22375 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
22376 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22377 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
22378 readStreamPtrPtr);
22379 memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
22380 *readStreamPtrPtr += sizeof(uint32_t);
22381 memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
22382 *readStreamPtrPtr += sizeof(uint32_t);
22383 memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
22384 *readStreamPtrPtr += sizeof(uint32_t);
22385 if (pRaygenShaderBindingTable) {
22386 transform_tohost_VkStridedDeviceAddressRegionKHR(
22387 m_state, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
22388 }
22389 if (pMissShaderBindingTable) {
22390 transform_tohost_VkStridedDeviceAddressRegionKHR(
22391 m_state, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
22392 }
22393 if (pHitShaderBindingTable) {
22394 transform_tohost_VkStridedDeviceAddressRegionKHR(
22395 m_state, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
22396 }
22397 if (pCallableShaderBindingTable) {
22398 transform_tohost_VkStridedDeviceAddressRegionKHR(
22399 m_state, (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
22400 }
22401 if (m_logCalls) {
22402 fprintf(stderr,
22403 "stream %p: call vkCmdTraceRaysKHR 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
22404 "0x%llx 0x%llx 0x%llx \n",
22405 ioStream, (unsigned long long)commandBuffer,
22406 (unsigned long long)pRaygenShaderBindingTable,
22407 (unsigned long long)pMissShaderBindingTable,
22408 (unsigned long long)pHitShaderBindingTable,
22409 (unsigned long long)pCallableShaderBindingTable,
22410 (unsigned long long)width, (unsigned long long)height,
22411 (unsigned long long)depth);
22412 }
22413 vk->vkCmdTraceRaysKHR(unboxed_commandBuffer, pRaygenShaderBindingTable,
22414 pMissShaderBindingTable, pHitShaderBindingTable,
22415 pCallableShaderBindingTable, width, height, depth);
22416 vkStream->unsetHandleMapping();
22417 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22418 (uintptr_t)snapshotTraceBegin);
22419 size_t snapshotTraceBytes = vkReadStream->endTrace();
22420 if (m_state->snapshotsEnabled()) {
22421 m_state->snapshot()->vkCmdTraceRaysKHR(
22422 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
22423 pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable,
22424 pCallableShaderBindingTable, width, height, depth);
22425 }
22426 vkReadStream->clearPool();
22427 if (m_queueSubmitWithCommandsEnabled)
22428 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22429 break;
22430 }
22431 case OP_vkCreateRayTracingPipelinesKHR: {
22432 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
22433 "VkDecoder vkCreateRayTracingPipelinesKHR");
22434 VkDevice device;
22435 VkDeferredOperationKHR deferredOperation;
22436 VkPipelineCache pipelineCache;
22437 uint32_t createInfoCount;
22438 const VkRayTracingPipelineCreateInfoKHR* pCreateInfos;
22439 const VkAllocationCallbacks* pAllocator;
22440 VkPipeline* pPipelines;
22441 // Begin non wrapped dispatchable handle unboxing for device;
22442 uint64_t cgen_var_0;
22443 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22444 *readStreamPtrPtr += 1 * 8;
22445 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
22446 auto unboxed_device = unbox_VkDevice(device);
22447 auto vk = dispatch_VkDevice(device);
22448 // End manual dispatchable handle unboxing for device;
22449 memcpy((VkDeferredOperationKHR*)&deferredOperation, (*readStreamPtrPtr), 8);
22450 android::base::Stream::fromBe64((uint8_t*)&deferredOperation);
22451 *readStreamPtrPtr += 8;
22452 uint64_t cgen_var_2;
22453 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
22454 *readStreamPtrPtr += 1 * 8;
22455 *(VkPipelineCache*)&pipelineCache =
22456 (VkPipelineCache)unbox_VkPipelineCache((VkPipelineCache)(*&cgen_var_2));
22457 memcpy((uint32_t*)&createInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
22458 *readStreamPtrPtr += sizeof(uint32_t);
22459 vkReadStream->alloc(
22460 (void**)&pCreateInfos,
22461 ((createInfoCount)) * sizeof(const VkRayTracingPipelineCreateInfoKHR));
22462 for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
22463 reservedunmarshal_VkRayTracingPipelineCreateInfoKHR(
22464 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22465 (VkRayTracingPipelineCreateInfoKHR*)(pCreateInfos + i), readStreamPtrPtr);
22466 }
22467 // WARNING PTR CHECK
22468 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
22469 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
22470 *readStreamPtrPtr += 8;
22471 if (pAllocator) {
22472 vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
22473 reservedunmarshal_VkAllocationCallbacks(
22474 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22475 (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
22476 }
22477 // Begin manual dispatchable handle unboxing for pPipelines;
22478 vkReadStream->unsetHandleMapping();
22479 vkReadStream->alloc((void**)&pPipelines, ((createInfoCount)) * sizeof(VkPipeline));
22480 if (((createInfoCount))) {
22481 uint8_t* cgen_var_4_ptr = (uint8_t*)(*readStreamPtrPtr);
22482 *readStreamPtrPtr += 8 * ((createInfoCount));
22483 for (uint32_t k = 0; k < ((createInfoCount)); ++k) {
22484 uint64_t tmpval;
22485 memcpy(&tmpval, cgen_var_4_ptr + k * 8, sizeof(uint64_t));
22486 *(((VkPipeline*)pPipelines) + k) =
22487 tmpval ? (VkPipeline)(VkPipeline)((VkPipeline)tmpval) : VK_NULL_HANDLE;
22488 }
22489 }
22490 if (pCreateInfos) {
22491 for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
22492 transform_tohost_VkRayTracingPipelineCreateInfoKHR(
22493 m_state, (VkRayTracingPipelineCreateInfoKHR*)(pCreateInfos + i));
22494 }
22495 }
22496 if (pAllocator) {
22497 transform_tohost_VkAllocationCallbacks(m_state,
22498 (VkAllocationCallbacks*)(pAllocator));
22499 }
22500 if (m_logCalls) {
22501 fprintf(stderr,
22502 "stream %p: call vkCreateRayTracingPipelinesKHR 0x%llx 0x%llx 0x%llx "
22503 "0x%llx 0x%llx 0x%llx 0x%llx \n",
22504 ioStream, (unsigned long long)device,
22505 (unsigned long long)deferredOperation,
22506 (unsigned long long)pipelineCache, (unsigned long long)createInfoCount,
22507 (unsigned long long)pCreateInfos, (unsigned long long)pAllocator,
22508 (unsigned long long)pPipelines);
22509 }
22510 VkResult vkCreateRayTracingPipelinesKHR_VkResult_return = (VkResult)0;
22511 vkCreateRayTracingPipelinesKHR_VkResult_return = vk->vkCreateRayTracingPipelinesKHR(
22512 unboxed_device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos,
22513 pAllocator, pPipelines);
22514 if ((vkCreateRayTracingPipelinesKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
22515 m_state->on_DeviceLost();
22516 m_state->on_CheckOutOfMemory(vkCreateRayTracingPipelinesKHR_VkResult_return, opcode,
22517 context);
22518 vkStream->unsetHandleMapping();
22519 if (((createInfoCount))) {
22520 uint64_t* cgen_var_5;
22521 vkStream->alloc((void**)&cgen_var_5, ((createInfoCount)) * 8);
22522 vkStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_5,
22523 ((createInfoCount)));
22524 vkStream->write((uint64_t*)cgen_var_5, ((createInfoCount)) * 8);
22525 }
22526 vkStream->write(&vkCreateRayTracingPipelinesKHR_VkResult_return, sizeof(VkResult));
22527 vkStream->commitWrite();
22528 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22529 (uintptr_t)snapshotTraceBegin);
22530 size_t snapshotTraceBytes = vkReadStream->endTrace();
22531 if (m_state->snapshotsEnabled()) {
22532 m_state->snapshot()->vkCreateRayTracingPipelinesKHR(
22533 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
22534 vkCreateRayTracingPipelinesKHR_VkResult_return, device, deferredOperation,
22535 pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
22536 }
22537 vkReadStream->clearPool();
22538 if (m_queueSubmitWithCommandsEnabled)
22539 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22540 break;
22541 }
22542 case OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: {
22543 GFXSTREAM_TRACE_EVENT(
22544 GFXSTREAM_TRACE_DECODER_CATEGORY,
22545 "VkDecoder vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
22546 VkDevice device;
22547 VkPipeline pipeline;
22548 uint32_t firstGroup;
22549 uint32_t groupCount;
22550 size_t dataSize;
22551 void* pData;
22552 // Begin non wrapped dispatchable handle unboxing for device;
22553 uint64_t cgen_var_0;
22554 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22555 *readStreamPtrPtr += 1 * 8;
22556 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
22557 auto unboxed_device = unbox_VkDevice(device);
22558 auto vk = dispatch_VkDevice(device);
22559 // End manual dispatchable handle unboxing for device;
22560 uint64_t cgen_var_1;
22561 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
22562 *readStreamPtrPtr += 1 * 8;
22563 *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_1));
22564 memcpy((uint32_t*)&firstGroup, *readStreamPtrPtr, sizeof(uint32_t));
22565 *readStreamPtrPtr += sizeof(uint32_t);
22566 memcpy((uint32_t*)&groupCount, *readStreamPtrPtr, sizeof(uint32_t));
22567 *readStreamPtrPtr += sizeof(uint32_t);
22568 memcpy((size_t*)&dataSize, (*readStreamPtrPtr), 8);
22569 android::base::Stream::fromBe64((uint8_t*)&dataSize);
22570 *readStreamPtrPtr += 8;
22571 // Begin manual dispatchable handle unboxing for pData;
22572 vkReadStream->unsetHandleMapping();
22573 vkReadStream->alloc((void**)&pData, ((dataSize)) * sizeof(uint8_t));
22574 memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(uint8_t));
22575 *readStreamPtrPtr += ((dataSize)) * sizeof(uint8_t);
22576 if (m_logCalls) {
22577 fprintf(stderr,
22578 "stream %p: call vkGetRayTracingCaptureReplayShaderGroupHandlesKHR "
22579 "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
22580 ioStream, (unsigned long long)device, (unsigned long long)pipeline,
22581 (unsigned long long)firstGroup, (unsigned long long)groupCount,
22582 (unsigned long long)dataSize, (unsigned long long)pData);
22583 }
22584 VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return =
22585 (VkResult)0;
22586 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return =
22587 vk->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
22588 unboxed_device, pipeline, firstGroup, groupCount, dataSize, pData);
22589 if ((vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return) ==
22590 VK_ERROR_DEVICE_LOST)
22591 m_state->on_DeviceLost();
22592 m_state->on_CheckOutOfMemory(
22593 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return, opcode,
22594 context);
22595 vkStream->unsetHandleMapping();
22596 vkStream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
22597 vkStream->write(&vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return,
22598 sizeof(VkResult));
22599 vkStream->commitWrite();
22600 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22601 (uintptr_t)snapshotTraceBegin);
22602 size_t snapshotTraceBytes = vkReadStream->endTrace();
22603 if (m_state->snapshotsEnabled()) {
22604 m_state->snapshot()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
22605 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
22606 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return, device,
22607 pipeline, firstGroup, groupCount, dataSize, pData);
22608 }
22609 vkReadStream->clearPool();
22610 if (m_queueSubmitWithCommandsEnabled)
22611 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22612 break;
22613 }
22614 case OP_vkCmdTraceRaysIndirectKHR: {
22615 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
22616 "VkDecoder vkCmdTraceRaysIndirectKHR");
22617 VkCommandBuffer commandBuffer;
22618 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
22619 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
22620 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
22621 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
22622 VkDeviceAddress indirectDeviceAddress;
22623 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
22624 uint64_t cgen_var_0;
22625 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22626 *readStreamPtrPtr += 1 * 8;
22627 *(VkCommandBuffer*)&commandBuffer =
22628 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
22629 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
22630 auto vk = dispatch_VkCommandBuffer(commandBuffer);
22631 // End manual dispatchable handle unboxing for commandBuffer;
22632 vkReadStream->alloc((void**)&pRaygenShaderBindingTable,
22633 sizeof(const VkStridedDeviceAddressRegionKHR));
22634 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
22635 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22636 (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
22637 readStreamPtrPtr);
22638 vkReadStream->alloc((void**)&pMissShaderBindingTable,
22639 sizeof(const VkStridedDeviceAddressRegionKHR));
22640 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
22641 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22642 (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
22643 vkReadStream->alloc((void**)&pHitShaderBindingTable,
22644 sizeof(const VkStridedDeviceAddressRegionKHR));
22645 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
22646 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22647 (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
22648 vkReadStream->alloc((void**)&pCallableShaderBindingTable,
22649 sizeof(const VkStridedDeviceAddressRegionKHR));
22650 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
22651 vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
22652 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
22653 readStreamPtrPtr);
22654 memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
22655 sizeof(VkDeviceAddress));
22656 *readStreamPtrPtr += sizeof(VkDeviceAddress);
22657 if (pRaygenShaderBindingTable) {
22658 transform_tohost_VkStridedDeviceAddressRegionKHR(
22659 m_state, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
22660 }
22661 if (pMissShaderBindingTable) {
22662 transform_tohost_VkStridedDeviceAddressRegionKHR(
22663 m_state, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
22664 }
22665 if (pHitShaderBindingTable) {
22666 transform_tohost_VkStridedDeviceAddressRegionKHR(
22667 m_state, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
22668 }
22669 if (pCallableShaderBindingTable) {
22670 transform_tohost_VkStridedDeviceAddressRegionKHR(
22671 m_state, (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
22672 }
22673 if (m_logCalls) {
22674 fprintf(stderr,
22675 "stream %p: call vkCmdTraceRaysIndirectKHR 0x%llx 0x%llx 0x%llx 0x%llx "
22676 "0x%llx 0x%llx \n",
22677 ioStream, (unsigned long long)commandBuffer,
22678 (unsigned long long)pRaygenShaderBindingTable,
22679 (unsigned long long)pMissShaderBindingTable,
22680 (unsigned long long)pHitShaderBindingTable,
22681 (unsigned long long)pCallableShaderBindingTable,
22682 (unsigned long long)indirectDeviceAddress);
22683 }
22684 vk->vkCmdTraceRaysIndirectKHR(unboxed_commandBuffer, pRaygenShaderBindingTable,
22685 pMissShaderBindingTable, pHitShaderBindingTable,
22686 pCallableShaderBindingTable, indirectDeviceAddress);
22687 vkStream->unsetHandleMapping();
22688 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22689 (uintptr_t)snapshotTraceBegin);
22690 size_t snapshotTraceBytes = vkReadStream->endTrace();
22691 if (m_state->snapshotsEnabled()) {
22692 m_state->snapshot()->vkCmdTraceRaysIndirectKHR(
22693 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
22694 pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable,
22695 pCallableShaderBindingTable, indirectDeviceAddress);
22696 }
22697 vkReadStream->clearPool();
22698 if (m_queueSubmitWithCommandsEnabled)
22699 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22700 break;
22701 }
22702 case OP_vkGetRayTracingShaderGroupStackSizeKHR: {
22703 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
22704 "VkDecoder vkGetRayTracingShaderGroupStackSizeKHR");
22705 VkDevice device;
22706 VkPipeline pipeline;
22707 uint32_t group;
22708 VkShaderGroupShaderKHR groupShader;
22709 // Begin non wrapped dispatchable handle unboxing for device;
22710 uint64_t cgen_var_0;
22711 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22712 *readStreamPtrPtr += 1 * 8;
22713 *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
22714 auto unboxed_device = unbox_VkDevice(device);
22715 auto vk = dispatch_VkDevice(device);
22716 // End manual dispatchable handle unboxing for device;
22717 uint64_t cgen_var_1;
22718 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
22719 *readStreamPtrPtr += 1 * 8;
22720 *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_1));
22721 memcpy((uint32_t*)&group, *readStreamPtrPtr, sizeof(uint32_t));
22722 *readStreamPtrPtr += sizeof(uint32_t);
22723 memcpy((VkShaderGroupShaderKHR*)&groupShader, *readStreamPtrPtr,
22724 sizeof(VkShaderGroupShaderKHR));
22725 *readStreamPtrPtr += sizeof(VkShaderGroupShaderKHR);
22726 if (m_logCalls) {
22727 fprintf(stderr,
22728 "stream %p: call vkGetRayTracingShaderGroupStackSizeKHR 0x%llx 0x%llx "
22729 "0x%llx 0x%llx \n",
22730 ioStream, (unsigned long long)device, (unsigned long long)pipeline,
22731 (unsigned long long)group, (unsigned long long)groupShader);
22732 }
22733 VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return =
22734 (VkDeviceSize)0;
22735 vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return =
22736 vk->vkGetRayTracingShaderGroupStackSizeKHR(unboxed_device, pipeline, group,
22737 groupShader);
22738 vkStream->unsetHandleMapping();
22739 vkStream->write(&vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return,
22740 sizeof(VkDeviceSize));
22741 vkStream->commitWrite();
22742 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22743 (uintptr_t)snapshotTraceBegin);
22744 size_t snapshotTraceBytes = vkReadStream->endTrace();
22745 if (m_state->snapshotsEnabled()) {
22746 m_state->snapshot()->vkGetRayTracingShaderGroupStackSizeKHR(
22747 snapshotTraceBegin, snapshotTraceBytes, &m_pool,
22748 vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return, device,
22749 pipeline, group, groupShader);
22750 }
22751 vkReadStream->clearPool();
22752 if (m_queueSubmitWithCommandsEnabled)
22753 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22754 break;
22755 }
22756 case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
22757 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
22758 "VkDecoder vkCmdSetRayTracingPipelineStackSizeKHR");
22759 VkCommandBuffer commandBuffer;
22760 uint32_t pipelineStackSize;
22761 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
22762 uint64_t cgen_var_0;
22763 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
22764 *readStreamPtrPtr += 1 * 8;
22765 *(VkCommandBuffer*)&commandBuffer =
22766 (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
22767 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
22768 auto vk = dispatch_VkCommandBuffer(commandBuffer);
22769 // End manual dispatchable handle unboxing for commandBuffer;
22770 memcpy((uint32_t*)&pipelineStackSize, *readStreamPtrPtr, sizeof(uint32_t));
22771 *readStreamPtrPtr += sizeof(uint32_t);
22772 if (m_logCalls) {
22773 fprintf(
22774 stderr,
22775 "stream %p: call vkCmdSetRayTracingPipelineStackSizeKHR 0x%llx 0x%llx \n",
22776 ioStream, (unsigned long long)commandBuffer,
22777 (unsigned long long)pipelineStackSize);
22778 }
22779 vk->vkCmdSetRayTracingPipelineStackSizeKHR(unboxed_commandBuffer,
22780 pipelineStackSize);
22781 vkStream->unsetHandleMapping();
22782 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
22783 (uintptr_t)snapshotTraceBegin);
22784 size_t snapshotTraceBytes = vkReadStream->endTrace();
22785 if (m_state->snapshotsEnabled()) {
22786 m_state->snapshot()->vkCmdSetRayTracingPipelineStackSizeKHR(
22787 snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
22788 pipelineStackSize);
22789 }
22790 vkReadStream->clearPool();
22791 if (m_queueSubmitWithCommandsEnabled)
22792 seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
22793 break;
22794 }
22795 #endif
22796 default: {
22797 m_pool.freeAll();
22798 return ptr - (unsigned char*)buf;
22799 }
22800 }
22801 ptr += packetLen;
22802 vkStream->clearPool();
22803 }
22804 if (m_forSnapshotLoad) {
22805 m_state->clearCreatedHandlesForSnapshotLoad();
22806 }
22807 m_pool.freeAll();
22808 return ptr - (unsigned char*)buf;
22809 ;
22810 }
22811
22812 } // namespace vk
22813 } // namespace gfxstream
22814