Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 64070a88a7a4411e0eb0d7148bd1a1598e74a88c / . / vktrace / vktrace_generate.py
blob: b8660307a21c2e97b05e23ce6b96655f37bf3920 [file] [log] [blame]
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1#!/usr/bin/env python3
2#
3# Vulkan
4#
Courtney Goeltzenleuchter8a17da52015-10-29 13:50:34 -0600[diff] [blame]5# Copyright (C) 2015 Valve Corporation
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]6#
7# Permission is hereby granted, free of charge, to any person obtaining a
8# copy of this software and associated documentation files (the "Software"),
9# to deal in the Software without restriction, including without limitation
10# the rights to use, copy, modify, merge, publish, distribute, sublicense,
11# and/or sell copies of the Software, and to permit persons to whom the
12# Software is furnished to do so, subject to the following conditions:
13#
14# The above copyright notice and this permission notice shall be included
15# in all copies or substantial portions of the Software.
16#
17# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23# DEALINGS IN THE SOFTWARE.
24#
Courtney Goeltzenleuchter96cd7952015-10-30 11:14:30 -0600[diff] [blame]25# Author: Jon Ashburn <jon@lunarg.com>
26# Author: Tobin Ehlis <tobin@lunarg.com>
Jon Ashburn01e96962015-11-03 11:57:00 -0700[diff] [blame]27# Author: Peter Lohrmann <peterl@valvesoftware.com>
Courtney Goeltzenleuchter96cd7952015-10-30 11:14:30 -0600[diff] [blame]28#
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]29
30import os, sys
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]31
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]32
33# add main repo directory so vulkan.py can be imported. This needs to be a complete path.
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]34vktrace_scripts_path = os.path.dirname(os.path.abspath(__file__))
35main_path = os.path.abspath(vktrace_scripts_path + "/../")
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]36sys.path.append(main_path)
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]37from source_line_info import sourcelineinfo
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]38
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]39import vulkan
40
41# vulkan.py doesn't include all the extensions (debug_report missing)
42headers = []
43objects = []
44protos = []
45for ext in vulkan.extensions_all:
46 headers.extend(ext.headers)
47 objects.extend(ext.objects)
48 protos.extend(ext.protos)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]49
50class Subcommand(object):
51 def __init__(self, argv):
52 self.argv = argv
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]53 self.extensionName = argv
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]54 self.headers = headers
55 self.objects = objects
56 self.protos = protos
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]57 self.lineinfo = sourcelineinfo()
58
59 def run(self):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]60 print(self.generate(self.extensionName))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]61
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]62 def generate(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]63 copyright = self.generate_copyright()
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]64 header = self.generate_header(extensionName)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]65 body = self.generate_body()
66 footer = self.generate_footer()
67 contents = []
68 if copyright:
69 contents.append(copyright)
70 if header:
71 contents.append(header)
72 if body:
73 contents.append(body)
74 if footer:
75 contents.append(footer)
76
77 return "\n\n".join(contents)
78
79 def generate_copyright(self):
80 return """/* THIS FILE IS GENERATED. DO NOT EDIT. */
81
82/*
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]83 *
Courtney Goeltzenleuchter8a17da52015-10-29 13:50:34 -0600[diff] [blame]84 * Copyright (C) 2015 Valve Corporation
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]85 *
86 * Permission is hereby granted, free of charge, to any person obtaining a
87 * copy of this software and associated documentation files (the "Software"),
88 * to deal in the Software without restriction, including without limitation
89 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
90 * and/or sell copies of the Software, and to permit persons to whom the
91 * Software is furnished to do so, subject to the following conditions:
92 *
93 * The above copyright notice and this permission notice shall be included
94 * in all copies or substantial portions of the Software.
95 *
96 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
97 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
98 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
99 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
100 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
101 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
102 * DEALINGS IN THE SOFTWARE.
Courtney Goeltzenleuchter96cd7952015-10-30 11:14:30 -0600[diff] [blame]103 *
104 * Author: Jon Ashburn <jon@lunarg.com>
Jon Ashburn56501152015-11-03 13:46:15 -0700[diff] [blame]105 * Author: Tobin Ehlis <tobin@lunarg.com>
106 * Author: Peter Lohrmann <peterl@valvesoftware.com>
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]107 */"""
108
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]109 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]110 return "\n".join(["#include <" + h + ">" for h in self.headers])
111
112 def generate_body(self):
113 pass
114
115 def generate_footer(self):
116 pass
117
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]118 def _generate_trace_func_protos(self):
119 func_protos = []
Jon Ashburn4278f642015-09-11 13:12:02 -0600[diff] [blame]120 func_protos.append('#ifdef __cplusplus')
121 func_protos.append('extern"C" {')
122 func_protos.append('#endif')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]123 func_protos.append('// Hooked function prototypes\n')
124 for proto in self.protos:
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]125 if 'Dbg' not in proto.name and 'KHR' not in proto.name:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]126 func_protos.append('VKTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_vk", attr="VKAPI"))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]127
Jon Ashburn4278f642015-09-11 13:12:02 -0600[diff] [blame]128 func_protos.append('#ifdef __cplusplus')
129 func_protos.append('}')
130 func_protos.append('#endif')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]131 return "\n".join(func_protos)
132
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]133 def _generate_trace_func_protos_ext(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]134 func_protos = []
135 func_protos.append('// Hooked function prototypes\n')
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]136 for ext in vulkan.extensions_all:
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]137 if (extensionName.lower() == ext.name.lower()):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]138 for proto in ext.protos:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]139 func_protos.append('VKTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_vk", attr="VKAPI"))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]140
141 return "\n".join(func_protos)
142
143
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]144 def _generate_init_funcs(self):
145 init_tracer = []
146 init_tracer.append('void send_vk_api_version_packet()\n{')
147 init_tracer.append(' packet_vkApiVersion* pPacket;')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]148 init_tracer.append(' vktrace_trace_packet_header* pHeader;')
149 init_tracer.append(' pHeader = vktrace_create_trace_packet(VKTRACE_TID_VULKAN, VKTRACE_TPI_VK_vkApiVersion, sizeof(packet_vkApiVersion), 0);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]150 init_tracer.append(' pPacket = interpret_body_as_vkApiVersion(pHeader);')
151 init_tracer.append(' pPacket->version = VK_API_VERSION;')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]152 init_tracer.append(' vktrace_set_packet_entrypoint_end_time(pHeader);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]153 init_tracer.append(' FINISH_TRACE_PACKET();\n}\n')
154
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]155 init_tracer.append('extern VKTRACE_CRITICAL_SECTION g_memInfoLock;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]156 init_tracer.append('void InitTracer(void)\n{')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]157 init_tracer.append(' const char *ipAddr = vktrace_get_global_var("VKTRACE_LIB_IPADDR");')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]158 init_tracer.append(' if (ipAddr == NULL)')
159 init_tracer.append(' ipAddr = "127.0.0.1";')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]160 init_tracer.append(' gMessageStream = vktrace_MessageStream_create(FALSE, ipAddr, VKTRACE_BASE_PORT + VKTRACE_TID_VULKAN);')
161 init_tracer.append(' vktrace_trace_set_trace_file(vktrace_FileLike_create_msg(gMessageStream));')
162 init_tracer.append(' vktrace_tracelog_set_tracer_id(VKTRACE_TID_VULKAN);')
163 init_tracer.append(' vktrace_create_critical_section(&g_memInfoLock);')
Mark Lobodzinski48837d12015-09-28 12:08:57 -0600[diff] [blame]164 init_tracer.append(' if (gMessageStream != NULL)')
165 init_tracer.append(' send_vk_api_version_packet();\n}\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]166 return "\n".join(init_tracer)
167
168 # Take a list of params and return a list of dicts w/ ptr param details
169 def _get_packet_ptr_param_list(self, params):
170 ptr_param_list = []
171 # TODO : This is a slightly nicer way to handle custom cases than initial code, however
172 # this can still be further generalized to eliminate more custom code
173 # big case to handle is when ptrs to structs have embedded data that needs to be accounted for in packet
174 custom_ptr_dict = {'VkDeviceCreateInfo': {'add_txt': 'add_VkDeviceCreateInfo_to_packet(pHeader, (VkDeviceCreateInfo**) &(pPacket->pCreateInfo), pCreateInfo)',
175 'finalize_txt': ''},
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]176 'VkApplicationInfo': {'add_txt': 'add_VkApplicationInfo_to_packet(pHeader, (VkApplicationInfo**)&(pPacket->pApplicationInfo), pApplicationInfo)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]177 'finalize_txt': ''},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]178 'VkPhysicalDevice': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), *pGpuCount*sizeof(VkPhysicalDevice), pGpus)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]179 'finalize_txt': 'default'},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]180 'pDataSize': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize)',
181 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize))'},
182# 'pData': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]183# 'finalize_txt': 'default'},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]184 'pName': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pName), ((pName != NULL) ? strlen(pName) + 1 : 0), pName)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]185 'finalize_txt': 'default'},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]186 'pMarker': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMarker), ((pMarker != NULL) ? strlen(pMarker) + 1 : 0), pMarker)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]187 'finalize_txt': 'default'},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]188 'pExtName': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pExtName), ((pExtName != NULL) ? strlen(pExtName) + 1 : 0), pExtName)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]189 'finalize_txt': 'default'},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]190 'pDescriptorSets': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]191 'finalize_txt': 'default'},
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]192 'pSparseMemoryRequirements': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSparseMemoryRequirements), (*pSparseMemoryRequirementCount) * sizeof(VkSparseImageMemoryRequirements), pSparseMemoryRequirements)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]193 'finalize_txt': 'default'},
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]194 'VkSparseImageFormatProperties': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pProperties), (*pPropertyCount) * sizeof(VkSparseImageFormatProperties), pProperties)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]195 'finalize_txt': 'default'},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]196 'VkSparseMemoryBindInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pBindInfo), numBindings * sizeof(VkSparseMemoryBindInfo), pBindInfo)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]197 'finalize_txt': 'default'},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]198 'VkSparseImageMemoryBindInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pBindInfo), numBindings * sizeof(VkSparseImageMemoryBindInfo), pBindInfo)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]199 'finalize_txt': 'default'},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]200 'VkFramebufferCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkFramebufferCreateInfo), pCreateInfo);\n'
201 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments), colorCount * sizeof(VkColorAttachmentBindInfo), pCreateInfo->pColorAttachments);\n'
202 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment), dsSize, pCreateInfo->pDepthStencilAttachment)',
203 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments));\n'
204 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment));\n'
205 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
206 'VkRenderPassCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkRenderPassCreateInfo), pCreateInfo);\n'
207 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorFormats), colorCount * sizeof(VkFormat), pCreateInfo->pColorFormats);\n'
208 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLayouts), colorCount * sizeof(VkImageLayout), pCreateInfo->pColorLayouts);\n'
209 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps), colorCount * sizeof(VkAttachmentLoadOp), pCreateInfo->pColorLoadOps);\n'
210 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps), colorCount * sizeof(VkAttachmentStoreOp), pCreateInfo->pColorStoreOps);\n'
211 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues), colorCount * sizeof(VkClearColor), pCreateInfo->pColorLoadClearValues)',
212 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorFormats));\n'
213 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLayouts));\n'
214 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps));\n'
215 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps));\n'
216 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues));\n'
217 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
218 'VkPipelineLayoutCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkPipelineLayoutCreateInfo), pCreateInfo);\n'
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]219 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSetLayouts), pCreateInfo->setLayoutCount * sizeof(VkDescriptorSetLayout), pCreateInfo->pSetLayouts);',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]220 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSetLayouts));\n'
221 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]222 'VkMemoryAllocateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocateInfo), sizeof(VkMemoryAllocateInfo), pAllocateInfo);\n'
223 ' add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocateInfo->pNext), pAllocateInfo->pNext)',
224 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocateInfo))'},
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]225# 'VkGraphicsPipelineCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkGraphicsPipelineCreateInfo), pCreateInfos);\n'
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]226# ' add_VkGraphicsPipelineCreateInfos_to_trace_packet(pHeader, (VkGraphicsPipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, count)',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]227# 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos))'},
228# 'VkComputePipelineCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), count*sizeof(VkComputePipelineCreateInfo), pCreateInfos);\n'
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]229# ' add_VkComputePipelineCreateInfos_to_trace_packet(pHeader, (VkComputePipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, count)',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]230# 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos))'},
231 'VkDescriptorPoolCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDescriptorPoolCreateInfo), pCreateInfo);\n'
Chia-I Wuc51b1212015-10-27 19:25:11 +0800[diff] [blame]232 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pPoolSizes), pCreateInfo->poolSizeCount * sizeof(VkDescriptorPoolSize), pCreateInfo->pPoolSizes)',
233 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pPoolSizes));\n'
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]234 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]235 'VkDescriptorSetLayoutCreateInfo': {'add_txt': 'add_create_ds_layout_to_trace_packet(pHeader, &pPacket->pCreateInfo, pCreateInfo)',
236 'finalize_txt': '// pCreateInfo finalized in add_create_ds_layout_to_trace_packet'},
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]237 'VkSwapchainCreateInfoKHR': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkSwapchainCreateInfoKHR), pCreateInfo);\n'
238 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription), sizeof(VkSurfaceDescriptionKHR), pCreateInfo->pSurfaceDescription)',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]239 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSurfaceDescription));\n'
240 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
241 'VkShaderModuleCreateInfo': {'add_txt': 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkShaderModuleCreateInfo), pCreateInfo);\n'
242 ' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), pPacket->pCreateInfo->codeSize, pCreateInfo->pCode)',
243 'finalize_txt': 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));\n'
244 ' vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]245 }
246
247 for p in params:
248 pp_dict = {}
Jon Ashburnbb4e7c12015-09-14 17:30:20 -0600[diff] [blame]249 if '*' in p.ty and p.name not in ['pTag', 'pUserData']:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]250 if 'const' in p.ty.lower() and 'count' in params[params.index(p)-1].name.lower():
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]251 pp_dict['add_txt'] = 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s*sizeof(%s), %s)' % (p.name, params[params.index(p)-1].name, p.ty.strip('*').replace('const ', ''), p.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]252 elif 'pOffsets' == p.name: # TODO : This is a custom case for BindVertexBuffers last param, need to clean this up
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]253 pp_dict['add_txt'] = 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s*sizeof(%s), %s)' % (p.name, params[params.index(p)-2].name, p.ty.strip('*').replace('const ', ''), p.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]254 elif p.ty.strip('*').replace('const ', '') in custom_ptr_dict:
255 pp_dict['add_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['add_txt']
256 pp_dict['finalize_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['finalize_txt']
257 elif p.name in custom_ptr_dict:
258 pp_dict['add_txt'] = custom_ptr_dict[p.name]['add_txt']
259 pp_dict['finalize_txt'] = custom_ptr_dict[p.name]['finalize_txt']
260 # TODO : This is custom hack to account for 2 pData items with dataSize param for sizing
261 if 'pData' == p.name and 'dataSize' == params[params.index(p)-1].name:
262 pp_dict['add_txt'] = pp_dict['add_txt'].replace('_dataSize', 'dataSize')
Jon Ashburn60816752015-11-12 13:46:36 -0700[diff] [blame]263 elif 'void' in p.ty and (p.name == 'pData' or p.name == 'pValues'):
Jon Ashburnbb4e7c12015-09-14 17:30:20 -0600[diff] [blame]264 pp_dict['add_txt'] = '//TODO FIXME vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s)' % (p.name, p.ty.strip('*').replace('const ', ''), p.name)
265 pp_dict['finalize_txt'] = '//TODO FIXME vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->%s))' % (p.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]266 else:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]267 pp_dict['add_txt'] = 'vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s)' % (p.name, p.ty.strip('*').replace('const ', ''), p.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]268 if 'finalize_txt' not in pp_dict or 'default' == pp_dict['finalize_txt']:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]269 pp_dict['finalize_txt'] = 'vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->%s))' % (p.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]270 pp_dict['index'] = params.index(p)
271 ptr_param_list.append(pp_dict)
272 return ptr_param_list
273
274 # Take a list of params and return a list of packet size elements
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]275 def _get_packet_size(self, extensionName, params):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]276 ps = [] # List of elements to be added together to account for packet size for given params
277 skip_list = [] # store params that are already accounted for so we don't count them twice
278 # Dict of specific params with unique custom sizes
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]279 # TODO: Now using bitfields for all stages, need pSetBindPoints to accomodate that.
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]280 custom_size_dict = {'pSetBindPoints': '(VK_SHADER_STAGE_COMPUTE * sizeof(uint32_t))', # Accounting for largest possible array
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]281 'VkSwapchainCreateInfoKHR' : 'vk_ext_khr_device_swapchain_size_vkswapchaincreateinfokhr(pCreateInfo)',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]282 }
283 size_func_suffix = ''
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]284 if extensionName.lower() != "vk_core":
285 size_func_suffix = '_%s' % extensionName.lower()
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]286 for p in params:
287 #First handle custom cases
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]288 if p.name in ['pCreateInfo', 'pSetLayoutInfoList', 'pBeginInfo', 'pAllocateInfo'] and 'khr' not in p.ty.lower():
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]289 ps.append('get_struct_chain_size%s((void*)%s)' % (size_func_suffix, p.name))
290 skip_list.append(p.name)
291 elif p.name in custom_size_dict:
292 ps.append(custom_size_dict[p.name])
293 skip_list.append(p.name)
294 elif p.ty.strip('*').replace('const ', '') in custom_size_dict:
295 tmp_ty = p.ty.strip('*').replace('const ', '')
296 ps.append(custom_size_dict[tmp_ty])
297 skip_list.append(p.name)
298 # Skip any params already handled
299 if p.name in skip_list:
300 continue
301 # Now check to identify dynamic arrays which depend on two params
302 if 'count' in p.name.lower():
303 next_idx = params.index(p)+1
304 # If next element is a const *, then multiply count and array type
305 if next_idx < len(params) and '*' in params[next_idx].ty and 'const' in params[next_idx].ty.lower():
306 if '*' in p.ty:
307 ps.append('*%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
308 else:
309 ps.append('%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
310 skip_list.append(params[next_idx].name)
311 if 'bindingCount' == p.name: # TODO : This is custom case for CmdBindVertexBuffers, need to clean it up
312 ps.append('%s*sizeof(%s)' % (p.name, params[next_idx+1].ty.strip('*').replace('const ', '')))
313 skip_list.append(params[next_idx+1].name)
314 elif '*' in p.ty: # Not a custom array size we're aware of, but ptr so need to account for its size
315 ps.append('sizeof(%s)' % (p.ty.strip('*').replace('const ', '')))
316 elif '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
317 if 'pData' == p.name:
318 if 'dataSize' == params[params.index(p)-1].name:
319 ps.append('dataSize')
320 elif 'counterCount' == params[params.index(p)-1].name:
321 ps.append('sizeof(%s)' % p.ty.strip('*').replace('const ', ''))
322 else:
323 #ps.append('((pDataSize != NULL && pData != NULL) ? *pDataSize : 0)')
324 ps.append('sizeof(void*)')
325 elif '**' in p.ty and 'void' in p.ty:
326 ps.append('sizeof(void*)')
327 elif 'void' in p.ty:
328 ps.append('sizeof(%s)' % p.name)
329 elif 'char' in p.ty:
330 ps.append('((%s != NULL) ? strlen(%s) + 1 : 0)' % (p.name, p.name))
331 elif 'pDataSize' in p.name:
332 ps.append('((pDataSize != NULL) ? sizeof(size_t) : 0)')
333 elif 'IMAGE_SUBRESOURCE' in p.ty and 'pSubresource' == p.name:
334 ps.append('((pSubresource != NULL) ? sizeof(VkImage_SUBRESOURCE) : 0)')
335 else:
336 ps.append('sizeof(%s)' % (p.ty.strip('*').replace('const ', '')))
337 return ps
338
339 # Generate functions used to trace API calls and store the input and result data into a packet
340 # Here's the general flow of code insertion w/ option items flagged w/ "?"
341 # Result decl?
342 # Packet struct decl
343 # ?Special case : setup call to function first and do custom API call time tracking
344 # CREATE_PACKET
345 # call real entrypoint and get return value (if there is one)
346 # Assign packet values
347 # FINISH packet
348 # return result if needed
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]349 def _generate_trace_funcs(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]350 func_body = []
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]351 manually_written_hooked_funcs = ['AllocateMemory',
352 'AllocateDescriptorSets',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]353 'CreateDescriptorPool',
Jon Ashburne70884b2015-08-25 13:33:39 -0600[diff] [blame]354 'CreateDevice',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]355 'CreateFramebuffer',
356 'CreateInstance',
357 'CreateRenderPass',
358 'CreateGraphicsPipelines',
359 'CreateComputePipelines',
360 'CmdPipelineBarrier',
361 'CmdWaitEvents',
362 'CmdBeginRenderPass',
363 'EnumeratePhysicalDevices',
364 'FreeMemory',
365 'FreeDescriptorSets',
Courtney Goeltzenleuchter3ec31622015-10-20 18:04:07 -0600[diff] [blame]366 'QueueSubmit',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]367 'FlushMappedMemoryRanges',
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]368 'GetDeviceProcAddr',
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]369 'GetInstanceProcAddr',
Courtney Goeltzenleuchter74c4ce92015-09-14 17:22:16 -0600[diff] [blame]370 'EnumerateInstanceExtensionProperties',
371 'EnumerateDeviceExtensionProperties',
372 'EnumerateInstanceLayerProperties',
373 'EnumerateDeviceLayerProperties',
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]374 'GetPhysicalDeviceQueueFamilyProperties',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]375 'GetQueryPoolResults',
376 'MapMemory',
377 'UnmapMemory',
378 'UpdateDescriptorSets',
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]379 'GetSurfacePropertiesKHR',
380 'GetSurfaceFormatsKHR',
381 'GetSurfacePresentModesKHR',
382 'CreateSwapchainKHR',
383 'GetSwapchainImagesKHR',
384 'QueuePresentKHR',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]385 ]
386
387 # validate the manually_written_hooked_funcs list
388 protoFuncs = [proto.name for proto in self.protos]
389 for func in manually_written_hooked_funcs:
390 if func not in protoFuncs:
391 sys.exit("Entry '%s' in manually_written_hooked_funcs list is not in the vulkan function prototypes" % func)
392
393 # process each of the entrypoint prototypes
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]394 for ext in vulkan.extensions_all:
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]395 if ext.name.lower() == extensionName.lower():
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]396 for proto in ext.protos:
397 if proto.name in manually_written_hooked_funcs:
Courtney Goeltzenleuchter3ec31622015-10-20 18:04:07 -0600[diff] [blame]398 func_body.append( '// __HOOKED_vk%s is manually written. Look in vktrace_lib_trace.cpp\n' % proto.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]399 else:
400 raw_packet_update_list = [] # non-ptr elements placed directly into packet
401 ptr_packet_update_list = [] # ptr elements to be updated into packet
402 return_txt = ''
403 packet_size = []
404 in_data_size = False # flag when we need to capture local input size variable for in/out size
405 func_body.append('%s' % self.lineinfo.get())
Chia-I Wuaf9e4fd2015-11-06 06:42:02 +0800[diff] [blame]406 func_body.append('VKTRACER_EXPORT VKAPI_ATTR %s VKAPI_CALL __HOOKED_vk%s(' % (proto.ret, proto.name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]407 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 if NULL
Chia-I Wua5cd6532015-10-28 18:31:57 +0800[diff] [blame]408 func_body.append(' %s,' % p.c())
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]409 if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
410 if 'pDataSize' in p.name:
411 in_data_size = True;
412 elif 'pfnMsgCallback' == p.name:
413 raw_packet_update_list.append(' PFN_vkDbgMsgCallback* pNonConstCallback = (PFN_vkDbgMsgCallback*)&pPacket->pfnMsgCallback;')
414 raw_packet_update_list.append(' *pNonConstCallback = pfnMsgCallback;')
Chia-I Wua5cd6532015-10-28 18:31:57 +0800[diff] [blame]415 elif '[' in p.ty:
416 raw_packet_update_list.append(' memcpy((void *) pPacket->%s, %s, sizeof(pPacket->%s));' % (p.name, p.name, p.name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]417 else:
418 raw_packet_update_list.append(' pPacket->%s = %s;' % (p.name, p.name))
419 # Get list of packet size modifiers due to ptr params
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]420 packet_size = self._get_packet_size(extensionName, proto.params)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]421 ptr_packet_update_list = self._get_packet_ptr_param_list(proto.params)
422 func_body[-1] = func_body[-1].replace(',', ')')
423 # End of function declaration portion, begin function body
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]424 func_body.append('{\n vktrace_trace_packet_header* pHeader;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]425 if 'void' not in proto.ret or '*' in proto.ret:
426 func_body.append(' %s result;' % proto.ret)
427 return_txt = 'result = '
428 if in_data_size:
429 func_body.append(' size_t _dataSize;')
430 func_body.append(' packet_vk%s* pPacket = NULL;' % proto.name)
Jon Ashburnf6754d42015-09-14 16:48:31 -0600[diff] [blame]431 if proto.name == "DestroyInstance" or proto.name == "DestroyDevice":
432 func_body.append(' dispatch_key key = get_dispatch_key(%s);' % proto.params[0].name)
433
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]434 if (0 == len(packet_size)):
435 func_body.append(' CREATE_TRACE_PACKET(vk%s, 0);' % (proto.name))
436 else:
437 func_body.append(' CREATE_TRACE_PACKET(vk%s, %s);' % (proto.name, ' + '.join(packet_size)))
438
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]439 # call down the layer chain and get return value (if there is one)
440 # Note: this logic doesn't work for CreateInstance or CreateDevice but those are handwritten
David Pinedoa31fe0b2015-11-24 09:00:24 -0700[diff] [blame]441 if extensionName == 'vk_lunarg_debug_marker':
Jon Ashburn5afdcf62015-09-14 15:17:36 -0600[diff] [blame]442 table_txt = 'mdd(%s)->debugMarkerTable' % proto.params[0].name
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]443 elif proto.params[0].ty in ['VkInstance', 'VkPhysicalDevice']:
Jon Ashburn5afdcf62015-09-14 15:17:36 -0600[diff] [blame]444 table_txt = 'mid(%s)->instTable' % proto.params[0].name
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]445 else:
Jon Ashburn5afdcf62015-09-14 15:17:36 -0600[diff] [blame]446 table_txt = 'mdd(%s)->devTable' % proto.params[0].name
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]447 func_body.append(' %s%s.%s;' % (return_txt, table_txt, proto.c_call()))
448 func_body.append(' vktrace_set_packet_entrypoint_end_time(pHeader);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]449
450 if in_data_size:
451 func_body.append(' _dataSize = (pDataSize == NULL || pData == NULL) ? 0 : *pDataSize;')
452 func_body.append(' pPacket = interpret_body_as_vk%s(pHeader);' % proto.name)
453 func_body.append('\n'.join(raw_packet_update_list))
454 for pp_dict in ptr_packet_update_list: #buff_ptr_indices:
455 func_body.append(' %s;' % (pp_dict['add_txt']))
456 if 'void' not in proto.ret or '*' in proto.ret:
457 func_body.append(' pPacket->result = result;')
458 for pp_dict in ptr_packet_update_list:
459 if ('DeviceCreateInfo' not in proto.params[pp_dict['index']].ty):
460 func_body.append(' %s;' % (pp_dict['finalize_txt']))
461 # All buffers should be finalized by now, and the trace packet can be finished (which sends it over the socket)
462 func_body.append(' FINISH_TRACE_PACKET();')
Jon Ashburnf6754d42015-09-14 16:48:31 -0600[diff] [blame]463 if proto.name == "DestroyInstance":
464 func_body.append(' g_instanceDataMap.erase(key);')
465 elif proto.name == "DestroyDevice":
466 func_body.append(' g_deviceDataMap.erase(key);')
467
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]468 # return result if needed
469 if 'void' not in proto.ret or '*' in proto.ret:
470 func_body.append(' return result;')
471 func_body.append('}\n')
472 return "\n".join(func_body)
473
474 def _generate_packet_id_enum(self):
475 pid_enum = []
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]476 pid_enum.append('enum VKTRACE_TRACE_PACKET_ID_VK')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]477 pid_enum.append('{')
478 first_func = True
479 for proto in self.protos:
480 if first_func:
481 first_func = False
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]482 pid_enum.append(' VKTRACE_TPI_VK_vkApiVersion = VKTRACE_TPI_BEGIN_API_HERE,')
483 pid_enum.append(' VKTRACE_TPI_VK_vk%s,' % proto.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]484 else:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]485 pid_enum.append(' VKTRACE_TPI_VK_vk%s,' % proto.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]486 pid_enum.append('};\n')
487 return "\n".join(pid_enum)
488
489 def _generate_packet_id_name_func(self):
490 func_body = []
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]491 func_body.append('static const char *vktrace_vk_packet_id_name(const enum VKTRACE_TRACE_PACKET_ID_VK id)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]492 func_body.append('{')
493 func_body.append(' switch(id) {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]494 func_body.append(' case VKTRACE_TPI_VK_vkApiVersion:')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]495 func_body.append(' {')
496 func_body.append(' return "vkApiVersion";')
497 func_body.append(' }')
498 for proto in self.protos:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]499 func_body.append(' case VKTRACE_TPI_VK_vk%s:' % proto.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]500 func_body.append(' {')
501 func_body.append(' return "vk%s";' % proto.name)
502 func_body.append(' }')
503 func_body.append(' default:')
504 func_body.append(' return NULL;')
505 func_body.append(' }')
506 func_body.append('}\n')
507 return "\n".join(func_body)
508
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]509 def _generate_interp_func(self):
510 interp_func_body = []
511 interp_func_body.append('%s' % self.lineinfo.get())
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]512 interp_func_body.append('static vktrace_trace_packet_header* interpret_trace_packet_vk(vktrace_trace_packet_header* pHeader)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]513 interp_func_body.append('{')
514 interp_func_body.append(' if (pHeader == NULL)')
515 interp_func_body.append(' {')
516 interp_func_body.append(' return NULL;')
517 interp_func_body.append(' }')
518 interp_func_body.append(' switch (pHeader->packet_id)')
519 interp_func_body.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]520 interp_func_body.append(' case VKTRACE_TPI_VK_vkApiVersion:')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]521 interp_func_body.append(' {')
522 interp_func_body.append(' return interpret_body_as_vkApiVersion(pHeader)->header;')
523 interp_func_body.append(' }')
524 for proto in self.protos:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]525 interp_func_body.append(' case VKTRACE_TPI_VK_vk%s:\n {' % proto.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]526 header_prefix = 'h'
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]527 if 'KHR' in proto.name or 'Dbg' in proto.name:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]528 header_prefix = 'pH'
529 interp_func_body.append(' return interpret_body_as_vk%s(pHeader)->%seader;\n }' % (proto.name, header_prefix))
530 interp_func_body.append(' default:')
531 interp_func_body.append(' return NULL;')
532 interp_func_body.append(' }')
533 interp_func_body.append(' return NULL;')
534 interp_func_body.append('}')
535 return "\n".join(interp_func_body)
536
537 def _generate_struct_util_funcs(self):
538 lineinfo = self.lineinfo
539 pid_enum = []
540 pid_enum.append('%s' % lineinfo.get())
541 pid_enum.append('//=============================================================================')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]542 pid_enum.append('static void add_VkApplicationInfo_to_packet(vktrace_trace_packet_header* pHeader, VkApplicationInfo** ppStruct, const VkApplicationInfo *pInStruct)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]543 pid_enum.append('{')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]544 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkApplicationInfo), pInStruct);')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]545 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pApplicationName), strlen(pInStruct->pApplicationName) + 1, pInStruct->pApplicationName);')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]546 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen(pInStruct->pEngineName) + 1, pInStruct->pEngineName);')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]547 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pApplicationName));')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]548 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')
549 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]550 pid_enum.append('};\n')
551 pid_enum.append('%s' % lineinfo.get())
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]552 pid_enum.append('static void add_VkInstanceCreateInfo_to_packet(vktrace_trace_packet_header* pHeader, VkInstanceCreateInfo** ppStruct, VkInstanceCreateInfo *pInStruct)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]553 pid_enum.append('{')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]554 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkInstanceCreateInfo), pInStruct);')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]555 pid_enum.append(' add_VkApplicationInfo_to_packet(pHeader, (VkApplicationInfo**)&((*ppStruct)->pApplicationInfo), pInStruct->pApplicationInfo);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]556 # TODO138 : This is an initial pass at getting the extension/layer arrays correct, needs to be validated.
557 pid_enum.append(' uint32_t i, siz = 0;')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]558 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledLayerNames), pInStruct->enabledLayerNameCount * sizeof(char*), pInStruct->ppEnabledLayerNames);')
559 pid_enum.append(' if (pInStruct->enabledLayerNameCount > 0) ')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]560 pid_enum.append(' {')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]561 pid_enum.append(' for (i = 0; i < pInStruct->enabledLayerNameCount; i++) {')
Jon Ashburn5bd87b92015-10-07 10:23:30 -0600[diff] [blame]562 pid_enum.append(' siz = (uint32_t) (1 + strlen(pInStruct->ppEnabledLayerNames[i]));')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]563 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledLayerNames[i]), siz, pInStruct->ppEnabledLayerNames[i]);')
564 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames[i]);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]565 pid_enum.append(' }')
566 pid_enum.append(' }')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]567 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames);')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]568 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledExtensionNames), pInStruct->enabledExtensionNameCount * sizeof(char*), pInStruct->ppEnabledExtensionNames);')
569 pid_enum.append(' if (pInStruct->enabledExtensionNameCount > 0) ')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]570 pid_enum.append(' {')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]571 pid_enum.append(' for (i = 0; i < pInStruct->enabledExtensionNameCount; i++) {')
Jon Ashburn5bd87b92015-10-07 10:23:30 -0600[diff] [blame]572 pid_enum.append(' siz = (uint32_t) (1 + strlen(pInStruct->ppEnabledExtensionNames[i]));')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]573 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames[i]), siz, pInStruct->ppEnabledExtensionNames[i]);')
574 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames[i]);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]575 pid_enum.append(' }')
576 pid_enum.append(' }')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]577 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
578 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)ppStruct);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]579 pid_enum.append('}\n')
580 pid_enum.append('%s' % lineinfo.get())
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]581 pid_enum.append('static void add_VkDeviceCreateInfo_to_packet(vktrace_trace_packet_header* pHeader, VkDeviceCreateInfo** ppStruct, const VkDeviceCreateInfo *pInStruct)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]582 pid_enum.append('{')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]583 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkDeviceCreateInfo), pInStruct);')
Chia-I Wu045654f2015-11-06 06:42:02 +0800[diff] [blame]584 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pQueueCreateInfos, pInStruct->queueCreateInfoCount*sizeof(VkDeviceQueueCreateInfo), pInStruct->pQueueCreateInfos);')
585 pid_enum.append(' for (uint32_t i = 0; i < pInStruct->queueCreateInfoCount; i++) {')
586 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pQueueCreateInfos[i].pQueuePriorities,')
587 pid_enum.append(' pInStruct->pQueueCreateInfos[i].queueCount*sizeof(float),')
588 pid_enum.append(' pInStruct->pQueueCreateInfos[i].pQueuePriorities);')
589 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pQueueCreateInfos[i].pQueuePriorities);')
Courtney Goeltzenleuchterd3a8d362015-10-23 10:37:02 -0600[diff] [blame]590 pid_enum.append(' }')
Chia-I Wu045654f2015-11-06 06:42:02 +0800[diff] [blame]591 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pQueueCreateInfos);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]592 # TODO138 : This is an initial pass at getting the extension/layer arrays correct, needs to be validated.
593 pid_enum.append(' uint32_t i, siz = 0;')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]594 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledLayerNames), pInStruct->enabledLayerNameCount * sizeof(char*), pInStruct->ppEnabledLayerNames);')
595 pid_enum.append(' if (pInStruct->enabledLayerNameCount > 0) ')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]596 pid_enum.append(' {')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]597 pid_enum.append(' for (i = 0; i < pInStruct->enabledLayerNameCount; i++) {')
Jon Ashburn5bd87b92015-10-07 10:23:30 -0600[diff] [blame]598 pid_enum.append(' siz = (uint32_t) (1 + strlen(pInStruct->ppEnabledLayerNames[i]));')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]599 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledLayerNames[i]), siz, pInStruct->ppEnabledLayerNames[i]);')
600 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames[i]);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]601 pid_enum.append(' }')
602 pid_enum.append(' }')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]603 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledLayerNames);')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]604 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledExtensionNames), pInStruct->enabledExtensionNameCount * sizeof(char*), pInStruct->ppEnabledExtensionNames);')
605 pid_enum.append(' if (pInStruct->enabledExtensionNameCount > 0) ')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]606 pid_enum.append(' {')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]607 pid_enum.append(' for (i = 0; i < pInStruct->enabledExtensionNameCount; i++) {')
Jon Ashburn5bd87b92015-10-07 10:23:30 -0600[diff] [blame]608 pid_enum.append(' siz = (uint32_t) (1 + strlen(pInStruct->ppEnabledExtensionNames[i]));')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]609 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames[i]), siz, pInStruct->ppEnabledExtensionNames[i]);')
610 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames[i]);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]611 pid_enum.append(' }')
612 pid_enum.append(' }')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]613 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
614 pid_enum.append(' vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pEnabledFeatures, sizeof(VkPhysicalDeviceFeatures), pInStruct->pEnabledFeatures);')
615 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pEnabledFeatures);')
616 pid_enum.append(' vktrace_finalize_buffer_address(pHeader, (void**)ppStruct);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]617 pid_enum.append('}\n')
618 pid_enum.append('%s' % lineinfo.get())
619 pid_enum.append('//=============================================================================\n')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]620 pid_enum.append('static VkInstanceCreateInfo* interpret_VkInstanceCreateInfo(vktrace_trace_packet_header* pHeader, intptr_t ptr_variable)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]621 pid_enum.append('{')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]622 pid_enum.append(' VkInstanceCreateInfo* pVkInstanceCreateInfo = (VkInstanceCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]623 pid_enum.append(' uint32_t i;')
624 pid_enum.append(' if (pVkInstanceCreateInfo != NULL)')
625 pid_enum.append(' {')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]626 pid_enum.append(' pVkInstanceCreateInfo->pApplicationInfo = (VkApplicationInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pApplicationInfo);')
627 pid_enum.append(' VkApplicationInfo** ppApplicationInfo = (VkApplicationInfo**) &pVkInstanceCreateInfo->pApplicationInfo;')
628 pid_enum.append(' (*ppApplicationInfo)->pApplicationName = (const char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pApplicationInfo->pApplicationName);')
629 pid_enum.append(' (*ppApplicationInfo)->pEngineName = (const char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pApplicationInfo->pEngineName);')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]630 pid_enum.append(' if (pVkInstanceCreateInfo->enabledLayerNameCount > 0)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]631 pid_enum.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]632 pid_enum.append(' pVkInstanceCreateInfo->ppEnabledLayerNames = (const char* const*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledLayerNames);')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]633 pid_enum.append(' for (i = 0; i < pVkInstanceCreateInfo->enabledLayerNameCount; i++) {')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]634 pid_enum.append(' char** ppTmp = (char**)&pVkInstanceCreateInfo->ppEnabledLayerNames[i];')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]635 pid_enum.append(' *ppTmp = (char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledLayerNames[i]);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]636 pid_enum.append(' }')
637 pid_enum.append(' }')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]638 pid_enum.append(' if (pVkInstanceCreateInfo->enabledExtensionNameCount > 0)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]639 pid_enum.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]640 pid_enum.append(' pVkInstanceCreateInfo->ppEnabledExtensionNames = (const char* const*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledExtensionNames);')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]641 pid_enum.append(' for (i = 0; i < pVkInstanceCreateInfo->enabledExtensionNameCount; i++) {')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]642 pid_enum.append(' char** ppTmp = (char**)&pVkInstanceCreateInfo->ppEnabledExtensionNames[i];')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]643 pid_enum.append(' *ppTmp = (char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->ppEnabledExtensionNames[i]);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]644 pid_enum.append(' }')
645 pid_enum.append(' }')
646 pid_enum.append(' }\n')
647 pid_enum.append(' return pVkInstanceCreateInfo;')
648 pid_enum.append('}\n')
649 pid_enum.append('%s' % lineinfo.get())
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]650 pid_enum.append('static VkDeviceCreateInfo* interpret_VkDeviceCreateInfo(vktrace_trace_packet_header* pHeader, intptr_t ptr_variable)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]651 pid_enum.append('{')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]652 pid_enum.append(' VkDeviceCreateInfo* pVkDeviceCreateInfo = (VkDeviceCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]653 pid_enum.append(' uint32_t i;')
654 pid_enum.append(' if (pVkDeviceCreateInfo != NULL)')
655 pid_enum.append(' {')
Chia-I Wu045654f2015-11-06 06:42:02 +0800[diff] [blame]656 pid_enum.append(' pVkDeviceCreateInfo->pQueueCreateInfos = (const VkDeviceQueueCreateInfo *)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->pQueueCreateInfos);\n')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]657 pid_enum.append(' if (pVkDeviceCreateInfo->enabledLayerNameCount > 0)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]658 pid_enum.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]659 pid_enum.append(' pVkDeviceCreateInfo->ppEnabledLayerNames = (const char* const*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledLayerNames);')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]660 pid_enum.append(' for (i = 0; i < pVkDeviceCreateInfo->enabledLayerNameCount; i++) {')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]661 pid_enum.append(' char** ppTmp = (char**)&pVkDeviceCreateInfo->ppEnabledLayerNames[i];')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]662 pid_enum.append(' *ppTmp = (char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledLayerNames[i]);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]663 pid_enum.append(' }')
664 pid_enum.append(' }')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]665 pid_enum.append(' if (pVkDeviceCreateInfo->enabledExtensionNameCount > 0)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]666 pid_enum.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]667 pid_enum.append(' pVkDeviceCreateInfo->ppEnabledExtensionNames = (const char* const*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledExtensionNames);')
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]668 pid_enum.append(' for (i = 0; i < pVkDeviceCreateInfo->enabledExtensionNameCount; i++) {')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]669 pid_enum.append(' char** ppTmp = (char**)&pVkDeviceCreateInfo->ppEnabledExtensionNames[i];')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]670 pid_enum.append(' *ppTmp = (char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledExtensionNames[i]);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]671 pid_enum.append(' }')
672 pid_enum.append(' }')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]673 pid_enum.append(' pVkDeviceCreateInfo->pEnabledFeatures = (const VkPhysicalDeviceFeatures*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->pEnabledFeatures);\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]674 pid_enum.append(' }\n')
675 pid_enum.append(' return pVkDeviceCreateInfo;')
676 pid_enum.append('}\n')
677 pid_enum.append('%s' % lineinfo.get())
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]678 pid_enum.append('static void interpret_VkPipelineShaderStageCreateInfo(vktrace_trace_packet_header* pHeader, VkPipelineShaderStageCreateInfo* pShader)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]679 pid_enum.append('{')
680 pid_enum.append(' if (pShader != NULL)')
681 pid_enum.append(' {')
Chia-I Wu062ad152015-10-31 00:31:16 +0800[diff] [blame]682 pid_enum.append(' pShader->pName = (const char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pName);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]683 pid_enum.append(' // specialization info')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]684 pid_enum.append(' pShader->pSpecializationInfo = (const VkSpecializationInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pSpecializationInfo);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]685 pid_enum.append(' if (pShader->pSpecializationInfo != NULL)')
686 pid_enum.append(' {')
687 pid_enum.append(' VkSpecializationInfo* pInfo = (VkSpecializationInfo*)pShader->pSpecializationInfo;')
Chia-I Wu483e7702015-10-26 17:20:32 +0800[diff] [blame]688 pid_enum.append(' pInfo->pMapEntries = (const VkSpecializationMapEntry*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pSpecializationInfo->pMapEntries);')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]689 pid_enum.append(' pInfo->pData = (const void*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pSpecializationInfo->pData);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]690 pid_enum.append(' }')
691 pid_enum.append(' }')
692 pid_enum.append('}\n')
693 pid_enum.append('//=============================================================================')
694 return "\n".join(pid_enum)
695
696 # Interpret functions used on replay to read in packets and interpret their contents
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]697 # This code gets generated into vktrace_vk_vk_packets.h file
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]698 def _generate_interp_funcs(self):
699 # Custom txt for given function and parameter. First check if param is NULL, then insert txt if not
700 # First some common code used by both CmdWaitEvents & CmdPipelineBarrier
701 mem_barrier_interp = ['uint32_t i = 0;\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]702 'for (i = 0; i < pPacket->memoryBarrierCount; i++) {\n',
703 ' void** ppMB = (void**)&(pPacket->ppMemoryBarriers[i]);\n',
704 ' *ppMB = vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->ppMemoryBarriers[i]);\n',
705 ' //VkMemoryBarrier* pBarr = (VkMemoryBarrier*)pPacket->ppMemoryBarriers[i];\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]706 ' // TODO : Could fix up the pNext ptrs here if they were finalized and if we cared by switching on Barrier type and remapping\n',
707 '}']
708 create_rp_interp = ['VkRenderPassCreateInfo* pInfo = (VkRenderPassCreateInfo*)pPacket->pCreateInfo;\n',
709 'uint32_t i = 0;\n',
710 'VkAttachmentDescription **ppAD = (VkAttachmentDescription **)&(pInfo->pAttachments);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]711 '*ppAD = (VkAttachmentDescription*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pAttachments);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]712 'VkSubpassDescription** ppSP = (VkSubpassDescription**)&(pInfo->pSubpasses);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]713 '*ppSP = (VkSubpassDescription*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]714 'for (i=0; i<pInfo->subpassCount; i++) {\n',
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]715 ' VkAttachmentReference** pAR = (VkAttachmentReference**)&(pInfo->pSubpasses[i].pInputAttachments);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]716 ' *pAR = (VkAttachmentReference*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pInputAttachments);\n',
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]717 ' pAR = (VkAttachmentReference**)&(pInfo->pSubpasses[i].pColorAttachments);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]718 ' *pAR = (VkAttachmentReference*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pColorAttachments);\n',
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]719 ' pAR = (VkAttachmentReference**)&(pInfo->pSubpasses[i].pResolveAttachments);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]720 ' *pAR = (VkAttachmentReference*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pResolveAttachments);\n',
Chia-I Wuce532f72015-10-26 17:32:47 +0800[diff] [blame]721 ' pAR = (VkAttachmentReference**)&(pInfo->pSubpasses[i].pDepthStencilAttachment);\n',
722 ' *pAR = (VkAttachmentReference*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pDepthStencilAttachment);\n',
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]723 ' pAR = (VkAttachmentReference**)&(pInfo->pSubpasses[i].pPreserveAttachments);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]724 ' *pAR = (VkAttachmentReference*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pSubpasses[i].pPreserveAttachments);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]725 '}\n',
726 'VkSubpassDependency** ppSD = (VkSubpassDependency**)&(pInfo->pDependencies);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]727 '*ppSD = (VkSubpassDependency*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->pDependencies);\n']
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]728 create_gfx_pipe = ['uint32_t i;\n',
729 'uint32_t j;\n',
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]730 'for (i=0; i<pPacket->createInfoCount; i++) {\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]731 'if (pPacket->pCreateInfos[i].sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) {\n',
732 '// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
733 'VkGraphicsPipelineCreateInfo* pNonConst = (VkGraphicsPipelineCreateInfo*)&(pPacket->pCreateInfos[i]);\n',
734 '// shader stages array\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]735 'pNonConst->pStages = (VkPipelineShaderStageCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pStages);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]736 'for (j = 0; j < pPacket->pCreateInfos[i].stageCount; j++)\n',
737 '{\n',
738 ' interpret_VkPipelineShaderStageCreateInfo(pHeader, (VkPipelineShaderStageCreateInfo*)&pPacket->pCreateInfos[i].pStages[j]);\n',
739 '}\n',
740 '// Vertex Input State\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]741 'pNonConst->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pVertexInputState);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]742 'VkPipelineVertexInputStateCreateInfo* pNonConstVIState = (VkPipelineVertexInputStateCreateInfo*)pNonConst->pVertexInputState;\n',
743 'if (pNonConstVIState) {\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]744 ' pNonConstVIState->pVertexBindingDescriptions = (const VkVertexInputBindingDescription*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions);\n',
745 ' pNonConstVIState->pVertexAttributeDescriptions = (const VkVertexInputAttributeDescription*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pVertexInputState->pVertexAttributeDescriptions);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]746 '}\n',
747 '// Input Assembly State\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]748 'pNonConst->pInputAssemblyState = (const VkPipelineInputAssemblyStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pInputAssemblyState);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]749 '// Tesselation State\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]750 'pNonConst->pTessellationState = (const VkPipelineTessellationStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pTessellationState);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]751 '// Viewport State\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]752 'pNonConst->pViewportState = (const VkPipelineViewportStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pViewportState);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]753 '// Raster State\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]754 'pNonConst->pRasterizationState = (const VkPipelineRasterizationStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pRasterizationState);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]755 '// MultiSample State\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]756 'pNonConst->pMultisampleState = (const VkPipelineMultisampleStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pMultisampleState);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]757 '// DepthStencil State\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]758 'pNonConst->pDepthStencilState = (const VkPipelineDepthStencilStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pDepthStencilState);\n',
Courtney Goeltzenleuchter1c9f9892015-09-30 16:08:38 -0600[diff] [blame]759 '// DynamicState State\n',
760 'pNonConst->pDynamicState = (const VkPipelineDynamicStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pDynamicState);\n',
761 'VkPipelineDynamicStateCreateInfo* pNonConstDyState = (VkPipelineDynamicStateCreateInfo*)pNonConst->pDynamicState;\n',
762 'if (pNonConstDyState) {\n',
763 ' pNonConstDyState->pDynamicStates = (const VkDynamicState*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pDynamicState->pDynamicStates);\n',
764 '}\n',
765
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]766 '// ColorBuffer State\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]767 'pNonConst->pColorBlendState = (const VkPipelineColorBlendStateCreateInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pColorBlendState);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]768 'VkPipelineColorBlendStateCreateInfo* pNonConstCbState = (VkPipelineColorBlendStateCreateInfo*)pNonConst->pColorBlendState;\n',
769 'if (pNonConstCbState)\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]770 ' pNonConstCbState->pAttachments = (const VkPipelineColorBlendAttachmentState*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfos[i].pColorBlendState->pAttachments);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]771 '} else {\n',
772 ' // This is unexpected.\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]773 ' vktrace_LogError("CreateGraphicsPipelines must have CreateInfo stype of VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.");\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]774 ' pPacket->header = NULL;\n',
775 '}\n',
776 '}\n']
777 # TODO : This code is now too large and complex, need to make codegen smarter for pointers embedded in struct params to handle those cases automatically
778 # TODO138 : Just ripped out a bunch of custom code here that was out of date. Need to scrub these function and verify they're correct
Chia-I Wu062ad152015-10-31 00:31:16 +0800[diff] [blame]779 custom_case_dict = { #'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['VkFramebufferCreateInfo* pInfo = (VkFramebufferCreateInfo*)pPacket->pCreateInfo;\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]780 # 'pInfo->pColorAttachments = (VkColorAttachmentBindInfo*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',
781 # 'pInfo->pDepthStencilAttachment = (VkDepthStencilBindInfo*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]782 'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': create_rp_interp},
783 'CreatePipelineLayout' : {'param': 'pCreateInfo', 'txt': ['VkPipelineLayoutCreateInfo* pInfo = (VkPipelineLayoutCreateInfo*)pPacket->pCreateInfo;\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]784 'pInfo->pSetLayouts = (VkDescriptorSetLayout*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pSetLayouts);\n']},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]785 'CreateDescriptorPool' : {'param': 'pCreateInfo', 'txt': ['VkDescriptorPoolCreateInfo* pInfo = (VkDescriptorPoolCreateInfo*)pPacket->pCreateInfo;\n',
Chia-I Wuc51b1212015-10-27 19:25:11 +0800[diff] [blame]786 'pInfo->pPoolSizes = (VkDescriptorPoolSize*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pPoolSizes);\n']},
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]787 'CmdWaitEvents' : {'param': 'ppMemoryBarriers', 'txt': mem_barrier_interp},
788 'CmdPipelineBarrier' : {'param': 'ppMemoryBarriers', 'txt': mem_barrier_interp},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]789 'CreateDescriptorSetLayout' : {'param': 'pCreateInfo', 'txt': ['if (pPacket->pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) {\n',
790 ' VkDescriptorSetLayoutCreateInfo* pNext = (VkDescriptorSetLayoutCreateInfo*)pPacket->pCreateInfo;\n',
791 ' do\n',' {\n',
792 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
793 ' void** ppNextVoidPtr = (void**)&(pNext->pNext);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]794 ' *ppNextVoidPtr = (void*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]795 ' switch(pNext->sType)\n', ' {\n',
796 ' case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:\n',
797 ' {\n' ,
798 ' unsigned int i = 0;\n',
Chia-I Wuf03cbf72015-10-31 00:31:16 +0800[diff] [blame]799 ' pNext->pBinding = (VkDescriptorSetLayoutBinding*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pBinding);\n',
Chia-I Wu763a7492015-10-26 20:48:51 +0800[diff] [blame]800 ' for (i = 0; i < pNext->bindingCount; i++)\n',' {\n',
Chia-I Wuf03cbf72015-10-31 00:31:16 +0800[diff] [blame]801 ' VkSampler** ppSamplers = (VkSampler**)&(pNext->pBinding[i].pImmutableSamplers);\n',
802 ' *ppSamplers = (VkSampler*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pBinding[i].pImmutableSamplers);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]803 ' }\n',
804 ' break;\n',
805 ' }\n',
806 ' default:\n',
807 ' {\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]808 ' vktrace_LogError("Encountered an unexpected type in descriptor set layout create list.");\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]809 ' pPacket->header = NULL;\n',
810 ' pNext->pNext = NULL;\n',
811 ' }\n',
812 ' }\n',
813 ' pNext = (VkDescriptorSetLayoutCreateInfo*)pNext->pNext;\n',
814 ' } while (NULL != pNext);\n',
815 '} else {\n',
816 ' // This is unexpected.\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]817 ' vktrace_LogError("CreateDescriptorSetLayout must have pCreateInfo->stype of VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO.");\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]818 ' pPacket->header = NULL;\n',
819 '}']},
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]820# 'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['if (pPacket->pBeginInfo->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO) {\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]821# ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]822# ' VkCommandBufferGraphicsBeginInfo** ppNext = (VkCommandBufferGraphicsBeginInfo**)&(pPacket->pBeginInfo->pNext);\n',
823# ' *ppNext = (VkCommandBufferGraphicsBeginInfo*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',
824# ' VkCommandBufferGraphicsBeginInfo* pNext = *ppNext;\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]825# ' while (NULL != pNext)\n', ' {\n',
826# ' switch(pNext->sType)\n', ' {\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]827# ' case VK_STRUCTURE_TYPE_COMMAND_BUFFER_GRAPHICS_BEGIN_INFO:\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]828# ' {\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]829# ' ppNext = (VkCommandBufferGraphicsBeginInfo**) &pNext->pNext;\n',
830# ' *ppNext = (VkCommandBufferGraphicsBeginInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]831# ' break;\n',
832# ' }\n',
833# ' default:\n',
834# ' {\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]835# ' vktrace_LogError("Encountered an unexpected type in begin command buffer list.");\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]836# ' pPacket->header = NULL;\n',
837# ' pNext->pNext = NULL;\n',
838# ' }\n',
839# ' }\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]840# ' pNext = (VkCommandBufferGraphicsBeginInfo*)pNext->pNext;\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]841# ' }\n',
842# '} else {\n',
843# ' // This is unexpected.\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]844# ' vktrace_LogError("BeginCommandBuffer must have BeginInfo stype of VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO.");\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]845# ' pPacket->header = NULL;\n',
846# '}']},
Chia-I Wuc1f5e402015-11-10 16:21:09 +0800[diff] [blame]847 'AllocateMemory' : {'param': 'pAllocateInfo', 'txt': ['if (pPacket->pAllocateInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO) {\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]848 ' VkMemoryAllocateInfo** ppNext = (VkMemoryAllocateInfo**) &(pPacket->pAllocateInfo->pNext);\n',
849 ' *ppNext = (VkMemoryAllocateInfo*) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocateInfo->pNext);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]850 '} else {\n',
851 ' // This is unexpected.\n',
Chia-I Wuc1f5e402015-11-10 16:21:09 +0800[diff] [blame]852 ' vktrace_LogError("AllocateMemory must have AllocInfo stype of VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO.");\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]853 ' pPacket->header = NULL;\n',
854 '}']},
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]855 'AllocateDescriptorSets' : {'param': 'pAllocateInfo', 'txt':
856 ['VkDescriptorSetLayout **ppDescSetLayout = (VkDescriptorSetLayout **) &pPacket->pAllocateInfo->pSetLayouts;\n'
857 ' *ppDescSetLayout = (VkDescriptorSetLayout *) vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pAllocateInfo->pSetLayouts));']},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]858 'UpdateDescriptorSets' : {'param': 'pDescriptorWrites', 'txt':
859 [ 'uint32_t i;\n',
Chia-I Wu483e7702015-10-26 17:20:32 +0800[diff] [blame]860 'for (i = 0; i < pPacket->descriptorWriteCount; i++) {\n',
Courtney Goeltzenleuchter34aa5c82015-10-23 13:38:14 -0600[diff] [blame]861 ' switch (pPacket->pDescriptorWrites[i].descriptorType) {',
862 ' case VK_DESCRIPTOR_TYPE_SAMPLER:',
863 ' case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:',
864 ' case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:',
865 ' case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:',
866 ' {',
867 ' VkDescriptorImageInfo** ppImageInfo = (VkDescriptorImageInfo**)&pPacket->pDescriptorWrites[i].pImageInfo;\n',
868 ' *ppImageInfo = (VkDescriptorImageInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDescriptorWrites[i].pImageInfo);\n',
869 ' }',
870 ' break;',
871 ' case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:',
872 ' case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:',
873 ' {',
874 ' VkBufferView** ppTexelBufferView = (VkBufferView**)&pPacket->pDescriptorWrites[i].pTexelBufferView;\n',
875 ' *ppTexelBufferView = (VkBufferView*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDescriptorWrites[i].pTexelBufferView);\n',
876 ' }',
877 ' break;',
878 ' case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:',
879 ' case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:',
880 ' case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:',
881 ' case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:',
882 ' {',
883 ' VkDescriptorBufferInfo** ppBufferInfo = (VkDescriptorBufferInfo**)&pPacket->pDescriptorWrites[i].pBufferInfo;\n',
884 ' *ppBufferInfo = (VkDescriptorBufferInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDescriptorWrites[i].pBufferInfo);\n',
885 ' }',
886 ' break;',
887 ' default:',
888 ' break;',
889 ' }',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]890 '}'
891 ]},
Chia-I Wu483e7702015-10-26 17:20:32 +0800[diff] [blame]892 'QueueSubmit' : {'param': 'pSubmits', 'txt':
Courtney Goeltzenleuchter3ec31622015-10-20 18:04:07 -0600[diff] [blame]893 [ 'uint32_t i;\n',
894 'for (i = 0; i < pPacket->submitCount; i++) {\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]895 ' VkCommandBuffer** ppCBs = (VkCommandBuffer**)&pPacket->pSubmits[i].pCommandBuffers;\n',
896 ' *ppCBs = (VkCommandBuffer*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSubmits[i].pCommandBuffers);\n',
Chia-I Wu483e7702015-10-26 17:20:32 +0800[diff] [blame]897 ' VkSemaphore** ppSems = (VkSemaphore**)&pPacket->pSubmits[i].pWaitSemaphores;\n',
898 ' *ppSems = (VkSemaphore*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSubmits[i].pWaitSemaphores);\n',
899 ' ppSems = (VkSemaphore**)&pPacket->pSubmits[i].pSignalSemaphores;\n',
900 ' *ppSems = (VkSemaphore*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSubmits[i].pSignalSemaphores);\n',
Courtney Goeltzenleuchter3ec31622015-10-20 18:04:07 -0600[diff] [blame]901 '}'
902 ]},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]903 'CreateGraphicsPipelines' : {'param': 'pCreateInfos', 'txt': create_gfx_pipe},
904 'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_VkPipelineShaderStageCreateInfo(pHeader, (VkPipelineShaderStageCreateInfo*)(&pPacket->pCreateInfo->cs));']},
Courtney Goeltzenleuchter1856d6f2015-09-01 17:30:39 -0600[diff] [blame]905 'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['VkImageView** ppAV = (VkImageView**)&(pPacket->pCreateInfo->pAttachments);\n',
906 '*ppAV = (VkImageView*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pCreateInfo->pAttachments));']},
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]907 'CmdBeginRenderPass' : {'param': 'pRenderPassBegin', 'txt': ['VkClearValue** ppCV = (VkClearValue**)&(pPacket->pRenderPassBegin->pClearValues);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]908 '*ppCV = (VkClearValue*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pRenderPassBegin->pClearValues));']},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]909 'CreateShaderModule' : {'param': 'pCreateInfo', 'txt': ['void** ppCode = (void**)&(pPacket->pCreateInfo->pCode);\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]910 '*ppCode = (void*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]911 'FlushMappedMemoryRanges' : {'param': 'ppData', 'txt': ['uint32_t i = 0;\n',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]912 'for (i = 0; i < pPacket->memoryRangeCount; i++)\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]913 '{\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]914 ' pPacket->ppData[i] = (void*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->ppData[i]);\n',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]915 '}']}}
916 if_body = []
917 if_body.append('typedef struct packet_vkApiVersion {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]918 if_body.append(' vktrace_trace_packet_header* header;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]919 if_body.append(' uint32_t version;')
920 if_body.append('} packet_vkApiVersion;\n')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]921 if_body.append('static packet_vkApiVersion* interpret_body_as_vkApiVersion(vktrace_trace_packet_header* pHeader)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]922 if_body.append('{')
923 if_body.append(' packet_vkApiVersion* pPacket = (packet_vkApiVersion*)pHeader->pBody;')
924 if_body.append(' pPacket->header = pHeader;')
925 if_body.append(' return pPacket;')
926 if_body.append('}\n')
927 for proto in self.protos:
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]928 if 'KHR' not in proto.name and 'Dbg' not in proto.name:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]929 if 'UnmapMemory' == proto.name:
930 proto.params.append(vulkan.Param("void*", "pData"))
931 elif 'FlushMappedMemoryRanges' == proto.name:
932 proto.params.append(vulkan.Param("void**", "ppData"))
933 if_body.append('%s' % self.lineinfo.get())
934 if_body.append('typedef struct packet_vk%s {' % proto.name)
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]935 if_body.append(' vktrace_trace_packet_header* header;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]936 for p in proto.params:
Chia-I Wua5cd6532015-10-28 18:31:57 +0800[diff] [blame]937 if_body.append(' %s;' % p.c())
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]938 if 'void' != proto.ret:
939 if_body.append(' %s result;' % proto.ret)
940 if_body.append('} packet_vk%s;\n' % proto.name)
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]941 if_body.append('static packet_vk%s* interpret_body_as_vk%s(vktrace_trace_packet_header* pHeader)' % (proto.name, proto.name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]942 if_body.append('{')
943 if_body.append(' packet_vk%s* pPacket = (packet_vk%s*)pHeader->pBody;' % (proto.name, proto.name))
944 if_body.append(' pPacket->header = pHeader;')
945 for p in proto.params:
946 if '*' in p.ty:
947 if 'DeviceCreateInfo' in p.ty:
948 if_body.append(' pPacket->%s = interpret_VkDeviceCreateInfo(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))
949 elif 'InstanceCreateInfo' in p.ty:
950 if_body.append(' pPacket->%s = interpret_VkInstanceCreateInfo(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))
951 else:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]952 if_body.append(' pPacket->%s = (%s)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]953 # TODO : Generalize this custom code to kill dict data struct above.
954 # Really the point of this block is to catch params w/ embedded ptrs to structs and chains of structs
955 if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
956 if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])
957 if_body.append(' {')
958 if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))
959 if_body.append(' }')
960 if_body.append(' return pPacket;')
961 if_body.append('}\n')
962 return "\n".join(if_body)
963
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]964 def _generate_interp_funcs_ext(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]965 if_body = []
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]966 custom_case_dict = { 'QueuePresentKHR' : {'param': 'pPresentInfo', 'txt': ['pPacket->pPresentInfo->swapchains = (VkSwapchainKHR*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pPresentInfo->swapchains));\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]967 'pPacket->pPresentInfo->imageIndices = (uint32_t*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pPresentInfo->imageIndices));']},
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]968 'CreateSwapchainKHR' : {'param': 'pCreateInfo', 'txt': ['VkSurfaceDescriptionKHR **ppSurfDescp = (VkSurfaceDescriptionKHR**)&pPacket->pCreateInfo->pSurfaceDescription;\n',
Jon Ashburnc51afc72015-08-11 16:01:35 -0600[diff] [blame]969 'uint32_t **ppQFI = (uint32_t**)&pPacket->pCreateInfo->pQueueFamilyIndices;\n',
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]970 '(*ppSurfDescp) = (VkSurfaceDescriptionKHR*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pCreateInfo->pSurfaceDescription));\n',
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]971 '(*ppQFI) = (uint32_t*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pPacket->pCreateInfo->pQueueFamilyIndices));']},
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]972 }
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]973 for ext in vulkan.extensions_all:
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]974 if ext.name.lower() == extensionName.lower():
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]975 for proto in ext.protos:
976 if_body.append('typedef struct packet_vk%s {' % proto.name)
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]977 if_body.append(' vktrace_trace_packet_header* pHeader;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]978 for p in proto.params:
Chia-I Wua5cd6532015-10-28 18:31:57 +0800[diff] [blame]979 if_body.append(' %s;' % p.c())
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]980 if 'void' != proto.ret:
981 if_body.append(' %s result;' % proto.ret)
982 if_body.append('} packet_vk%s;\n' % proto.name)
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]983 if_body.append('static packet_vk%s* interpret_body_as_vk%s(vktrace_trace_packet_header* pHeader)' % (proto.name, proto.name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]984 if_body.append('{')
985 if_body.append(' packet_vk%s* pPacket = (packet_vk%s*)pHeader->pBody;' % (proto.name, proto.name))
986 if_body.append(' pPacket->pHeader = pHeader;')
987 for p in proto.params:
988 if '*' in p.ty:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]989 if_body.append(' pPacket->%s = (%s)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]990 # TODO : Generalize this custom code to kill dict data struct above.
991 # Really the point of this block is to catch params w/ embedded ptrs to structs and chains of structs
992 if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
993 if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])
994 if_body.append(' {')
995 if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))
996 if_body.append(' }')
997 if_body.append(' return pPacket;')
998 if_body.append('}\n')
999 return "\n".join(if_body)
1000
1001 def _generate_replay_func_ptrs(self):
1002 xf_body = []
1003 xf_body.append('struct vkFuncs {')
1004 xf_body.append(' void init_funcs(void * libHandle);')
1005 xf_body.append(' void *m_libHandle;\n')
1006 for proto in self.protos:
Chia-I Wuaf9e4fd2015-11-06 06:42:02 +0800[diff] [blame]1007 xf_body.append(' typedef %s( VKAPI_PTR * type_vk%s)(' % (proto.ret, proto.name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1008 for p in proto.params:
Chia-I Wua5cd6532015-10-28 18:31:57 +0800[diff] [blame]1009 xf_body.append(' %s,' % p.c())
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1010 xf_body[-1] = xf_body[-1].replace(',', ');')
1011 xf_body.append(' type_vk%s real_vk%s;' % (proto.name, proto.name))
1012 xf_body.append('};')
1013 return "\n".join(xf_body)
1014
1015 def _map_decl(self, type1, type2, name):
1016 return ' std::map<%s, %s> %s;' % (type1, type2, name)
1017
1018 def _add_to_map_decl(self, type1, type2, name):
1019 txt = ' void add_to_%s_map(%s pTraceVal, %s pReplayVal)\n {\n' % (name[2:], type1, type2)
1020 #TODO138 : These checks need to vary between disp & non-disp objects
1021 #txt += ' assert(pTraceVal != 0);\n'
1022 #txt += ' assert(pReplayVal != 0);\n'
1023 txt += ' %s[pTraceVal] = pReplayVal;\n }\n' % name
1024 return txt
1025
1026 def _rm_from_map_decl(self, ty, name):
1027 txt = ' void rm_from_%s_map(const %s& key)\n {\n' % (name[2:], ty)
1028 txt += ' %s.erase(key);\n }\n' % name
1029 return txt
1030
1031 def _remap_decl(self, ty, name):
1032 txt = ' %s remap_%s(const %s& value)\n {\n' % (ty, name[2:], ty)
1033 txt += ' if (value == 0) { return 0; }\n'
1034 txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1035 txt += ' if (q == %s.end()) { vktrace_LogError("Failed to remap %s."); return value; }\n' % (name, ty)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1036 txt += ' return q->second;\n }\n'
1037 return txt
1038
1039 def _generate_replay_objMemory_funcs(self):
1040 rof_body = []
1041 # Custom code for memory mapping functions for app writes into mapped memory
1042 rof_body.append('// memory mapping functions for app writes into mapped memory')
1043 rof_body.append(' bool isPendingAlloc()')
1044 rof_body.append(' {')
1045 rof_body.append(' return m_pendingAlloc;')
1046 rof_body.append(' }')
1047 rof_body.append('')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1048 rof_body.append(' void setAllocInfo(const VkMemoryAllocateInfo *info, const bool pending)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1049 rof_body.append(' {')
1050 rof_body.append(' m_pendingAlloc = pending;')
1051 rof_body.append(' m_allocInfo = *info;')
1052 rof_body.append(' }')
1053 rof_body.append('')
1054 rof_body.append(' void setMemoryDataAddr(void *pBuf)')
1055 rof_body.append(' {')
1056 rof_body.append(' if (m_mapRange.empty())')
1057 rof_body.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1058 rof_body.append(' vktrace_LogError("gpuMemory::setMemoryDataAddr() m_mapRange is empty.");')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1059 rof_body.append(' return;')
1060 rof_body.append(' }')
1061 rof_body.append(' MapRange mr = m_mapRange.back();')
1062 rof_body.append(' if (mr.pData != NULL)')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1063 rof_body.append(' vktrace_LogWarning("gpuMemory::setMemoryDataAddr() data already mapped overwrite old mapping.");')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1064 rof_body.append(' else if (pBuf == NULL)')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1065 rof_body.append(' vktrace_LogWarning("gpuMemory::setMemoryDataAddr() adding NULL pointer.");')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1066 rof_body.append(' mr.pData = (uint8_t *) pBuf;')
1067 rof_body.append(' }')
1068 rof_body.append('')
1069 rof_body.append(' void setMemoryMapRange(void *pBuf, const size_t size, const size_t offset, const bool pending)')
1070 rof_body.append(' {')
1071 rof_body.append(' MapRange mr;')
1072 rof_body.append(' mr.pData = (uint8_t *) pBuf;')
1073 rof_body.append(' if (size == 0)')
1074 rof_body.append(' mr.size = m_allocInfo.allocationSize - offset;')
1075 rof_body.append(' else')
1076 rof_body.append(' mr.size = size;')
1077 rof_body.append(' mr.offset = offset;')
1078 rof_body.append(' mr.pending = pending;')
1079 rof_body.append(' m_mapRange.push_back(mr);')
1080 rof_body.append(' assert(m_allocInfo.allocationSize >= (size + offset));')
1081 rof_body.append(' }')
1082 rof_body.append('')
1083 rof_body.append(' void copyMappingData(const void* pSrcData, bool entire_map, size_t size, size_t offset)')
1084 rof_body.append(' {')
1085 rof_body.append(' if (m_mapRange.empty())')
1086 rof_body.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1087 rof_body.append(' vktrace_LogError("gpuMemory::copyMappingData() m_mapRange is empty.");')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1088 rof_body.append(' return;')
1089 rof_body.append(' }')
1090 rof_body.append(' MapRange mr = m_mapRange.back();')
1091 rof_body.append(' if (!pSrcData || !mr.pData)')
1092 rof_body.append(' {')
1093 rof_body.append(' if (!pSrcData)')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1094 rof_body.append(' vktrace_LogError("gpuMemory::copyMappingData() null src pointer.");')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1095 rof_body.append(' else')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1096 rof_body.append(' vktrace_LogError("gpuMemory::copyMappingData() null dest pointer totalSize=%u.", m_allocInfo.allocationSize);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1097 rof_body.append(' m_mapRange.pop_back();')
1098 rof_body.append(' return;')
1099 rof_body.append(' }')
1100 rof_body.append(' if (entire_map)')
1101 rof_body.append(' {')
1102 rof_body.append(' size = mr.size;')
1103 rof_body.append(' offset = mr.offset;')
1104 rof_body.append(' }')
1105 rof_body.append(' else')
1106 rof_body.append(' {')
1107 rof_body.append(' assert(offset >= mr.offset);')
1108 rof_body.append(' assert(size <= mr.size && (size + offset) <= mr.size);')
1109 rof_body.append(' }')
1110 rof_body.append(' memcpy(mr.pData + offset, pSrcData, size);')
1111 rof_body.append(' if (!mr.pending && entire_map)')
1112 rof_body.append(' m_mapRange.pop_back();')
1113 rof_body.append(' }')
1114 rof_body.append('')
1115 rof_body.append(' size_t getMemoryMapSize()')
1116 rof_body.append(' {')
1117 rof_body.append(' return (!m_mapRange.empty()) ? m_mapRange.back().size : 0;')
1118 rof_body.append(' }\n')
1119 return "\n".join(rof_body)
1120
1121 def _generate_replay_objmapper_class(self):
1122 # Create dict mapping member var names to VK type (i.e. 'm_imageViews' : 'VkImage_VIEW')
1123 obj_map_dict = {}
1124 for obj in vulkan.object_type_list:
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1125 if (obj.startswith('Vk')):
1126 mem_var = obj.replace('Vk', '').lower()
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1127 mem_var_list = mem_var.split('_')
1128 mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1129 obj_map_dict[mem_var] = obj
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1130 rc_body = []
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1131 rc_body.append('#define VKTRACE_VK_OBJECT_TYPE_UNKNOWN (VkObjectType)-1')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1132 rc_body.append('')
1133 rc_body.append('typedef struct _VKAllocInfo {')
1134 rc_body.append(' VkDeviceSize size;')
1135 rc_body.append(' uint8_t *pData;')
1136 rc_body.append(' bool rangeUpdated;')
1137 rc_body.append('} VKAllocInfo;')
1138 rc_body.append('')
1139 rc_body.append('class objMemory {')
1140 rc_body.append('public:')
1141 rc_body.append(' objMemory() : m_numAllocations(0), m_pMemReqs(NULL) {}')
1142 rc_body.append(' ~objMemory() { free(m_pMemReqs);}')
1143 rc_body.append(' void setCount(const uint32_t num)')
1144 rc_body.append(' {')
1145 rc_body.append(' m_numAllocations = num;')
1146 rc_body.append(' }\n')
1147 rc_body.append(' void setReqs(const VkMemoryRequirements *pReqs, const uint32_t num)')
1148 rc_body.append(' {')
1149 rc_body.append(' if (m_numAllocations != num && m_numAllocations != 0)')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1150 rc_body.append(' vktrace_LogError("objMemory::setReqs, internal mismatch on number of allocations.");')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1151 rc_body.append(' if (m_pMemReqs == NULL && pReqs != NULL)')
1152 rc_body.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1153 rc_body.append(' m_pMemReqs = (VkMemoryRequirements *) vktrace_malloc(num * sizeof(VkMemoryRequirements));')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1154 rc_body.append(' if (m_pMemReqs == NULL)')
1155 rc_body.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1156 rc_body.append(' vktrace_LogError("objMemory::setReqs out of memory.");')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1157 rc_body.append(' return;')
1158 rc_body.append(' }')
1159 rc_body.append(' memcpy(m_pMemReqs, pReqs, num * sizeof(VkMemoryRequirements));')
1160 rc_body.append(' }')
1161 rc_body.append(' }\n')
1162 rc_body.append('private:')
1163 rc_body.append(' uint32_t m_numAllocations;')
1164 rc_body.append(' VkMemoryRequirements *m_pMemReqs;')
1165 rc_body.append('};')
1166 rc_body.append('')
1167 rc_body.append('class gpuMemory {')
1168 rc_body.append('public:')
1169 rc_body.append(' gpuMemory() : m_pendingAlloc(false) {m_allocInfo.allocationSize = 0;}')
1170 rc_body.append(' ~gpuMemory() {}')
1171 rc_body.append(self._generate_replay_objMemory_funcs())
1172 rc_body.append('private:')
1173 rc_body.append(' bool m_pendingAlloc;')
1174 rc_body.append(' struct MapRange {')
1175 rc_body.append(' bool pending;')
1176 rc_body.append(' size_t size;')
1177 rc_body.append(' size_t offset;')
1178 rc_body.append(' uint8_t* pData;')
1179 rc_body.append(' };')
1180 rc_body.append(' std::vector<MapRange> m_mapRange;')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1181 rc_body.append(' VkMemoryAllocateInfo m_allocInfo;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1182 rc_body.append('};')
1183 rc_body.append('')
1184 rc_body.append('typedef struct _imageObj {')
1185 rc_body.append(' objMemory imageMem;')
1186 rc_body.append(' VkImage replayImage;')
1187 rc_body.append(' } imageObj;')
1188 rc_body.append('')
1189 rc_body.append('typedef struct _bufferObj {')
1190 rc_body.append(' objMemory bufferMem;')
1191 rc_body.append(' VkBuffer replayBuffer;')
1192 rc_body.append(' } bufferObj;')
1193 rc_body.append('')
1194 rc_body.append('typedef struct _gpuMemObj {')
1195 rc_body.append(' gpuMemory *pGpuMem;')
1196 rc_body.append(' VkDeviceMemory replayGpuMem;')
1197 rc_body.append(' } gpuMemObj;')
1198 rc_body.append('')
1199 rc_body.append('')
1200 rc_body.append('class vkReplayObjMapper {')
1201 rc_body.append('public:')
1202 rc_body.append(' vkReplayObjMapper() {}')
1203 rc_body.append(' ~vkReplayObjMapper() {}')
1204 rc_body.append('')
1205 rc_body.append(' bool m_adjustForGPU; // true if replay adjusts behavior based on GPU')
1206 # Code for memory objects for handling replay GPU != trace GPU object memory requirements
1207 rc_body.append('void init_objMemCount(const uint64_t handle, const VkDbgObjectType objectType, const uint32_t &num)\n {')
1208 rc_body.append(' switch (objectType) {')
1209 rc_body.append(' case VK_OBJECT_TYPE_BUFFER:')
1210 rc_body.append(' {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1211 rc_body.append(' std::map<VkBuffer, bufferObj>::iterator it = m_buffers.find((VkBuffer) handle);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1212 rc_body.append(' if (it != m_buffers.end()) {')
1213 rc_body.append(' objMemory obj = it->second.bufferMem;')
1214 rc_body.append(' obj.setCount(num);')
1215 rc_body.append(' return;')
1216 rc_body.append(' }')
1217 rc_body.append(' break;')
1218 rc_body.append(' }')
1219 rc_body.append(' case VK_OBJECT_TYPE_IMAGE:')
1220 rc_body.append(' {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1221 rc_body.append(' std::map<VkImage, imageObj>::iterator it = m_images.find((VkImage) handle);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1222 rc_body.append(' if (it != m_images.end()) {')
1223 rc_body.append(' objMemory obj = it->second.imageMem;')
1224 rc_body.append(' obj.setCount(num);')
1225 rc_body.append(' return;')
1226 rc_body.append(' }')
1227 rc_body.append(' break;')
1228 rc_body.append(' }')
1229 rc_body.append(' default:')
1230 rc_body.append(' break;')
1231 rc_body.append(' }')
1232 rc_body.append(' return;')
1233 rc_body.append('}\n')
1234 rc_body.append('void init_objMemReqs(const uint64_t handle, const VkDbgObjectType objectType, const VkMemoryRequirements *pMemReqs, const unsigned int num)\n {')
1235 rc_body.append(' switch (objectType) {')
1236 rc_body.append(' case VK_OBJECT_TYPE_BUFFER:')
1237 rc_body.append(' {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1238 rc_body.append(' std::map<VkBuffer, bufferObj>::iterator it = m_buffers.find((VkBuffer) handle);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1239 rc_body.append(' if (it != m_buffers.end()) {')
1240 rc_body.append(' objMemory obj = it->second.bufferMem;')
1241 rc_body.append(' obj.setReqs(pMemReqs, num);')
1242 rc_body.append(' return;')
1243 rc_body.append(' }')
1244 rc_body.append(' break;')
1245 rc_body.append(' }')
1246 rc_body.append(' case VK_OBJECT_TYPE_IMAGE:')
1247 rc_body.append(' {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1248 rc_body.append(' std::map<VkImage, imageObj>::iterator it = m_images.find((VkImage) handle);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1249 rc_body.append(' if (it != m_images.end()) {')
1250 rc_body.append(' objMemory obj = it->second.imageMem;')
1251 rc_body.append(' obj.setReqs(pMemReqs, num);')
1252 rc_body.append(' return;')
1253 rc_body.append(' }')
1254 rc_body.append(' break;')
1255 rc_body.append(' }')
1256 rc_body.append(' default:')
1257 rc_body.append(' break;')
1258 rc_body.append(' }')
1259 rc_body.append(' return;')
1260 rc_body.append(' }')
1261 rc_body.append('')
1262 rc_body.append(' void clear_all_map_handles()\n {')
1263 for var in sorted(obj_map_dict):
1264 rc_body.append(' %s.clear();' % var)
1265 rc_body.append(' }\n')
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1266 disp_obj_types = [obj for obj in vulkan.object_dispatch_list]
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1267 for var in sorted(obj_map_dict):
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1268 if obj_map_dict[var] == 'VkImage':
1269 rc_body.append(self._map_decl('VkImage', 'imageObj', var))
1270 rc_body.append(self._add_to_map_decl('VkImage', 'imageObj', var))
1271 rc_body.append(self._rm_from_map_decl('VkImage', var))
1272 rc_body.append(' VkImage remap_images(const VkImage& value)')
1273 rc_body.append(' {')
1274 rc_body.append(' if (value == 0) { return 0; }')
1275 rc_body.append('')
1276 rc_body.append(' std::map<VkImage, imageObj>::const_iterator q = m_images.find(value);')
1277 rc_body.append(' if (q == m_images.end()) { vktrace_LogError("Failed to remap VkImage."); return value; }\n')
1278 rc_body.append(' return q->second.replayImage;')
1279 rc_body.append(' }\n')
1280 elif obj_map_dict[var] == 'VkBuffer':
1281 rc_body.append(self._map_decl('VkBuffer', 'bufferObj', var))
1282 rc_body.append(self._add_to_map_decl('VkBuffer', 'bufferObj', var))
1283 rc_body.append(self._rm_from_map_decl('VkBuffer', var))
1284 rc_body.append(' VkBuffer remap_buffers(const VkBuffer& value)')
1285 rc_body.append(' {')
1286 rc_body.append(' if (value == 0) { return 0; }')
1287 rc_body.append('')
1288 rc_body.append(' std::map<VkBuffer, bufferObj>::const_iterator q = m_buffers.find(value);')
1289 rc_body.append(' if (q == m_buffers.end()) { vktrace_LogError("Failed to remap VkBuffer."); return value; }\n')
1290 rc_body.append(' return q->second.replayBuffer;')
1291 rc_body.append(' }\n')
1292 elif obj_map_dict[var] == 'VkDeviceMemory':
1293 rc_body.append(self._map_decl('VkDeviceMemory', 'gpuMemObj', var))
1294 rc_body.append(self._add_to_map_decl('VkDeviceMemory', 'gpuMemObj', var))
1295 rc_body.append(self._rm_from_map_decl('VkDeviceMemory', var))
1296 rc_body.append(' VkDeviceMemory remap_devicememorys(const VkDeviceMemory& value)')
1297 rc_body.append(' {')
1298 rc_body.append(' if (value == 0) { return 0; }')
1299 rc_body.append('')
1300 rc_body.append(' std::map<VkDeviceMemory, gpuMemObj>::const_iterator q = m_devicememorys.find(value);')
1301 rc_body.append(' if (q == m_devicememorys.end()) { vktrace_LogError("Failed to remap VkDeviceMemory."); return value; }')
1302 rc_body.append(' return q->second.replayGpuMem;')
1303 rc_body.append(' }\n')
1304 else:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1305 rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))
1306 rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))
1307 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1308 rc_body.append(self._remap_decl(obj_map_dict[var], var))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1309 # VkDynamicStateObject code
1310# TODO138 : Each dynamic state object is now unique so need to make sure their re-mapping is being handled correctly
1311# state_obj_remap_types = vulkan.object_dynamic_state_list
1312# state_obj_bindings = vulkan.object_dynamic_state_bind_point_list
1313# rc_body.append(' VkDynamicStateObject remap(const VkDynamicStateObject& state, const VkStateBindPoint& bindPoint)\n {')
1314# rc_body.append(' VkDynamicStateObject obj;')
1315# index = 0
1316# while index < len(state_obj_remap_types):
1317# obj = state_obj_remap_types[index]
1318# type = state_obj_bindings[index]
1319# rc_body.append(' if (bindPoint == %s) {' % type)
1320# rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != VK_NULL_HANDLE)' % obj.type)
1321# rc_body.append(' return obj;')
1322# rc_body.append(' }')
1323# index += 1
1324# for obj in state_obj_remap_types:
1325# rc_body.append('// if ((obj = remap(static_cast <%s> (state))) != VK_NULL_HANDLE)' % obj.type)
1326# rc_body.append('// return obj;')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1327# rc_body.append(' vktrace_LogWarning("Failed to remap VkDynamicStateObject.");')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1328# rc_body.append(' return VK_NULL_HANDLE;\n }')
1329# rc_body.append(' void rm_from_map(const VkDynamicStateObject& state)\n {')
1330# for obj in state_obj_remap_types:
1331# rc_body.append(' rm_from_map(static_cast <%s> (state));' % obj.type)
1332# rc_body.append(' }')
1333# rc_body.append('')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1334 rc_body.append('};')
1335 return "\n".join(rc_body)
1336
1337 def _generate_replay_init_funcs(self):
1338 rif_body = []
1339 rif_body.append('void vkFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')
1340 for proto in self.protos:
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1341 if 'KHR' not in proto.name and 'Dbg' not in proto.name:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1342 rif_body.append(' real_vk%s = (type_vk%s)(vktrace_platform_get_library_entrypoint(handle, "vk%s"));' % (proto.name, proto.name, proto.name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1343 else: # These func ptrs get assigned at GetProcAddr time
1344 rif_body.append(' real_vk%s = (type_vk%s)NULL;' % (proto.name, proto.name))
1345 rif_body.append('}')
1346 return "\n".join(rif_body)
1347
Jon Ashburnc736c002015-10-25 20:24:57 -0600[diff] [blame]1348 def _remap_packet_param(self, funcName, paramType, paramName, lastName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1349 remap_list = vulkan.object_type_list
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1350 param_exclude_list = ['pDescriptorSets', 'pFences']
1351 cleanParamType = paramType.strip('*').replace('const ', '')
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1352 VulkNonDispObjects = [o for o in vulkan.object_non_dispatch_list]
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1353 for obj in remap_list:
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1354 if obj == cleanParamType and paramName not in param_exclude_list:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1355 objectTypeRemapParam = ''
1356 if 'VkDynamicStateObject' == cleanParamType:
1357 objectTypeRemapParam = ', pPacket->stateBindPoint'
1358 elif 'object' == paramName:
1359 if 'DbgSetObjectTag' == funcName:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1360 objectTypeRemapParam = ', VKTRACE_VK_OBJECT_TYPE_UNKNOWN'
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1361 else:
1362 objectTypeRemapParam = ', pPacket->objType'
1363 elif 'srcObject' == paramName and 'Callback' in funcName:
1364 objectTypeRemapParam = ', pPacket->objType'
Jon Ashburnc736c002015-10-25 20:24:57 -0600[diff] [blame]1365 pArray = ''
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1366 if '*' in paramType:
Jon Ashburnc736c002015-10-25 20:24:57 -0600[diff] [blame]1367 if 'const' not in paramType:
1368 result = ' %s remapped%s = m_objMapper.remap_%ss(*pPacket->%s%s);\n' % (cleanParamType, paramName, paramName.lower(), paramName, objectTypeRemapParam)
1369 result += ' if (pPacket->%s != VK_NULL_HANDLE && remapped%s == VK_NULL_HANDLE)\n' % (paramName, paramName)
1370 result += ' {\n'
1371 result += ' return vktrace_replay::VKTRACE_REPLAY_ERROR;\n'
1372 result += ' }\n'
1373 return result
1374 else:
1375 if lastName == '':
1376 return ' // pPacket->%s should have been remapped with special case code' % (paramName)
1377 pArray = '[pPacket->%s]' % lastName
Courtney Goeltzenleuchter5970b252015-10-27 11:32:31 -0600[diff] [blame]1378 result = ' %s *remapped%s = new %s%s;\n' % (cleanParamType, paramName, cleanParamType, pArray)
Jon Ashburnc736c002015-10-25 20:24:57 -0600[diff] [blame]1379 result += '%s\n' % self.lineinfo.get()
1380 result += ' for (uint32_t i = 0; i < pPacket->%s; i++) {\n' % lastName
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1381 result += ' remapped%s[i] = m_objMapper.remap_%ss(pPacket->%s[i]%s);\n' % (paramName, cleanParamType.lower()[2:], paramName, objectTypeRemapParam)
1382 result += ' if (pPacket->%s[i] != VK_NULL_HANDLE && remapped%s[i] == VK_NULL_HANDLE)\n' % (paramName, paramName)
Jon Ashburnc736c002015-10-25 20:24:57 -0600[diff] [blame]1383 result += ' {\n'
1384 result += ' return vktrace_replay::VKTRACE_REPLAY_ERROR;\n'
1385 result += ' }\n'
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1386 result += ' }\n'
1387 return result
Jon Ashburnc736c002015-10-25 20:24:57 -0600[diff] [blame]1388
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1389 result = ' %s remapped%s = m_objMapper.remap_%ss(pPacket->%s%s);\n' % (paramType, paramName, cleanParamType.lower()[2:], paramName, objectTypeRemapParam)
1390 result += '%s\n' % self.lineinfo.get()
1391 result += ' if (pPacket->%s != VK_NULL_HANDLE && remapped%s == VK_NULL_HANDLE)\n' % (paramName, paramName)
1392 result += ' {\n'
1393 result += ' return vktrace_replay::VKTRACE_REPLAY_ERROR;\n'
1394 result += ' }\n'
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1395 return result
1396 return ' // No need to remap %s' % (paramName)
1397
1398 def _get_packet_param(self, funcName, paramType, paramName):
1399 # list of types that require remapping
1400 remap_list = vulkan.object_type_list
1401 param_exclude_list = ['pDescriptorSets', 'pFences']
1402 cleanParamType = paramType.strip('*').replace('const ', '')
1403 for obj in remap_list:
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1404 if obj == cleanParamType and paramName not in param_exclude_list:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1405 objectTypeRemapParam = ''
1406 if 'object' == paramName:
1407 if 'DbgSetObjectTag' == funcName:
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1408 objectTypeRemapParam = ', VKTRACE_VK_OBJECT_TYPE_UNKNOWN'
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1409 else:
1410 objectTypeRemapParam = ', pPacket->objType'
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1411 return 'remapped%s' % (paramName)
1412 return 'pPacket->%s' % (paramName)
1413
1414 def _gen_replay_create_image(self):
1415 ci_body = []
1416 ci_body.append(' imageObj local_imageObj;')
1417 ci_body.append(' VkDevice remappedDevice = m_objMapper.remap_devices(pPacket->device);')
1418 ci_body.append(' if (remappedDevice == VK_NULL_HANDLE)')
1419 ci_body.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1420 ci_body.append(' return vktrace_replay::VKTRACE_REPLAY_ERROR;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1421 ci_body.append(' }')
Chia-I Wu69f40122015-10-26 21:10:41 +0800[diff] [blame]1422 ci_body.append(' replayResult = m_vkFuncs.real_vkCreateImage(remappedDevice, pPacket->pCreateInfo, NULL, &local_imageObj.replayImage);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1423 ci_body.append(' if (replayResult == VK_SUCCESS)')
1424 ci_body.append(' {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1425 ci_body.append(' m_objMapper.add_to_images_map(*(pPacket->pImage), local_imageObj);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1426 ci_body.append(' }')
1427 return "\n".join(ci_body)
1428
1429 def _gen_replay_create_buffer(self):
1430 cb_body = []
1431 cb_body.append(' bufferObj local_bufferObj;')
1432 cb_body.append(' VkDevice remappedDevice = m_objMapper.remap_devices(pPacket->device);')
1433 cb_body.append(' if (remappedDevice == VK_NULL_HANDLE)')
1434 cb_body.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1435 cb_body.append(' return vktrace_replay::VKTRACE_REPLAY_ERROR;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1436 cb_body.append(' }')
Chia-I Wu69f40122015-10-26 21:10:41 +0800[diff] [blame]1437 cb_body.append(' replayResult = m_vkFuncs.real_vkCreateBuffer(remappedDevice, pPacket->pCreateInfo, NULL, &local_bufferObj.replayBuffer);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1438 cb_body.append(' if (replayResult == VK_SUCCESS)')
1439 cb_body.append(' {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1440 cb_body.append(' m_objMapper.add_to_buffers_map(*(pPacket->pBuffer), local_bufferObj);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1441 cb_body.append(' }')
1442 return "\n".join(cb_body)
1443
1444 # Generate main replay case statements where actual replay API call is dispatched based on input packet data
1445 def _generate_replay(self):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1446 manually_replay_funcs = ['AllocateMemory',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1447 'BeginCommandBuffer',
1448 'CreateDescriptorSetLayout',
1449 'CreateDevice',
1450 'CreateFramebuffer',
1451 'CreateGraphicsPipelines',
1452 'CreateInstance',
1453 'CreatePipelineLayout',
1454 'CreateRenderPass',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1455 'CmdBeginRenderPass',
1456 'CmdBindDescriptorSets',
1457 'CmdBindVertexBuffers',
1458 'CmdPipelineBarrier',
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1459 'QueuePresentKHR',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1460 'CmdWaitEvents',
1461 #'DestroyObject',
1462 'EnumeratePhysicalDevices',
1463 'FreeMemory',
1464 'FreeDescriptorSets',
1465 'FlushMappedMemoryRanges',
1466 #'GetGlobalExtensionInfo',
1467 #'GetImageSubresourceInfo',
1468 #'GetObjectInfo',
1469 #'GetPhysicalDeviceExtensionInfo',
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1470 'GetPhysicalDeviceSurfaceSupportKHR',
1471 'GetSurfacePropertiesKHR',
1472 'GetSurfaceFormatsKHR',
1473 'GetSurfacePresentModesKHR',
1474 'CreateSwapchainKHR',
1475 'GetSwapchainImagesKHR',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1476 #'GetPhysicalDeviceInfo',
1477 'MapMemory',
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1478 #'QueuePresentKHR',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1479 'QueueSubmit',
1480 #'StorePipeline',
1481 'UnmapMemory',
1482 'UpdateDescriptorSets',
1483 'WaitForFences',
Jon Ashburncaae0492015-08-13 16:49:08 -0600[diff] [blame]1484 'DbgCreateMsgCallback',
1485 'DbgDestroyMsgCallback',
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1486 'AllocateCommandBuffers',
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1487 ]
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1488
1489 # validate the manually_replay_funcs list
1490 protoFuncs = [proto.name for proto in self.protos]
1491 for func in manually_replay_funcs:
1492 if func not in protoFuncs:
1493 sys.exit("Entry '%s' in manually_replay_funcs list is not in the vulkan function prototypes" % func)
1494
1495 # map protos to custom functions if body is fully custom
1496 custom_body_dict = {'CreateImage': self._gen_replay_create_image,
1497 'CreateBuffer': self._gen_replay_create_buffer }
1498 # multi-gpu Open funcs w/ list of local params to create
1499 custom_open_params = {'OpenSharedMemory': (-1,),
1500 'OpenSharedSemaphore': (-1,),
1501 'OpenPeerMemory': (-1,),
1502 'OpenPeerImage': (-1, -2,)}
1503 # Functions that create views are unique from other create functions
Courtney Goeltzenleuchter1856d6f2015-09-01 17:30:39 -0600[diff] [blame]1504 create_view_list = ['CreateBufferView', 'CreateImageView', 'CreateComputePipeline']
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1505 # Functions to treat as "Create' that don't have 'Create' in the name
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1506 special_create_list = ['LoadPipeline', 'LoadPipelineDerivative', 'AllocateMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocateDescriptorSets']
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1507 # A couple funcs use do while loops
1508 do_while_dict = {'GetFenceStatus': 'replayResult != pPacket->result && pPacket->result == VK_SUCCESS', 'GetEventStatus': '(pPacket->result == VK_EVENT_SET || pPacket->result == VK_EVENT_RESET) && replayResult != pPacket->result'}
1509 rbody = []
1510 rbody.append('%s' % self.lineinfo.get())
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1511 rbody.append('vktrace_replay::VKTRACE_REPLAY_RESULT vkReplay::replay(vktrace_trace_packet_header *packet)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1512 rbody.append('{')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1513 rbody.append(' vktrace_replay::VKTRACE_REPLAY_RESULT returnValue = vktrace_replay::VKTRACE_REPLAY_SUCCESS;')
Courtney Goeltzenleuchterac544f32015-09-14 18:01:17 -0600[diff] [blame]1514 rbody.append(' VkResult replayResult = VK_ERROR_VALIDATION_FAILED;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1515 rbody.append(' switch (packet->packet_id)')
1516 rbody.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1517 rbody.append(' case VKTRACE_TPI_VK_vkApiVersion:')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1518 rbody.append(' {')
1519 rbody.append(' packet_vkApiVersion* pPacket = (packet_vkApiVersion*)(packet->pBody);')
1520 rbody.append(' if (pPacket->version != VK_API_VERSION)')
1521 rbody.append(' {')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1522 rbody.append(' vktrace_LogError("Trace file is from Vulkan version 0x%x (%u.%u.%u), but the vktrace plugin only supports version 0x%x (%u.%u.%u).", pPacket->version, (pPacket->version & 0xFFC00000) >> 22, (pPacket->version & 0x003FF000) >> 12, (pPacket->version & 0x00000FFF), VK_API_VERSION, (VK_API_VERSION & 0xFFC00000) >> 22, (VK_API_VERSION & 0x003FF000) >> 12, (VK_API_VERSION & 0x00000FFF));')
1523 rbody.append(' returnValue = vktrace_replay::VKTRACE_REPLAY_ERROR;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1524 rbody.append(' }')
1525 rbody.append(' break;')
1526 rbody.append(' }')
1527 for proto in self.protos:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1528 ret_value = False
1529 create_view = False
1530 create_func = False
1531 # TODO : How to handle void* return of GetProcAddr?
Jon Ashburnd7770ed2015-09-30 13:41:02 -0600[diff] [blame]1532#TODO make sure vkDestroy object functions really do clean up the object maps
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1533 if ('void' not in proto.ret.lower()) and ('size_t' not in proto.ret) and (proto.name not in custom_body_dict):
1534 ret_value = True
1535 if proto.name in create_view_list:
1536 create_view = True
1537 elif 'Create' in proto.name or proto.name in special_create_list:
1538 create_func = True
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1539 rbody.append(' case VKTRACE_TPI_VK_vk%s:' % proto.name)
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1540 rbody.append(' {')
1541 rbody.append(' packet_vk%s* pPacket = (packet_vk%s*)(packet->pBody);' % (proto.name, proto.name))
1542 if proto.name in manually_replay_funcs:
1543 if ret_value == True:
1544 rbody.append(' replayResult = manually_replay_vk%s(pPacket);' % proto.name)
1545 else:
1546 rbody.append(' manually_replay_vk%s(pPacket);' % proto.name)
1547 elif proto.name in custom_body_dict:
1548 rbody.append(custom_body_dict[proto.name]())
1549 else:
1550 if proto.name in custom_open_params:
1551 for pidx in custom_open_params[proto.name]:
1552 rbody.append(' %s local_%s;' % (proto.params[pidx].ty.replace('const ', '').strip('*'), proto.params[pidx].name))
1553 elif create_view:
1554 rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').replace('const ', '')))
1555 rbody.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(%s));' % (proto.params[1].ty.strip('*').replace('const ', '')))
1556 if 'CreateComputePipeline' == proto.name:
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1557 rbody.append(' createInfo.cs.shader = m_objMapper.remap_shaders(pPacket->pCreateInfo->cs.shader);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1558 elif 'CreateBufferView' == proto.name:
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1559 rbody.append(' createInfo.buffer = m_objMapper.remap_buffers(pPacket->pCreateInfo->buffer);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1560 else:
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1561 rbody.append(' createInfo.image = m_objMapper.remap_images(pPacket->pCreateInfo->image);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1562 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
1563 elif create_func: # Declare local var to store created handle into
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1564 if 'AllocateDescriptorSets' == proto.name:
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]1565 p_ty = proto.params[-1].ty.strip('*').replace('const ', '')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1566 rbody.append(' %s* local_%s = (%s*)malloc(pPacket->pAllocateInfo->setLayoutCount * sizeof(%s));' % (p_ty, proto.params[-1].name, p_ty, p_ty))
1567 rbody.append(' VkDescriptorSetLayout* local_pSetLayouts = (VkDescriptorSetLayout*)malloc(pPacket->pAllocateInfo->setLayoutCount * sizeof(VkDescriptorSetLayout));')
1568 rbody.append(' VkDescriptorSetAllocateInfo local_AllocInfo, *local_pAllocateInfo = &local_AllocInfo;')
Jon Ashburne27a9182015-10-16 17:50:47 -0600[diff] [blame]1569 rbody.append(' VkDescriptorPool local_descPool;')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1570 rbody.append(' local_descPool = m_objMapper.remap_descriptorpools(pPacket->pAllocateInfo->descriptorPool);')
1571 rbody.append(' for (uint32_t i = 0; i < pPacket->pAllocateInfo->setLayoutCount; i++)')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1572 rbody.append(' {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1573 rbody.append(' local_pSetLayouts[i] = m_objMapper.remap_descriptorsetlayouts(pPacket->%s->pSetLayouts[i]);' % (proto.params[-2].name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1574 rbody.append(' }')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1575 rbody.append(' memcpy(local_pAllocateInfo, pPacket->pAllocateInfo, sizeof(VkDescriptorSetAllocateInfo));')
1576 rbody.append(' local_pAllocateInfo->pSetLayouts = local_pSetLayouts;')
1577 rbody.append(' local_pAllocateInfo->descriptorPool = local_descPool;')
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]1578 else:
1579 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1580 elif proto.name == 'ResetFences':
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1581 rbody.append(' VkFence* fences = VKTRACE_NEW_ARRAY(VkFence, pPacket->fenceCount);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1582 rbody.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')
1583 rbody.append(' {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1584 rbody.append(' fences[i] = m_objMapper.remap_fences(pPacket->%s[i]);' % (proto.params[-1].name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1585 rbody.append(' }')
1586 elif proto.name in do_while_dict:
1587 rbody.append(' do {')
Jon Ashburnc736c002015-10-25 20:24:57 -0600[diff] [blame]1588 last_name = ''
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1589 for p in proto.params:
1590 if create_func or create_view:
1591 if p.name != proto.params[-1].name:
Jon Ashburnc736c002015-10-25 20:24:57 -0600[diff] [blame]1592 rbody.append(self._remap_packet_param(proto.name, p.ty, p.name, last_name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1593 else:
Jon Ashburnc736c002015-10-25 20:24:57 -0600[diff] [blame]1594 rbody.append(self._remap_packet_param(proto.name, p.ty, p.name, last_name))
1595 last_name = p.name
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1596
1597 if proto.name == 'DestroyInstance':
1598 rbody.append(' if (m_vkFuncs.real_vkDbgDestroyMsgCallback != NULL)')
1599 rbody.append(' {')
1600 rbody.append(' m_vkFuncs.real_vkDbgDestroyMsgCallback(remappedinstance, m_dbgMsgCallbackObj);')
1601 rbody.append(' }')
1602 # TODO: need a better way to indicate which extensions should be mapped to which Get*ProcAddr
1603 elif proto.name == 'GetInstanceProcAddr':
1604 for iProto in self.protos:
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1605 if 'Dbg' in iProto.name or 'GetPhysicalDeviceSurfaceSupportKHR' in iProto.name:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1606 rbody.append(' if (strcmp(pPacket->pName, "vk%s") == 0) {' % (iProto.name))
1607 rbody.append(' m_vkFuncs.real_vk%s = (PFN_vk%s)vk%s(remappedinstance, pPacket->pName);' % (iProto.name, iProto.name, proto.name))
1608 rbody.append(' }')
1609 elif proto.name == 'GetDeviceProcAddr':
1610 for dProto in self.protos:
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1611 if 'KHR' in dProto.name:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1612 rbody.append(' if (strcmp(pPacket->pName, "vk%s") == 0) {' % (dProto.name))
1613 rbody.append(' m_vkFuncs.real_vk%s = (PFN_vk%s)vk%s(remappeddevice, pPacket->pName);' % (dProto.name, dProto.name, proto.name))
1614 rbody.append(' }')
1615
1616 # build the call to the "real_" entrypoint
1617 rr_string = ' '
1618 if ret_value:
1619 rr_string = ' replayResult = '
1620 rr_string += 'm_vkFuncs.real_vk%s(' % proto.name
1621 for p in proto.params:
1622 # For last param of Create funcs, pass address of param
1623 if create_func:
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1624 if proto.name == 'AllocateDescriptorSets' and ((p.name == proto.params[-2].name) or (p.name == proto.params[-1].name)):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1625 rr_string += 'local_%s, ' % p.name
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]1626 elif p.name == proto.params[-1].name:
1627 rr_string += '&local_%s, ' % p.name
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1628 else:
1629 rr_string += '%s, ' % self._get_packet_param(proto.name, p.ty, p.name)
1630 else:
1631 rr_string += '%s, ' % self._get_packet_param(proto.name, p.ty, p.name)
1632 rr_string = '%s);' % rr_string[:-2]
1633 if proto.name in custom_open_params:
1634 rr_list = rr_string.split(', ')
1635 for pidx in custom_open_params[proto.name]:
1636 rr_list[pidx] = '&local_%s' % proto.params[pidx].name
1637 rr_string = ', '.join(rr_list)
1638 rr_string += ');'
1639 elif create_view:
1640 rr_list = rr_string.split(', ')
Chia-I Wu69f40122015-10-26 21:10:41 +0800[diff] [blame]1641 rr_list[-3] = '&createInfo'
1642 rr_list[-2] = 'NULL'
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1643 rr_list[-1] = '&local_%s);' % proto.params[-1].name
1644 rr_string = ', '.join(rr_list)
1645 # this is a sneaky shortcut to use generic create code below to add_to_map
1646 create_func = True
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1647 elif proto.name == 'AllocateDescriptorSets':
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1648 rr_string = rr_string.replace('pPacket->pSetLayouts', 'pLocalDescSetLayouts')
1649 elif proto.name == 'ResetFences':
1650 rr_string = rr_string.replace('pPacket->pFences', 'fences')
1651
1652 # insert the real_*(..) call
1653 rbody.append(rr_string)
1654
1655 # handle return values or anything that needs to happen after the real_*(..) call
Courtney Goeltzenleuchter74c4ce92015-09-14 17:22:16 -0600[diff] [blame]1656 get_ext_layers_proto = ['EnumerateInstanceExtensionProperties', 'EnumerateDeviceExtensionProperties','EnumerateInstanceLayerProperties', 'EnumerateDeviceLayerProperties']
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1657 if 'DestroyDevice' in proto.name:
1658 rbody.append(' if (replayResult == VK_SUCCESS)')
1659 rbody.append(' {')
1660 rbody.append(' m_pCBDump = NULL;')
1661 rbody.append(' m_pDSDump = NULL;')
1662 #TODO138 : disabling snapshot
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1663 #rbody.append(' m_pVktraceSnapshotPrint = NULL;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1664 rbody.append(' m_objMapper.rm_from_devices_map(pPacket->device);')
1665 rbody.append(' m_display->m_initedVK = false;')
1666 rbody.append(' }')
Jon Ashburnc30315e2015-09-07 14:39:30 -0600[diff] [blame]1667 elif proto.name in get_ext_layers_proto:
Courtney Goeltzenleuchterac544f32015-09-14 18:01:17 -0600[diff] [blame]1668 rbody.append(' if (replayResult == VK_ERROR_LAYER_NOT_PRESENT || replayResult == VK_INCOMPLETE)')
Jon Ashburnc30315e2015-09-07 14:39:30 -0600[diff] [blame]1669 rbody.append(' { // ignore errors caused by trace config != replay config')
1670 rbody.append(' replayResult = VK_SUCCESS;')
1671 rbody.append(' }')
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1672 elif 'DestroySwapchainKHR' in proto.name:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1673 rbody.append(' if (replayResult == VK_SUCCESS)')
1674 rbody.append(' {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1675 rbody.append(' m_objMapper.rm_from_swapchainkhrs_map(pPacket->swapchain);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1676 rbody.append(' }')
1677 elif 'DestroyInstance' in proto.name:
1678 rbody.append(' if (replayResult == VK_SUCCESS)')
1679 rbody.append(' {')
1680 rbody.append(' // TODO need to handle multiple instances and only clearing maps within an instance.')
1681 rbody.append(' // TODO this only works with a single instance used at any given time.')
1682 rbody.append(' m_objMapper.clear_all_map_handles();')
1683 rbody.append(' }')
Courtney Goeltzenleuchter5970b252015-10-27 11:32:31 -0600[diff] [blame]1684 elif 'MergePipelineCaches' in proto.name:
1685 rbody.append(' delete remappedpSrcCaches;')
1686 elif 'FreeCommandBuffers' in proto.name:
1687 rbody.append(' delete remappedpCommandBuffers;')
1688 elif 'CmdExecuteCommands' in proto.name:
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1689 rbody.append(' delete remappedpCommandBuffers;')
1690 elif 'AllocateDescriptorSets' in proto.name:
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1691 rbody.append(' if (replayResult == VK_SUCCESS)')
1692 rbody.append(' {')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1693 rbody.append(' for (uint32_t i = 0; i < pPacket->pAllocateInfo->setLayoutCount; i++) {')
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1694 rbody.append(' m_objMapper.add_to_descriptorsets_map(pPacket->%s[i], local_%s[i]);' % (proto.params[-1].name, proto.params[-1].name))
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1695 rbody.append(' }')
1696 rbody.append(' }')
Jon Ashburn9e8755b2015-08-10 08:53:44 -0600[diff] [blame]1697 rbody.append(' free(local_pSetLayouts);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1698 rbody.append(' free(local_pDescriptorSets);')
1699 elif proto.name == 'ResetFences':
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1700 rbody.append(' VKTRACE_DELETE(fences);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1701 elif create_func: # save handle mapping if create successful
Courtney Goeltzenleuchter3ec31622015-10-20 18:04:07 -0600[diff] [blame]1702 if ret_value:
1703 rbody.append(' if (replayResult == VK_SUCCESS)')
1704 rbody.append(' {')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1705 clean_type = proto.params[-1].ty.strip('*').replace('const ', '')
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1706 VkNonDispObjType = [o for o in vulkan.object_non_dispatch_list]
Chia-I Wue420a332015-10-26 20:04:44 +0800[diff] [blame]1707 rbody.append(' m_objMapper.add_to_%ss_map(*(pPacket->%s), local_%s);' % (clean_type.lower()[2:], proto.params[-1].name, proto.params[-1].name))
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1708 if 'AllocateMemory' == proto.name:
1709 rbody.append(' m_objMapper.add_entry_to_mapData(local_%s, pPacket->pAllocateInfo->allocationSize);' % (proto.params[-1].name))
Courtney Goeltzenleuchter3ec31622015-10-20 18:04:07 -0600[diff] [blame]1710 if ret_value:
1711 rbody.append(' }')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1712 elif proto.name in do_while_dict:
1713 rbody[-1] = ' %s' % rbody[-1]
1714 rbody.append(' } while (%s);' % do_while_dict[proto.name])
1715 rbody.append(' if (pPacket->result != VK_NOT_READY || replayResult != VK_SUCCESS)')
1716 if ret_value:
1717 rbody.append(' CHECK_RETURN_VALUE(vk%s);' % proto.name)
1718 rbody.append(' break;')
1719 rbody.append(' }')
1720 rbody.append(' default:')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1721 rbody.append(' vktrace_LogWarning("Unrecognized packet_id %u, skipping.", packet->packet_id);')
1722 rbody.append(' returnValue = vktrace_replay::VKTRACE_REPLAY_INVALID_ID;')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1723 rbody.append(' break;')
1724 rbody.append(' }')
1725 rbody.append(' return returnValue;')
1726 rbody.append('}')
1727 return "\n".join(rbody)
1728
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1729class VktraceTraceHeader(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1730 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1731 header_txt = []
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1732 header_txt.append('#include "vktrace_vk_vk_packets.h"')
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]1733 header_txt.append('#include "vktrace_vk_packet_id.h"\n\n')
1734 header_txt.append('void InitTracer(void);\n\n')
1735 header_txt.append('#ifdef WIN32')
1736 header_txt.append('extern INIT_ONCE gInitOnce;')
1737 header_txt.append('\n#elif defined(PLATFORM_LINUX)')
1738 header_txt.append('extern pthread_once_t gInitOnce;')
1739 header_txt.append('#endif\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1740 return "\n".join(header_txt)
1741
1742 def generate_body(self):
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]1743 body = [self._generate_trace_func_protos()]
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1744
1745 return "\n".join(body)
1746
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1747class VktraceTraceC(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1748 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1749 header_txt = []
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1750 header_txt.append('#include "vktrace_platform.h"')
1751 header_txt.append('#include "vktrace_common.h"')
1752 header_txt.append('#include "vktrace_lib_helpers.h"')
1753 header_txt.append('#include "vktrace_vk_vk.h"')
David Pinedoa31fe0b2015-11-24 09:00:24 -0700[diff] [blame]1754 header_txt.append('#include "vktrace_vk_vk_lunarg_debug_report.h"')
1755 header_txt.append('#include "vktrace_vk_vk_lunarg_debug_marker.h"')
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1756 header_txt.append('#include "vktrace_vk_vk_ext_khr_swapchain.h"')
1757 header_txt.append('#include "vktrace_vk_vk_ext_khr_device_swapchain.h"')
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1758 header_txt.append('#include "vktrace_interconnect.h"')
1759 header_txt.append('#include "vktrace_filelike.h"')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1760 header_txt.append('#include "vk_struct_size_helper.h"')
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]1761 header_txt.append('#ifdef PLATFORM_LINUX')
1762 header_txt.append('#include <pthread.h>')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1763 header_txt.append('#endif')
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1764 header_txt.append('#include "vktrace_trace_packet_utils.h"')
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]1765 header_txt.append('#include <stdio.h>\n')
Chia-I Wua5cd6532015-10-28 18:31:57 +0800[diff] [blame]1766 header_txt.append('#include <string.h>\n')
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]1767 header_txt.append('#ifdef WIN32')
1768 header_txt.append('INIT_ONCE gInitOnce = INIT_ONCE_STATIC_INIT;')
1769 header_txt.append('#elif defined(PLATFORM_LINUX)')
1770 header_txt.append('pthread_once_t gInitOnce = PTHREAD_ONCE_INIT;')
1771 header_txt.append('#endif')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1772 return "\n".join(header_txt)
1773
1774 def generate_body(self):
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]1775 body = [self._generate_init_funcs(),
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1776 self._generate_trace_funcs(self.extensionName)]
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1777
1778 return "\n".join(body)
1779
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1780class VktracePacketID(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1781 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1782 header_txt = []
1783 header_txt.append('#pragma once\n')
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1784 header_txt.append('#include "vktrace_trace_packet_utils.h"')
1785 header_txt.append('#include "vktrace_trace_packet_identifiers.h"')
1786 header_txt.append('#include "vktrace_interconnect.h"')
1787 header_txt.append('#include "vktrace_vk_vk_packets.h"')
David Pinedoa31fe0b2015-11-24 09:00:24 -0700[diff] [blame]1788 header_txt.append('#include "vktrace_vk_vk_lunarg_debug_report_packets.h"')
1789 header_txt.append('#include "vktrace_vk_vk_lunarg_debug_marker_packets.h"')
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1790 header_txt.append('#include "vktrace_vk_vk_ext_khr_swapchain_packets.h"')
1791 header_txt.append('#include "vktrace_vk_vk_ext_khr_device_swapchain_packets.h"')
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1792 #header_txt.append('#include "vk_enum_string_helper.h"')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1793 header_txt.append('#ifndef _WIN32')
1794 header_txt.append(' #pragma GCC diagnostic ignored "-Wwrite-strings"')
1795 header_txt.append('#endif')
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1796 #header_txt.append('#include "vk_struct_string_helper.h"')
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1797 #header_txt.append('#include "vk_ext_khr_swapchain_struct_string_helper.h"')
1798 #header_txt.append('#include "vk_ext_khr_device_swapchain_struct_string_helper.h"')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1799 header_txt.append('#ifndef _WIN32')
1800 header_txt.append(' #pragma GCC diagnostic warning "-Wwrite-strings"')
1801 header_txt.append('#endif')
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1802 #header_txt.append('#include "vk_ext_khr_swapchain_enum_string_helper.h"')
1803 #header_txt.append('#include "vk_ext_khr_device_swapchain_enum_string_helper.h"')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1804 header_txt.append('#if defined(WIN32)')
1805 header_txt.append('#define snprintf _snprintf')
1806 header_txt.append('#endif')
1807 header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1808 header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) vktrace_TraceInfo(#entrypoint);\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1809 header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1810 header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) vktrace_TraceInfo(entrypoint, __VA_ARGS__);\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1811 header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1812 header_txt.append(' pHeader = vktrace_create_trace_packet(VKTRACE_TID_VULKAN, VKTRACE_TPI_VK_##entrypoint, sizeof(packet_##entrypoint), buffer_bytes_needed);\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1813 header_txt.append('#define FINISH_TRACE_PACKET() \\')
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1814 header_txt.append(' vktrace_finalize_trace_packet(pHeader); \\')
1815 header_txt.append(' vktrace_write_trace_packet(pHeader, vktrace_trace_get_trace_file()); \\')
1816 header_txt.append(' vktrace_delete_trace_packet(&pHeader);')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1817 return "\n".join(header_txt)
1818
1819 def generate_body(self):
1820 body = [self._generate_packet_id_enum(),
1821 self._generate_packet_id_name_func(),
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1822# self._generate_stringify_func(),
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1823 self._generate_interp_func()]
1824
1825 return "\n".join(body)
1826
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1827class VktraceCoreTracePackets(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1828 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1829 header_txt = []
1830 header_txt.append('#pragma once\n')
David Pinedo329ca9e2015-11-06 12:54:48 -0700[diff] [blame]1831 header_txt.append('#include "vulkan/vulkan.h"')
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1832 header_txt.append('#include "vktrace_trace_packet_utils.h"\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1833 return "\n".join(header_txt)
1834
1835 def generate_body(self):
1836 body = [self._generate_struct_util_funcs(),
1837 self._generate_interp_funcs()]
1838
1839 return "\n".join(body)
1840
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1841class VktraceExtTraceHeader(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1842 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1843 header_txt = []
1844 header_txt.append('#pragma once\n')
David Pinedo329ca9e2015-11-06 12:54:48 -0700[diff] [blame]1845 header_txt.append('#include "vulkan/vulkan.h"')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1846 header_txt.append('#include "%s.h"' % extensionName.lower())
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1847 return "\n".join(header_txt)
1848
1849 def generate_body(self):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1850 body = [self._generate_trace_func_protos_ext(self.extensionName)]
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1851
1852 return "\n".join(body)
1853
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1854class VktraceExtTraceC(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1855 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1856 header_txt = []
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1857 header_txt.append('#include "vktrace_platform.h"')
1858 header_txt.append('#include "vktrace_common.h"')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1859 if extensionName == "vk_ext_khr_device_swapchain":
David Pinedo329ca9e2015-11-06 12:54:48 -0700[diff] [blame]1860 header_txt.append('#include "vulkan/vk_ext_khr_swapchain.h"')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1861 header_txt.append('#include "vktrace_vk_%s.h"' % extensionName.lower())
1862 header_txt.append('#include "vktrace_vk_%s_packets.h"' % extensionName.lower())
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1863 header_txt.append('#include "vktrace_vk_packet_id.h"')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1864 header_txt.append('#include "vk_struct_size_helper.h"')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1865 header_txt.append('#include "%s_struct_size_helper.h"' % extensionName.lower())
David Pinedoa31fe0b2015-11-24 09:00:24 -0700[diff] [blame]1866 if extensionName == 'vk_lunarg_debug_marker':
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]1867 header_txt.append('#include "vk_debug_marker_layer.h"\n')
Jon Ashburn71654fd2015-09-11 09:18:44 -0600[diff] [blame]1868
Jon Ashburn5afdcf62015-09-14 15:17:36 -0600[diff] [blame]1869 header_txt.append('#include "vktrace_lib_helpers.h"')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1870 return "\n".join(header_txt)
1871
1872 def generate_body(self):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1873 body = [self._generate_trace_funcs(self.extensionName)]
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1874
1875 return "\n".join(body)
1876
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1877class VktraceExtTracePackets(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1878 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1879 header_txt = []
1880 header_txt.append('#pragma once\n')
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1881 header_txt.append('#include "%s.h"' % extensionName.lower())
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1882 header_txt.append('#include "vktrace_trace_packet_utils.h"\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1883 return "\n".join(header_txt)
1884
1885 def generate_body(self):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1886 body = [self._generate_interp_funcs_ext(self.extensionName)]
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1887
1888 return "\n".join(body)
1889
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1890class VktraceReplayVkFuncPtrs(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1891 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1892 header_txt = []
1893 header_txt.append('#pragma once\n')
1894 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
1895 header_txt.append('#include <xcb/xcb.h>\n')
1896 header_txt.append('#endif')
David Pinedo329ca9e2015-11-06 12:54:48 -0700[diff] [blame]1897 header_txt.append('#include "vulkan/vulkan.h"')
David Pinedoa31fe0b2015-11-24 09:00:24 -0700[diff] [blame]1898 header_txt.append('#include "vulkan/vk_lunarg_debug_report.h"')
1899 header_txt.append('#include "vulkan/vk_lunarg_debug_marker.h"')
David Pinedo329ca9e2015-11-06 12:54:48 -0700[diff] [blame]1900 header_txt.append('#include "vulkan/vk_ext_khr_swapchain.h"')
1901 header_txt.append('#include "vulkan/vk_ext_khr_device_swapchain.h"')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1902
1903 def generate_body(self):
1904 body = [self._generate_replay_func_ptrs()]
1905 return "\n".join(body)
1906
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1907class VktraceReplayObjMapperHeader(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1908 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1909 header_txt = []
1910 header_txt.append('#pragma once\n')
1911 header_txt.append('#include <set>')
1912 header_txt.append('#include <map>')
1913 header_txt.append('#include <vector>')
1914 header_txt.append('#include <string>')
David Pinedo329ca9e2015-11-06 12:54:48 -0700[diff] [blame]1915 header_txt.append('#include "vulkan/vulkan.h"')
David Pinedoa31fe0b2015-11-24 09:00:24 -0700[diff] [blame]1916 header_txt.append('#include "vulkan/vk_lunarg_debug_report.h"')
1917 header_txt.append('#include "vulkan/vk_lunarg_debug_marker.h"')
David Pinedo329ca9e2015-11-06 12:54:48 -0700[diff] [blame]1918 header_txt.append('#include "vulkan/vk_ext_khr_swapchain.h"')
1919 header_txt.append('#include "vulkan/vk_ext_khr_device_swapchain.h"')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1920 return "\n".join(header_txt)
1921
1922 def generate_body(self):
1923 body = [self._generate_replay_objmapper_class()]
1924 return "\n".join(body)
1925
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1926class VktraceReplayC(Subcommand):
Chia-I Wu1f851912015-10-27 18:04:07 +0800[diff] [blame]1927 def generate_header(self, extensionName):
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1928 header_txt = []
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1929 header_txt.append('#include "vkreplay_vkreplay.h"\n')
1930 header_txt.append('#include "vkreplay.h"\n')
1931 header_txt.append('#include "vkreplay_main.h"\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1932 header_txt.append('#include <algorithm>')
1933 header_txt.append('#include <queue>')
1934 header_txt.append('\n')
1935 header_txt.append('extern "C" {')
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1936 header_txt.append('#include "vktrace_vk_vk_packets.h"')
David Pinedoa31fe0b2015-11-24 09:00:24 -0700[diff] [blame]1937 header_txt.append('#include "vktrace_vk_vk_lunarg_debug_report_packets.h"')
1938 header_txt.append('#include "vktrace_vk_vk_lunarg_debug_marker_packets.h"')
Ian Elliott338dedb2015-08-21 15:09:33 -0600[diff] [blame]1939 header_txt.append('#include "vktrace_vk_vk_ext_khr_swapchain_packets.h"')
1940 header_txt.append('#include "vktrace_vk_vk_ext_khr_device_swapchain_packets.h"')
Mark Lobodzinskif39d70c2015-08-14 14:24:50 -0600[diff] [blame]1941 header_txt.append('#include "vktrace_vk_packet_id.h"')
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1942 #header_txt.append('#include "vk_enum_string_helper.h"\n}\n')
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1943
1944 return "\n".join(header_txt)
1945
1946 def generate_body(self):
1947 body = [self._generate_replay_init_funcs(),
1948 self._generate_replay()]
Jon Ashburncb622a12015-08-06 17:22:53 -0600[diff] [blame]1949 body.append("}")
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1950 return "\n".join(body)
1951
1952def main():
1953 subcommands = {
Mark Lobodzinski87220f82015-08-27 15:30:29 -0600[diff] [blame]1954 "vktrace-trace-h" : VktraceTraceHeader,
1955 "vktrace-trace-c" : VktraceTraceC,
1956 "vktrace-packet-id" : VktracePacketID,
1957 "vktrace-core-trace-packets" : VktraceCoreTracePackets,
1958 "vktrace-ext-trace-h" : VktraceExtTraceHeader,
1959 "vktrace-ext-trace-c" : VktraceExtTraceC,
1960 "vktrace-ext-trace-packets" : VktraceExtTracePackets,
1961 "vktrace-replay-vk-funcs" : VktraceReplayVkFuncPtrs,
1962 "vktrace-replay-obj-mapper-h" : VktraceReplayObjMapperHeader,
1963 "vktrace-replay-c" : VktraceReplayC,
Jon Ashburn4d9cfd22015-08-04 13:35:25 -0600[diff] [blame]1964 }
1965
1966 if len(sys.argv) < 2 or sys.argv[1] not in subcommands:
1967 print("Usage: %s <subcommand> [options]" % sys.argv[0])
1968 print
1969 print("Available subcommands are: %s" % " ".join(subcommands))
1970 exit(1)
1971
1972 subcmd = subcommands[sys.argv[1]](sys.argv[2])
1973 subcmd.run()
1974
1975if __name__ == "__main__":
1976 main()