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