Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 4e063af32cf68a85a3cffd2c076c5476d8c15d37 / . / tools / glave / scripts / vk_generate.py
blob: c50d6264e2ee13aec30de4e4393f5f66728f050b [file] [log] [blame]
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1#!/usr/bin/env python3
2#
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]3# Vulkan
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]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#
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]25
Peter Lohrmannd221ea12015-03-25 21:35:32 -0700[diff] [blame]26import os, sys
27
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]28# add main repo directory so vulkan.py can be imported. This needs to be a complete path.
Peter Lohrmannd221ea12015-03-25 21:35:32 -0700[diff] [blame]29glv_scripts_path = os.path.dirname(os.path.abspath(__file__))
30main_path = os.path.abspath(glv_scripts_path + "/../../../")
31sys.path.append(main_path)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]32
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]33import vulkan
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]34
35class Subcommand(object):
36 def __init__(self, argv):
37 self.argv = argv
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]38 self.headers = vulkan.headers
39 self.protos = vulkan.protos
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]40
41 def run(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]42 print(self.generate())
43
44 def generate(self):
45 copyright = self.generate_copyright()
46 header = self.generate_header()
47 body = self.generate_body()
48 footer = self.generate_footer()
49
50 contents = []
51 if copyright:
52 contents.append(copyright)
53 if header:
54 contents.append(header)
55 if body:
56 contents.append(body)
57 if footer:
58 contents.append(footer)
59
60 return "\n\n".join(contents)
61
62 def generate_copyright(self):
63 return """/* THIS FILE IS GENERATED. DO NOT EDIT. */
64
65/*
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]66 * Vulkan
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]67 *
68 * Copyright (C) 2014 LunarG, Inc.
69 *
70 * Permission is hereby granted, free of charge, to any person obtaining a
71 * copy of this software and associated documentation files (the "Software"),
72 * to deal in the Software without restriction, including without limitation
73 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
74 * and/or sell copies of the Software, and to permit persons to whom the
75 * Software is furnished to do so, subject to the following conditions:
76 *
77 * The above copyright notice and this permission notice shall be included
78 * in all copies or substantial portions of the Software.
79 *
80 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
81 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
82 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
83 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
84 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
85 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
86 * DEALINGS IN THE SOFTWARE.
87 */"""
88
89 def generate_header(self):
90 return "\n".join(["#include <" + h + ">" for h in self.headers])
91
92 def generate_body(self):
93 pass
94
95 def generate_footer(self):
96 pass
97
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]98 # Return set of printf '%' qualifier, input to that qualifier, and any dereference
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]99 def _get_printf_params(self, vk_type, name, output_param):
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]100 deref = ""
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]101 # TODO : Need ENUM and STRUCT checks here
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]102 if "VkImage_LAYOUT" in vk_type:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]103 return ("%s", "string_%s(%s)" % (vk_type.replace('const ', '').strip('*'), name), deref)
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]104 if "VkClearColor" in vk_type:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]105 return ("%p", "(void*)&%s" % name, deref)
106 if "_type" in vk_type.lower(): # TODO : This should be generic ENUM check
107 return ("%s", "string_%s(%s)" % (vk_type.replace('const ', '').strip('*'), name), deref)
108 if "char*" == vk_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]109 return ("%s", name, "*")
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]110 if "uint64_t" in vk_type:
111 if '*' in vk_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]112 return ("%lu", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
113 return ("%lu", name, deref)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]114 if "size_t" in vk_type:
115 if '*' in vk_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]116 return ("%zu", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
117 return ("%zu", name, deref)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]118 if "float" in vk_type:
119 if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]120 return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name), deref)
121 return ("%f", name, deref)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]122 if "bool" in vk_type or 'xcb_randr_crtc_t' in vk_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]123 return ("%u", name, deref)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]124 if True in [t in vk_type.lower() for t in ["int", "flags", "mask", "xcb_window_t"]]:
125 if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]126 return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name), deref)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]127 if '*' in vk_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]128 return ("%i", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
129 return ("%i", name, deref)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]130 if output_param:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]131 return ("%p", "(void*)%s" % name, deref)
132 return ("%p", "(void*)(%s)" % name, deref)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]133
134 def _generate_trace_func_ptrs(self):
135 func_ptrs = []
136 func_ptrs.append('// Pointers to real functions and declarations of hooked functions')
137 func_ptrs.append('#ifdef WIN32')
138 func_ptrs.append('extern INIT_ONCE gInitOnce;')
139 for proto in self.protos:
140 if True not in [skip_str in proto.name for skip_str in ['Dbg', 'Wsi']]: #Dbg' not in proto.name and 'Wsi' not in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]141 func_ptrs.append('#define __HOOKED_vk%s hooked_vk%s' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]142
143 func_ptrs.append('\n#elif defined(PLATFORM_LINUX)')
144 func_ptrs.append('extern pthread_once_t gInitOnce;')
145 for proto in self.protos:
146 if True not in [skip_str in proto.name for skip_str in ['Dbg', 'Wsi']]:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]147 func_ptrs.append('#define __HOOKED_vk%s vk%s' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]148
149 func_ptrs.append('#endif\n')
150 return "\n".join(func_ptrs)
151
152 def _generate_trace_func_ptrs_ext(self, func_class='Wsi'):
153 func_ptrs = []
154 func_ptrs.append('#ifdef WIN32')
155 for proto in self.protos:
156 if func_class in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]157 func_ptrs.append('#define __HOOKED_vk%s hooked_vk%s' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]158
159 func_ptrs.append('#elif defined(__linux__)')
160 for proto in self.protos:
161 if func_class in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]162 func_ptrs.append('#define __HOOKED_vk%s vk%s' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]163
164 func_ptrs.append('#endif\n')
165 return "\n".join(func_ptrs)
166
167 def _generate_trace_func_protos(self):
168 func_protos = []
169 func_protos.append('// Hooked function prototypes\n')
170 for proto in self.protos:
171 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]172 func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_vk", attr="VKAPI"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]173
174 return "\n".join(func_protos)
175
176 def _generate_trace_func_protos_ext(self, func_class='Wsi'):
177 func_protos = []
178 func_protos.append('// Hooked function prototypes\n')
179 for proto in self.protos:
180 if func_class in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]181 func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_vk", attr="VKAPI"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]182
183 return "\n".join(func_protos)
184
185
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]186 def _generate_trace_real_func_ptr_protos(self):
187 func_ptr_assign = []
188 func_ptr_assign.append('')
189 for proto in self.protos:
190 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]191 func_ptr_assign.append('extern %s( VKAPI * real_vk%s)(' % (proto.ret, proto.name))
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]192 for p in proto.params:
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]193 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]194 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ');\n')
195 return "\n".join(func_ptr_assign)
196
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]197 def _generate_func_ptr_assignments(self):
198 func_ptr_assign = []
199 for proto in self.protos:
200 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]201 func_ptr_assign.append('%s( VKAPI * real_vk%s)(' % (proto.ret, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]202 for p in proto.params:
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]203 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]204 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = vk%s;\n' % (proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]205 return "\n".join(func_ptr_assign)
206
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]207
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]208 def _generate_func_ptr_assignments_ext(self, func_class='Wsi'):
209 func_ptr_assign = []
210 for proto in self.protos:
211 if func_class in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]212 func_ptr_assign.append('static %s( VKAPI * real_vk%s)(' % (proto.ret, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]213 for p in proto.params:
214 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]215 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = vk%s;\n' % (proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]216 return "\n".join(func_ptr_assign)
217
218 def _generate_attach_hooks(self):
219 hooks_txt = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]220 hooks_txt.append('// declared as extern in glvtrace_vk_helpers.h')
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]221 hooks_txt.append('BOOL isHooked = FALSE;\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]222 hooks_txt.append('void AttachHooks()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)')
223 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]224 # TODO : Verify if CreateInstance is appropriate to key off of here
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]225 hooks_txt.append(' if (real_vkCreateInstance != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]226 hooks_txt.append(' {\n isHooked = TRUE;')
227 hook_operator = '='
228 for proto in self.protos:
229 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]230 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_vk%s, hooked_vk%s);' % (hook_operator, proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]231 hook_operator = '&='
232 hooks_txt.append(' }\n')
233 hooks_txt.append(' if (!hookSuccess)\n {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]234 hooks_txt.append(' glv_LogError("Failed to hook Vulkan.");\n }\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]235 hooks_txt.append(' Mhook_EndMultiOperation();\n')
236 hooks_txt.append('#elif defined(__linux__)')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]237 hooks_txt.append(' if (real_vkCreateInstance == vkCreateInstance)')
238 hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_vkCreateInstance,"vkCreateInstance");')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]239 hooks_txt.append(' isHooked = TRUE;')
240 for proto in self.protos:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]241 if 'Dbg' not in proto.name and 'Wsi' not in proto.name and 'CreateInstance' not in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]242 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_vk%s, "vk%s");' % (hook_operator, proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]243 hooks_txt.append(' if (!hookSuccess)\n {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]244 hooks_txt.append(' glv_LogError("Failed to hook Vulkan.");\n }\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]245 hooks_txt.append('#endif\n}\n')
246 return "\n".join(hooks_txt)
247
248 def _generate_attach_hooks_ext(self, func_class='Wsi'):
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]249 func_ext_dict = {'Wsi': '_vkwsix11ext', 'Dbg': '_vkdbg'}
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]250 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
251 hooks_txt = []
252 hooks_txt.append('void AttachHooks%s()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)' % func_ext_dict[func_class])
253 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]254 hooks_txt.append(' if (real_vk%s != NULL)' % first_proto_dict[func_class])
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]255 hooks_txt.append(' {')
256 hook_operator = '='
257 for proto in self.protos:
258 if func_class in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]259 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_vk%s, hooked_vk%s);' % (hook_operator, proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]260 hook_operator = '&='
261 hooks_txt.append(' }\n')
262 hooks_txt.append(' if (!hookSuccess)\n {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]263 hooks_txt.append(' glv_LogError("Failed to hook Vulkan ext %s.");\n }\n' % func_class)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]264 hooks_txt.append(' Mhook_EndMultiOperation();\n')
265 hooks_txt.append('#elif defined(__linux__)')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]266 hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_vk%s, "vk%s");' % (first_proto_dict[func_class], first_proto_dict[func_class]))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]267 for proto in self.protos:
268 if func_class in proto.name and first_proto_dict[func_class] not in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]269 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_vk%s, "vk%s");' % (hook_operator, proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]270 hooks_txt.append(' if (!hookSuccess)\n {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]271 hooks_txt.append(' glv_LogError("Failed to hook Vulkan ext %s.");\n }\n' % func_class)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]272 hooks_txt.append('#endif\n}\n')
273 return "\n".join(hooks_txt)
274
275 def _generate_detach_hooks(self):
276 hooks_txt = []
277 hooks_txt.append('void DetachHooks()\n{\n#ifdef __linux__\n return;\n#elif defined(WIN32)')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]278 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_vkGetGpuInfo != NULL)\n {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]279 hook_operator = '='
280 for proto in self.protos:
281 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]282 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_vk%s);' % (hook_operator, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]283 hook_operator = '&='
284 hooks_txt.append(' }\n isHooked = FALSE;')
285 hooks_txt.append(' if (!unhookSuccess)\n {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]286 hooks_txt.append(' glv_LogError("Failed to unhook Vulkan.");\n }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]287 hooks_txt.append('#endif\n}')
288 hooks_txt.append('#ifdef WIN32\nINIT_ONCE gInitOnce = INIT_ONCE_STATIC_INIT;\n#elif defined(PLATFORM_LINUX)\npthread_once_t gInitOnce = PTHREAD_ONCE_INIT;\n#endif\n')
289 return "\n".join(hooks_txt)
290
291 def _generate_detach_hooks_ext(self, func_class='Wsi'):
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]292 func_ext_dict = {'Wsi': '_vkwsix11ext', 'Dbg': '_vkdbg'}
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]293 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
294 hooks_txt = []
295 hooks_txt.append('void DetachHooks%s()\n{\n#ifdef WIN32' % func_ext_dict[func_class])
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]296 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_vk%s != NULL)\n {' % first_proto_dict[func_class])
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]297 hook_operator = '='
298 for proto in self.protos:
299 if func_class in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]300 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_vk%s);' % (hook_operator, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]301 hook_operator = '&='
302 hooks_txt.append(' }')
303 hooks_txt.append(' if (!unhookSuccess)\n {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]304 hooks_txt.append(' glv_LogError("Failed to unhook Vulkan ext %s.");\n }' % func_class)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]305 hooks_txt.append('#elif defined(__linux__)\n return;\n#endif\n}\n')
306 return "\n".join(hooks_txt)
307
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]308 def _generate_init_funcs(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]309 init_tracer = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]310 init_tracer.append('void send_vk_api_version_packet()\n{')
311 init_tracer.append(' struct_vkApiVersion* pPacket;')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]312 init_tracer.append(' glv_trace_packet_header* pHeader;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]313 init_tracer.append(' pHeader = glv_create_trace_packet(GLV_TID_VULKAN, GLV_TPI_VK_vkApiVersion, sizeof(struct_vkApiVersion), 0);')
314 init_tracer.append(' pPacket = interpret_body_as_vkApiVersion(pHeader, FALSE);')
315 init_tracer.append(' pPacket->version = VK_API_VERSION;')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]316 init_tracer.append(' FINISH_TRACE_PACKET();\n}\n')
317
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]318 init_tracer.append('extern GLV_CRITICAL_SECTION g_memInfoLock;')
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]319 init_tracer.append('void InitTracer(void)\n{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]320 init_tracer.append(' char *ipAddr = glv_get_global_var("GLVLIB_TRACE_IPADDR");')
321 init_tracer.append(' if (ipAddr == NULL)')
322 init_tracer.append(' ipAddr = "127.0.0.1";')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]323 init_tracer.append(' gMessageStream = glv_MessageStream_create(FALSE, ipAddr, GLV_BASE_PORT + GLV_TID_VULKAN);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]324 init_tracer.append(' glv_trace_set_trace_file(glv_FileLike_create_msg(gMessageStream));')
325 init_tracer.append('// glv_tracelog_set_log_file(glv_FileLike_create_file(fopen("glv_log_traceside.txt","w")));')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]326 init_tracer.append(' glv_tracelog_set_tracer_id(GLV_TID_VULKAN);')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]327 init_tracer.append(' glv_create_critical_section(&g_memInfoLock);')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]328 init_tracer.append(' send_vk_api_version_packet();\n}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]329 return "\n".join(init_tracer)
330
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]331 # Take a list of params and return a list of dicts w/ ptr param details
332 def _get_packet_ptr_param_list(self, params):
333 ptr_param_list = []
334 # TODO : This is a slightly nicer way to handle custom cases than initial code, however
335 # this can still be further generalized to eliminate more custom code
336 # big case to handle is when ptrs to structs have embedded data that needs to be accounted for in packet
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]337 custom_ptr_dict = {'VkDeviceCreateInfo': {'add_txt': 'add_VkDeviceCreateInfo_to_packet(pHeader, (VkDeviceCreateInfo**) &(pPacket->pCreateInfo), pCreateInfo)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]338 'finalize_txt': ''},
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]339 'VkApplicationInfo': {'add_txt': 'add_VkApplicationInfo_to_packet(pHeader, (VkApplicationInfo**)&(pPacket->pAppInfo), pAppInfo)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]340 'finalize_txt': ''},
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]341 'VK_PHYSICAL_GPU': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), *pGpuCount*sizeof(VK_PHYSICAL_GPU), pGpus)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]342 'finalize_txt': 'default'},
343 'pDataSize': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize)',
344 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize))'},
345 'pData': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData)',
346 'finalize_txt': 'default'},
347 'pName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pName), ((pName != NULL) ? strlen(pName) + 1 : 0), pName)',
348 'finalize_txt': 'default'},
349 'pExtName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pExtName), ((pExtName != NULL) ? strlen(pExtName) + 1 : 0), pExtName)',
350 'finalize_txt': 'default'},
351 'pDescriptorSets': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets)',
352 'finalize_txt': 'default'},
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]353 'pUpdateChain': {'add_txt': 'add_update_descriptors_to_trace_packet(pHeader, (void**)&(pPacket->pUpdateChain), pUpdateChain)',
354 'finalize_txt': 'default'},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]355 'VkShaderCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkShaderCreateInfo), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), ((pCreateInfo != NULL) ? pCreateInfo->codeSize : 0), pCreateInfo->pCode)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]356 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]357 'VkFramebufferCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkFramebufferCreateInfo), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments), colorCount * sizeof(VkColorAttachmentBindInfo), pCreateInfo->pColorAttachments);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment), dsSize, pCreateInfo->pDepthStencilAttachment)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]358 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Jon Ashburn4e063af2015-04-15 15:45:22 -0600[diff] [blame^]359 'VkRenderPassCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkRenderPassCreateInfo), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorFormats), colorCount * sizeof(VkFormat), pCreateInfo->pColorFormats);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLayouts), colorCount * sizeof(VkImageLayout), pCreateInfo->pColorLayouts);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps), colorCount * sizeof(VkAttachmentLoadOp), pCreateInfo->pColorLoadOps);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps), colorCount * sizeof(VkAttachmentStoreOp), pCreateInfo->pColorStoreOps);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues), colorCount * sizeof(VkClearColor), pCreateInfo->pColorLoadClearValues)',
360 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorFormats));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLayouts));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]361 'VkCmdBufferBeginInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pBeginInfo), sizeof(VkCmdBufferBeginInfo), pBeginInfo);\n add_begin_cmdbuf_to_trace_packet(pHeader, (void**)&(pPacket->pBeginInfo->pNext), pBeginInfo->pNext)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]362 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBeginInfo))'},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]363 'VkDynamicVpStateCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDynamicVpStateCreateInfo), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pViewports), vpsCount * sizeof(VkViewport), pCreateInfo->pViewports);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pScissors), vpsCount * sizeof(VkRect), pCreateInfo->pScissors)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]364 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pViewports));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pScissors));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]365 'VkMemoryAllocInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(VkMemoryAllocInfo), pAllocInfo);\n add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo->pNext), pAllocInfo->pNext)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]366 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo))'},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]367 'VkGraphicsPipelineCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkGraphicsPipelineCreateInfo), pCreateInfo);\n add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]368 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]369 'VkDescriptorPoolCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDescriptorPoolCreateInfo), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), pCreateInfo->count * sizeof(VkDescriptorTypeCount), pCreateInfo->pTypeCount)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]370 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]371 'VkComputePipelineCreateInfo': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkComputePipelineCreateInfo), pCreateInfo);\n add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);\n add_pipeline_shader_to_trace_packet(pHeader, (VkPipelineShader*)&pPacket->pCreateInfo->cs, &pCreateInfo->cs)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]372 'finalize_txt': 'finalize_pipeline_shader_address(pHeader, &pPacket->pCreateInfo->cs);\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
373 }
374 for p in params:
375 pp_dict = {}
376 if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
377 if 'const' in p.ty.lower() and 'count' in params[params.index(p)-1].name.lower():
378 pp_dict['add_txt'] = 'glv_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)
379 elif p.ty.strip('*').replace('const ', '') in custom_ptr_dict:
380 pp_dict['add_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['add_txt']
381 pp_dict['finalize_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['finalize_txt']
382 elif p.name in custom_ptr_dict:
383 pp_dict['add_txt'] = custom_ptr_dict[p.name]['add_txt']
384 pp_dict['finalize_txt'] = custom_ptr_dict[p.name]['finalize_txt']
385 # TODO : This is custom hack to account for 2 pData items with dataSize param for sizing
386 if 'pData' == p.name and 'dataSize' == params[params.index(p)-1].name:
387 pp_dict['add_txt'] = pp_dict['add_txt'].replace('_dataSize', 'dataSize')
388 else:
389 pp_dict['add_txt'] = 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s)' % (p.name, p.ty.strip('*').replace('const ', ''), p.name)
390 if 'finalize_txt' not in pp_dict or 'default' == pp_dict['finalize_txt']:
391 pp_dict['finalize_txt'] = 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s))' % (p.name)
392 pp_dict['index'] = params.index(p)
393 ptr_param_list.append(pp_dict)
394 return ptr_param_list
395
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]396 # Take a list of params and return a list of packet size elements
397 def _get_packet_size(self, params):
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]398 ps = [] # List of elements to be added together to account for packet size for given params
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]399 skip_list = [] # store params that are already accounted for so we don't count them twice
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]400 # Dict of specific params with unique custom sizes
401 custom_size_dict = {'pSetBindPoints': '(VK_SHADER_STAGE_COMPUTE * sizeof(uint32_t))', # Accounting for largest possible array
402 }
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]403 for p in params:
404 #First handle custom cases
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]405 if p.name in ['pCreateInfo', 'pUpdateChain', 'pSetLayoutInfoList', 'pBeginInfo', 'pAllocInfo']:
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]406 ps.append('get_struct_chain_size((void*)%s)' % p.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]407 skip_list.append(p.name)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]408 elif p.name in custom_size_dict:
409 ps.append(custom_size_dict[p.name])
410 skip_list.append(p.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]411 # Skip any params already handled
412 if p.name in skip_list:
413 continue
414 # Now check to identify dynamic arrays which depend on two params
415 if 'count' in p.name.lower():
416 next_idx = params.index(p)+1
417 # If next element is a const *, then multiply count and array type
418 if next_idx < len(params) and '*' in params[next_idx].ty and 'const' in params[next_idx].ty.lower():
419 if '*' in p.ty:
420 ps.append('*%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
421 else:
422 ps.append('%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
423 skip_list.append(params[next_idx].name)
424 elif '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
425 if 'pData' == p.name:
426 if 'dataSize' == params[params.index(p)-1].name:
427 ps.append('dataSize')
428 elif 'counterCount' == params[params.index(p)-1].name:
429 ps.append('sizeof(%s)' % p.ty.strip('*').replace('const ', ''))
430 else:
431 ps.append('((pDataSize != NULL && pData != NULL) ? *pDataSize : 0)')
432 elif '**' in p.ty and 'void' in p.ty:
433 ps.append('sizeof(void*)')
434 elif 'void' in p.ty:
435 ps.append('sizeof(%s)' % p.name)
436 elif 'char' in p.ty:
437 ps.append('((%s != NULL) ? strlen(%s) + 1 : 0)' % (p.name, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]438 elif 'pDataSize' in p.name:
439 ps.append('((pDataSize != NULL) ? sizeof(size_t) : 0)')
440 elif 'IMAGE_SUBRESOURCE' in p.ty and 'pSubresource' == p.name:
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]441 ps.append('((pSubresource != NULL) ? sizeof(VkImage_SUBRESOURCE) : 0)')
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]442 else:
443 ps.append('sizeof(%s)' % (p.ty.strip('*').replace('const ', '')))
444 return ps
445
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]446 # Generate functions used to trace API calls and store the input and result data into a packet
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]447 # Here's the general flow of code insertion w/ option items flagged w/ "?"
448 # Result decl?
449 # Packet struct decl
450 # ?Special case : setup call to function first and do custom API call time tracking
451 # CREATE_PACKET
452 # Call (w/ result?)
453 # Assign packet values
454 # FINISH packet
455 # return result?
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]456 def _generate_trace_funcs(self):
457 func_body = []
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]458 manually_written_hooked_funcs = ['CreateInstance', 'EnumerateLayers', 'EnumerateGpus',
459 'AllocDescriptorSets', 'MapMemory', 'UnmapMemory',
460 'CmdPipelineBarrier', 'CmdWaitEvents']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]461 for proto in self.protos:
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]462 if proto.name in manually_written_hooked_funcs:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]463 func_body.append( '// __HOOKED_vk%s is manually written. Look in glvtrace_vk_trace.c\n' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]464 elif 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]465 raw_packet_update_list = [] # non-ptr elements placed directly into packet
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]466 ptr_packet_update_list = [] # ptr elements to be updated into packet
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]467 return_txt = ''
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]468 packet_size = []
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]469 in_data_size = False # flag when we need to capture local input size variable for in/out size
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]470 func_body.append('GLVTRACER_EXPORT %s VKAPI __HOOKED_vk%s(' % (proto.ret, proto.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]471 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 if NULL
472 if '[' in p.ty: # Correctly declare static arrays in function parameters
473 func_body.append(' %s %s[%s],' % (p.ty[:p.ty.find('[')], p.name, p.ty[p.ty.find('[')+1:p.ty.find(']')]))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]474 else:
475 func_body.append(' %s %s,' % (p.ty, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]476 if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
477 if 'pDataSize' in p.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]478 in_data_size = True;
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]479 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]480 if '[' in p.ty:
Tobin Ehlis8a5a85b2015-02-25 11:30:27 -0700[diff] [blame]481 array_str = p.ty[p.ty.find('[')+1:p.ty.find(']')]
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]482 raw_packet_update_list.append(' memcpy((void*)pPacket->color, color, %s * sizeof(%s));' % (array_str, p.ty.strip('*').replace('const ', '').replace('[%s]' % array_str, '')))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]483 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]484 raw_packet_update_list.append(' pPacket->%s = %s;' % (p.name, p.name))
485 # Get list of packet size modifiers due to ptr params
486 packet_size = self._get_packet_size(proto.params)
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]487 ptr_packet_update_list = self._get_packet_ptr_param_list(proto.params)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]488 func_body[-1] = func_body[-1].replace(',', ')')
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]489 # End of function declaration portion, begin function body
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]490 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]491 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]492 func_body.append(' %s result;' % proto.ret)
493 return_txt = 'result = '
494 if in_data_size:
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]495 func_body.append(' size_t _dataSize;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]496 func_body.append(' struct_vk%s* pPacket = NULL;' % proto.name)
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]497 # functions that have non-standard sequence of packet creation and calling real function
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]498 # NOTE: Anytime we call the function before CREATE_TRACE_PACKET, need to add custom code for correctly tracking API call time
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]499 if proto.name in ['CreateFramebuffer', 'CreateRenderPass', 'CreateDynamicViewportState',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]500 'CreateDescriptorRegion']:
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]501 # these are regular case as far as sequence of tracing but have some custom size element
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]502 if 'CreateFramebuffer' == proto.name:
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]503 func_body.append(' int dsSize = (pCreateInfo != NULL && pCreateInfo->pDepthStencilAttachment != NULL) ? sizeof(VkDepthStencilBindInfo) : 0;')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]504 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && pCreateInfo->pColorAttachments != NULL) ? pCreateInfo->colorAttachmentCount : 0;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]505 func_body.append(' CREATE_TRACE_PACKET(vkCreateFramebuffer, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkFramebuffer));')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]506 elif 'CreateRenderPass' == proto.name:
Jon Ashburn4e063af2015-04-15 15:45:22 -0600[diff] [blame^]507 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && (pCreateInfo->pColorFormats != NULL || pCreateInfo->pColorLayouts != NULL || pCreateInfo->pColorLoadOps != NULL || pCreateInfo->pColorStoreOps != NULL || pCreateInfo->pColorLoadClearValues != NULL)) ? pCreateInfo->colorAttachmentCount : 0;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]508 func_body.append(' CREATE_TRACE_PACKET(vkCreateRenderPass, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkRenderPass));')
Jon Ashburn8e7dcd02015-02-04 08:50:35 -0700[diff] [blame]509 elif 'CreateDynamicViewportState' == proto.name:
Courtney Goeltzenleuchterc6e32f92015-02-11 14:13:34 -0700[diff] [blame]510 func_body.append(' uint32_t vpsCount = (pCreateInfo != NULL && pCreateInfo->pViewports != NULL) ? pCreateInfo->viewportAndScissorCount : 0;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]511 func_body.append(' CREATE_TRACE_PACKET(vkCreateDynamicViewportState, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkDynamicVpState));')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]512 elif 'CreateDescriptorRegion' == proto.name:
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]513 func_body.append(' uint32_t rgCount = (pCreateInfo != NULL && pCreateInfo->pTypeCount != NULL) ? pCreateInfo->count : 0;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]514 func_body.append(' CREATE_TRACE_PACKET(vkCreateDescriptorRegion, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkDescriptorRegion));')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]515 func_body.append(' %sreal_vk%s;' % (return_txt, proto.c_call()))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]516 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]517 if (0 == len(packet_size)):
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]518 func_body.append(' CREATE_TRACE_PACKET(vk%s, 0);' % (proto.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]519 else:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]520 func_body.append(' CREATE_TRACE_PACKET(vk%s, %s);' % (proto.name, ' + '.join(packet_size)))
521 func_body.append(' %sreal_vk%s;' % (return_txt, proto.c_call()))
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]522 if in_data_size:
523 func_body.append(' _dataSize = (pDataSize == NULL || pData == NULL) ? 0 : *pDataSize;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]524 func_body.append(' pPacket = interpret_body_as_vk%s(pHeader);' % proto.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]525 func_body.append('\n'.join(raw_packet_update_list))
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]526 for pp_dict in ptr_packet_update_list: #buff_ptr_indices:
527 func_body.append(' %s;' % (pp_dict['add_txt']))
528 if 'void' not in proto.ret or '*' in proto.ret:
529 func_body.append(' pPacket->result = result;')
530 for pp_dict in ptr_packet_update_list:
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]531 if ('DeviceCreateInfo' not in proto.params[pp_dict['index']].ty) and ('APPLICATION_INFO' not in proto.params[pp_dict['index']].ty) and ('pUpdateChain' != proto.params[pp_dict['index']].name):
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]532 func_body.append(' %s;' % (pp_dict['finalize_txt']))
533 func_body.append(' FINISH_TRACE_PACKET();')
534 if 'AllocMemory' in proto.name:
535 func_body.append(' add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);')
536 elif 'FreeMemory' in proto.name:
537 func_body.append(' rm_handle_from_mem_info(mem);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]538 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]539 func_body.append(' return result;')
540 func_body.append('}\n')
541 return "\n".join(func_body)
542
543 def _generate_trace_funcs_ext(self, func_class='Wsi'):
544 thread_once_funcs = ['DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback', 'DbgSetGlobalOption']
545 func_body = []
546 for proto in self.protos:
547 if func_class in proto.name:
548 packet_update_txt = ''
549 return_txt = ''
550 packet_size = ''
551 buff_ptr_indices = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]552 func_body.append('GLVTRACER_EXPORT %s VKAPI __HOOKED_vk%s(' % (proto.ret, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]553 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL
554 func_body.append(' %s %s,' % (p.ty, p.name))
555 if 'Size' in p.name:
556 packet_size += p.name
557 if '*' in p.ty and 'pSysMem' != p.name:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]558 if 'char' in p.ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]559 packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]560 elif 'Size' not in packet_size:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]561 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]562 buff_ptr_indices.append(proto.params.index(p))
563 if 'pConnectionInfo' in p.name:
564 packet_size += '((pConnectionInfo->pConnection != NULL) ? sizeof(void *) : 0)'
565 else:
566 packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)
567 if '' == packet_size:
568 packet_size = '0'
569 else:
570 packet_size = packet_size.strip(' + ')
571 func_body[-1] = func_body[-1].replace(',', ')')
572 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]573 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]574 func_body.append(' %s result;' % proto.ret)
575 return_txt = 'result = '
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]576 func_body.append(' struct_vk%s* pPacket = NULL;' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]577 if proto.name in thread_once_funcs:
578 func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]579 func_body.append(' SEND_ENTRYPOINT_ID(vk%s);' % proto.name)
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]580 if 'DbgRegisterMsgCallback' in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]581 func_body.append(' CREATE_TRACE_PACKET(vk%s, sizeof(char));' % proto.name)
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]582 else:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]583 func_body.append(' CREATE_TRACE_PACKET(vk%s, %s);' % (proto.name, packet_size))
584 func_body.append(' %sreal_vk%s;' % (return_txt, proto.c_call()))
585 func_body.append(' pPacket = interpret_body_as_vk%s(pHeader);' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]586 func_body.append(packet_update_txt.strip('\n'))
587 for idx in buff_ptr_indices:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]588 if 'char' in proto.params[idx].ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]589 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), ((%s != NULL) ? strlen(%s) + 1 : 0), %s);' % (proto.params[idx].name, proto.params[idx].name, proto.params[idx].name, proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]590 elif 'Size' in proto.params[idx-1].name:
591 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s, %s);' % (proto.params[idx].name, proto.params[idx-1].name, proto.params[idx].name))
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]592 elif 'DbgRegisterMsgCallback' in proto.name:
593 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, 'char', proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]594 else:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]595 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, proto.params[idx].ty.strip('*').replace('const ', ''), proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]596 if 'WsiX11AssociateConnection' in proto.name:
597 func_body.append(' if (pConnectionInfo->pConnection != NULL) {')
598 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection), sizeof(void *), pConnectionInfo->pConnection);')
599 func_body.append(' glv_finalize_buffer_address(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection));')
600 func_body.append(' }')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]601 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]602 func_body.append(' pPacket->result = result;')
603 for idx in buff_ptr_indices:
604 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))
605 func_body.append(' FINISH_TRACE_PACKET();')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]606 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]607 func_body.append(' return result;')
608 func_body.append('}\n')
609 return "\n".join(func_body)
610
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]611 def _generate_packet_id_enum(self):
612 pid_enum = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]613 pid_enum.append('enum GLV_TRACE_PACKET_ID_VK')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]614 pid_enum.append('{')
615 first_func = True
616 for proto in self.protos:
617 if first_func:
618 first_func = False
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]619 pid_enum.append(' GLV_TPI_VK_vkApiVersion = GLV_TPI_BEGIN_API_HERE,')
620 pid_enum.append(' GLV_TPI_VK_vk%s,' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]621 else:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]622 pid_enum.append(' GLV_TPI_VK_vk%s,' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]623 pid_enum.append('};\n')
624 return "\n".join(pid_enum)
625
626 def _generate_stringify_func(self):
627 func_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]628 func_body.append('static const char *stringify_vk_packet_id(const enum GLV_TRACE_PACKET_ID_VK id, const glv_trace_packet_header* pHeader)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]629 func_body.append('{')
630 func_body.append(' static char str[1024];')
631 func_body.append(' switch(id) {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]632 func_body.append(' case GLV_TPI_VK_vkApiVersion:')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]633 func_body.append(' {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]634 func_body.append(' struct_vkApiVersion* pPacket = (struct_vkApiVersion*)(pHeader->pBody);')
635 func_body.append(' snprintf(str, 1024, "vkApiVersion = 0x%x", pPacket->version);')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]636 func_body.append(' return str;')
637 func_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]638 for proto in self.protos:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]639 func_body.append(' case GLV_TPI_VK_vk%s:' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]640 func_body.append(' {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]641 func_str = 'vk%s(' % proto.name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]642 print_vals = ''
643 create_func = False
644 if 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
645 create_func = True
646 for p in proto.params:
647 last_param = False
648 if (p.name == proto.params[-1].name):
649 last_param = True
650 if last_param and create_func: # last param of create func
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]651 (pft, pfi, ptr) = self._get_printf_params(p.ty,'pPacket->%s' % p.name, True)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]652 else:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]653 (pft, pfi, ptr) = self._get_printf_params(p.ty, 'pPacket->%s' % p.name, False)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]654 if last_param == True:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]655 func_str += '%s%s = %s)' % (ptr, p.name, pft)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]656 print_vals += ', %s' % (pfi)
657 else:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]658 func_str += '%s%s = %s, ' % (ptr, p.name, pft)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]659 print_vals += ', %s' % (pfi)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]660 func_body.append(' struct_vk%s* pPacket = (struct_vk%s*)(pHeader->pBody);' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]661 func_body.append(' snprintf(str, 1024, "%s"%s);' % (func_str, print_vals))
662 func_body.append(' return str;')
663 func_body.append(' }')
664 func_body.append(' default:')
665 func_body.append(' return NULL;')
666 func_body.append(' }')
667 func_body.append('};\n')
668 return "\n".join(func_body)
669
670 def _generate_interp_func(self):
671 interp_func_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]672 interp_func_body.append('static glv_trace_packet_header* interpret_trace_packet_vk(glv_trace_packet_header* pHeader)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]673 interp_func_body.append('{')
674 interp_func_body.append(' if (pHeader == NULL)')
675 interp_func_body.append(' {')
676 interp_func_body.append(' return NULL;')
677 interp_func_body.append(' }')
678 interp_func_body.append(' switch (pHeader->packet_id)')
679 interp_func_body.append(' {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]680 interp_func_body.append(' case GLV_TPI_VK_vkApiVersion:\n {')
681 interp_func_body.append(' return interpret_body_as_vkApiVersion(pHeader, TRUE)->header;\n }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]682 for proto in self.protos:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]683 interp_func_body.append(' case GLV_TPI_VK_vk%s:\n {' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]684 header_prefix = 'h'
685 if 'Wsi' in proto.name or 'Dbg' in proto.name:
686 header_prefix = 'pH'
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]687 interp_func_body.append(' return interpret_body_as_vk%s(pHeader)->%seader;\n }' % (proto.name, header_prefix))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]688 interp_func_body.append(' default:')
689 interp_func_body.append(' return NULL;')
690 interp_func_body.append(' }')
691 interp_func_body.append(' return NULL;')
692 interp_func_body.append('}')
693 return "\n".join(interp_func_body)
694
695 def _generate_struct_util_funcs(self):
696 pid_enum = []
697 pid_enum.append('//=============================================================================')
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]698 pid_enum.append('static void add_VkApplicationInfo_to_packet(glv_trace_packet_header* pHeader, VkApplicationInfo** ppStruct, const VkApplicationInfo *pInStruct)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]699 pid_enum.append('{')
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]700 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkApplicationInfo), pInStruct);')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]701 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen(pInStruct->pAppName) + 1, pInStruct->pAppName);')
702 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen(pInStruct->pEngineName) + 1, pInStruct->pEngineName);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]703 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')
704 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')
705 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
706 pid_enum.append('};\n')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]707 pid_enum.append('//=============================================================================\n')
Jon Ashburn4e063af2015-04-15 15:45:22 -0600[diff] [blame^]708 pid_enum.append('static void add_VkInstanceCreateInfo_to_packet(glv_trace_packet_header* pHeader, VkInstanceCreateInfo** ppStruct, VkInstanceCreateInfo *pInStruct)')
709 pid_enum.append('{')
710 pid_enum.append(' uint32_t i;')
711 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkInstanceCreateInfo), pInStruct);')
712 pid_enum.append(' add_VkApplicationInfo_to_packet(pHeader, (VkApplicationInfo**)&((*ppStruct)->pAppInfo), pInStruct->pAppInfo);')
713 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAllocCb), sizeof(VkAllocCallbacks), pInStruct->pAllocCb);')
714 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAllocCb));')
715 pid_enum.append(' if (pInStruct->extensionCount > 0) ')
716 pid_enum.append(' {')
717 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char *), pInStruct->ppEnabledExtensionNames);')
718 pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')
719 pid_enum.append(' {')
720 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen(pInStruct->ppEnabledExtensionNames[i]) + 1, pInStruct->ppEnabledExtensionNames[i]);')
721 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')
722 pid_enum.append(' }')
723 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
724 pid_enum.append(' }')
725 pid_enum.append(' VkLayerCreateInfo *pNext = ( VkLayerCreateInfo *) pInStruct->pNext;')
726 pid_enum.append(' while (pNext != NULL)')
727 pid_enum.append(' {')
728 pid_enum.append(' if ((pNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
729 pid_enum.append(' {')
730 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->pNext)), sizeof(VkLayerCreateInfo), pNext);')
731 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->pNext)));')
732 pid_enum.append(' VkLayerCreateInfo **ppOutStruct = (VkLayerCreateInfo **) &((*ppStruct)->pNext);')
733 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppOutStruct)->ppActiveLayerNames), pNext->layerCount * sizeof(char *), pNext->ppActiveLayerNames);')
734 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
735 pid_enum.append(' {')
736 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])), strlen(pNext->ppActiveLayerNames[i]) + 1, pNext->ppActiveLayerNames[i]);')
737 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])));')
738 pid_enum.append(' }')
739 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppOutStruct)->ppActiveLayerNames);')
740 pid_enum.append(' }')
741 pid_enum.append(' pNext = ( VkLayerCreateInfo *) pNext->pNext;')
742 pid_enum.append(' }')
743 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')
744 pid_enum.append('}\n')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]745 pid_enum.append('static void add_VkDeviceCreateInfo_to_packet(glv_trace_packet_header* pHeader, VkDeviceCreateInfo** ppStruct, const VkDeviceCreateInfo *pInStruct)')
Jon Ashburn29669a42015-04-04 14:52:07 -0600[diff] [blame]746 pid_enum.append('{')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]747 pid_enum.append(' uint32_t i;')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]748 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkDeviceCreateInfo), pInStruct);')
749 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(VkDeviceQueueCreateInfo), pInStruct->pRequestedQueues);')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]750 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')
Jon Ashburn29669a42015-04-04 14:52:07 -0600[diff] [blame]751 pid_enum.append(' if (pInStruct->extensionCount > 0) ')
752 pid_enum.append(' {')
753 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char *), pInStruct->ppEnabledExtensionNames);')
754 pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')
755 pid_enum.append(' {')
756 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen(pInStruct->ppEnabledExtensionNames[i]) + 1, pInStruct->ppEnabledExtensionNames[i]);')
757 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')
758 pid_enum.append(' }')
759 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
760 pid_enum.append(' }')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]761 pid_enum.append(' VkLayerCreateInfo *pNext = ( VkLayerCreateInfo *) pInStruct->pNext;')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]762 pid_enum.append(' while (pNext != NULL)')
763 pid_enum.append(' {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]764 pid_enum.append(' if ((pNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]765 pid_enum.append(' {')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]766 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->pNext)), sizeof(VkLayerCreateInfo), pNext);')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]767 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->pNext)));')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]768 pid_enum.append(' VkLayerCreateInfo **ppOutStruct = (VkLayerCreateInfo **) &((*ppStruct)->pNext);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]769 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppOutStruct)->ppActiveLayerNames), pNext->layerCount * sizeof(char *), pNext->ppActiveLayerNames);')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]770 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
771 pid_enum.append(' {')
772 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])), strlen(pNext->ppActiveLayerNames[i]) + 1, pNext->ppActiveLayerNames[i]);')
773 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])));')
774 pid_enum.append(' }')
775 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppOutStruct)->ppActiveLayerNames);')
776 pid_enum.append(' }')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]777 pid_enum.append(' pNext = ( VkLayerCreateInfo *) pNext->pNext;')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]778 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]779 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')
780 pid_enum.append('}\n')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]781 pid_enum.append('static VkDeviceCreateInfo* interpret_VkDeviceCreateInfo(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]782 pid_enum.append('{')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]783 pid_enum.append(' VkDeviceCreateInfo* pVkDeviceCreateInfo = (VkDeviceCreateInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')
784 pid_enum.append(' if (pVkDeviceCreateInfo != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]785 pid_enum.append(' {')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]786 pid_enum.append(' uint32_t i;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]787 pid_enum.append(' const char** pNames;')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]788 pid_enum.append(' pVkDeviceCreateInfo->pRequestedQueues = (const VkDeviceQueueCreateInfo *)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->pRequestedQueues);\n')
789 pid_enum.append(' if (pVkDeviceCreateInfo->extensionCount > 0)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]790 pid_enum.append(' {')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]791 pid_enum.append(' pVkDeviceCreateInfo->ppEnabledExtensionNames = (const char *const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->ppEnabledExtensionNames);')
792 pid_enum.append(' pNames = (const char**)pVkDeviceCreateInfo->ppEnabledExtensionNames;')
793 pid_enum.append(' for (i = 0; i < pVkDeviceCreateInfo->extensionCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]794 pid_enum.append(' {')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]795 pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pVkDeviceCreateInfo->ppEnabledExtensionNames[i]));')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]796 pid_enum.append(' }')
797 pid_enum.append(' }')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]798 pid_enum.append(' VkLayerCreateInfo *pNext = ( VkLayerCreateInfo *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkDeviceCreateInfo->pNext);')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]799 pid_enum.append(' while (pNext != NULL)')
800 pid_enum.append(' {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]801 pid_enum.append(' if ((pNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]802 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]803 pid_enum.append(' pNext->ppActiveLayerNames = (const char**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames));')
804 pid_enum.append(' pNames = (const char**)pNext->ppActiveLayerNames;')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]805 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
806 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]807 pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames[i]));')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]808 pid_enum.append(' }')
809 pid_enum.append(' }')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]810 pid_enum.append(' pNext = ( VkLayerCreateInfo *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]811 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]812 pid_enum.append(' }\n')
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]813 pid_enum.append(' return pVkDeviceCreateInfo;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]814 pid_enum.append('}\n')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]815 pid_enum.append('static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, VkPipelineShader* pShader)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]816 pid_enum.append('{')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]817 pid_enum.append(' if (pShader != NULL)')
818 pid_enum.append(' {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]819 pid_enum.append(' // constant buffers')
820 pid_enum.append(' if (pShader->linkConstBufferCount > 0)')
821 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]822 pid_enum.append(' uint32_t i;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]823 pid_enum.append(' pShader->pLinkConstBufferInfo = (const VkLinkConstBuffer*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]824 pid_enum.append(' for (i = 0; i < pShader->linkConstBufferCount; i++)')
825 pid_enum.append(' {')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]826 pid_enum.append(' VkLinkConstBuffer* pBuffer = (VkLinkConstBuffer*)pShader->pLinkConstBufferInfo;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]827 pid_enum.append(' pBuffer[i].pBufferData = (const void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo[i].pBufferData);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]828 pid_enum.append(' }')
829 pid_enum.append(' }')
830 pid_enum.append(' }')
831 pid_enum.append('}\n')
832 pid_enum.append('//=============================================================================')
833 return "\n".join(pid_enum)
834
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]835 # Interpret functions used on replay to read in packets and interpret their contents
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]836 # This code gets generated into glv_vk_vk_structs.h file
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]837 def _generate_interp_funcs(self):
838 # Custom txt for given function and parameter. First check if param is NULL, then insert txt if not
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]839 # 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
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]840 custom_case_dict = { 'CreateInstance' : {'param': 'pAppInfo', 'txt': ['VkApplicationInfo* pInfo = (VkApplicationInfo*)pPacket->pAppInfo;\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]841 'pInfo->pAppName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);\n',
842 'pInfo->pEngineName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pEngineName);']},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]843 'CreateShader' : {'param': 'pCreateInfo', 'txt': ['VkShaderCreateInfo* pInfo = (VkShaderCreateInfo*)pPacket->pCreateInfo;\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]844 'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]845 'CreateDynamicViewportState' : {'param': 'pCreateInfo', 'txt': ['VkDynamicVpStateCreateInfo* pInfo = (VkDynamicVpStateCreateInfo*)pPacket->pCreateInfo;\n',
846 'pInfo->pViewports = (VkViewport*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pViewports);\n',
847 'pInfo->pScissors = (VkRect*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pScissors);']},
848 'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['VkFramebufferCreateInfo* pInfo = (VkFramebufferCreateInfo*)pPacket->pCreateInfo;\n',
849 'pInfo->pColorAttachments = (VkColorAttachmentBindInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',
850 'pInfo->pDepthStencilAttachment = (VkDepthStencilBindInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},
851 'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': ['VkRenderPassCreateInfo* pInfo = (VkRenderPassCreateInfo*)pPacket->pCreateInfo;\n',
Jon Ashburn4e063af2015-04-15 15:45:22 -0600[diff] [blame^]852 'pInfo->pColorLayouts = (VkImageLayout*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLayouts);\n',
853 'pInfo->pColorFormats = (VkFormat*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorFormats);\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]854 'pInfo->pColorLoadOps = (VkAttachmentLoadOp*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadOps);\n',
855 'pInfo->pColorStoreOps = (VkAttachmentStoreOp*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorStoreOps);\n',
856 'pInfo->pColorLoadClearValues = (VkClearColor*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadClearValues);\n']},
857 'CreateDescriptorPool' : {'param': 'pCreateInfo', 'txt': ['VkDescriptorPoolCreateInfo* pInfo = (VkDescriptorPoolCreateInfo*)pPacket->pCreateInfo;\n',
858 'pInfo->pTypeCount = (VkDescriptorTypeCount*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pTypeCount);\n']},
859 'CmdWaitEvents' : {'param': 'pWaitInfo', 'txt': ['VkEventWaitInfo* pInfo = (VkEventWaitInfo*)pPacket->pWaitInfo;\n',
860 'pInfo->pEvents = (VkEvent*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->pEvents);\n',
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]861 'pInfo->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->ppMemBarriers);\n',
862 'uint32_t i;\n',
863 'for (i = 0; i < pInfo->memBarrierCount; i++) {\n',
864 ' void** ppLocalMemBarriers = (void**)&pInfo->ppMemBarriers[i];\n',
865 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->ppMemBarriers[i]);\n',
866 '}']},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]867 'CmdPipelineBarrier' : {'param': 'pBarrier', 'txt': ['VkPipelineBarrier* pBarrier = (VkPipelineBarrier*)pPacket->pBarrier;\n',
868 'pBarrier->pEvents = (VkPipeEvent*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->pEvents);\n',
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]869 'pBarrier->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->ppMemBarriers);\n',
870 'uint32_t i;\n',
871 'for (i = 0; i < pBarrier->memBarrierCount; i++) {\n',
872 ' void** ppLocalMemBarriers = (void**)&pBarrier->ppMemBarriers[i];\n',
873 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pBarrier->ppMemBarriers[i]);\n',
874 '}']},
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]875 'CreateDescriptorSetLayout' : {'param': 'pSetLayoutInfoList', 'txt': ['if (pPacket->pSetLayoutInfoList->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) {\n',
876 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
877 ' void** ppNextVoidPtr = (void**)&(pPacket->pSetLayoutInfoList->pNext);\n',
878 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSetLayoutInfoList->pNext);\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]879 ' VkDescriptorSetLayoutCreateInfo* pNext = (VkDescriptorSetLayoutCreateInfo*)pPacket->pSetLayoutInfoList->pNext;\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]880 ' while (NULL != pNext)\n', ' {\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]881 ' switch(pNext->sType)\n', ' {\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]882 ' case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]883 ' {\n' ,
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]884 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
885 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]886 ' break;\n',
887 ' }\n',
888 ' default:\n',
889 ' {\n',
890 ' glv_LogError("Encountered an unexpected type in descriptor set layout create list.\\n");\n',
891 ' pPacket->header = NULL;\n',
892 ' pNext->pNext = NULL;\n',
893 ' }\n',
Jon Ashburn7fd7eff2015-02-04 10:55:47 -0700[diff] [blame]894 ' }\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]895 ' pNext = (VkDescriptorSetLayoutCreateInfo*)pNext->pNext;\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]896 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]897 '} else {\n',
898 ' // This is unexpected.\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]899 ' glv_LogError("CreateDescriptorSetLayout must have LayoutInfoList stype of VK_STRCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO\\n");\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]900 ' pPacket->header = NULL;\n',
Jon Ashburn7fd7eff2015-02-04 10:55:47 -0700[diff] [blame]901 '}']},
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]902 'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['if (pPacket->pBeginInfo->sType == VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO) {\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]903 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]904 ' VkCmdBufferGraphicsBeginInfo** ppNext = (VkCmdBufferGraphicsBeginInfo**)&(pPacket->pBeginInfo->pNext);\n',
905 ' *ppNext = (VkCmdBufferGraphicsBeginInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',
906 ' VkCmdBufferGraphicsBeginInfo* pNext = *ppNext;\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]907 ' while (NULL != pNext)\n', ' {\n',
908 ' switch(pNext->sType)\n', ' {\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]909 ' case VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]910 ' {\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]911 ' ppNext = (VkCmdBufferGraphicsBeginInfo**) &pNext->pNext;\n',
912 ' *ppNext = (VkCmdBufferGraphicsBeginInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]913 ' break;\n',
914 ' }\n',
915 ' default:\n',
916 ' {\n',
917 ' glv_LogError("Encountered an unexpected type in begin command buffer list.\\n");\n',
918 ' pPacket->header = NULL;\n',
919 ' pNext->pNext = NULL;\n',
920 ' }\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]921 ' }\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]922 ' pNext = (VkCmdBufferGraphicsBeginInfo*)pNext->pNext;\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]923 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]924 '} else {\n',
925 ' // This is unexpected.\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]926 ' glv_LogError("BeginCommandBuffer must have BeginInfo stype of VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO.\\n");\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]927 ' pPacket->header = NULL;\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]928 '}']},
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]929 'AllocMemory' : {'param': 'pAllocInfo', 'txt': ['if (pPacket->pAllocInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO) {\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]930 ' VkMemoryAllocInfo** ppNext = (VkMemoryAllocInfo**) &(pPacket->pAllocInfo->pNext);\n',
931 ' *ppNext = (VkMemoryAllocInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocInfo->pNext);\n',
932 ' VkMemoryAllocInfo* pNext = (VkMemoryAllocInfo*) *ppNext;\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]933 ' while (NULL != pNext)\n', ' {\n',
934 ' switch(pNext->sType)\n', ' {\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]935 ' case VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:\n',
936 ' case VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]937 ' {\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]938 ' ppNext = (VkMemoryAllocInfo **) &(pNext->pNext);\n',
939 ' *ppNext = (VkMemoryAllocInfo*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]940 ' break;\n',
941 ' }\n',
942 ' default:\n',
943 ' {\n',
944 ' glv_LogError("Encountered an unexpected type alloc memory list.\\n");\n',
945 ' pPacket->header = NULL;\n',
946 ' pNext->pNext = NULL;\n',
947 ' }\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]948 ' }\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]949 ' pNext = (VkMemoryAllocInfo*)pNext->pNext;\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]950 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]951 '} else {\n',
952 ' // This is unexpected.\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]953 ' glv_LogError("AllocMemory must have AllocInfo stype of VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO.\\n");\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]954 ' pPacket->header = NULL;\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]955 '}']},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]956 'UpdateDescriptors' : {'param': 'pUpdateChain', 'txt': ['VkUpdateSamplers* pNext = (VkUpdateSamplers*)pPacket->pUpdateChain;\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]957 'while ((NULL != pNext) && (VK_NULL_HANDLE != pNext))\n', '{\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]958 ' switch(pNext->sType)\n', ' {\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]959 ' case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]960 ' {\n',
961 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
962 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
963 ' break;\n',
964 ' }\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]965 ' case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]966 ' {\n',
967 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]968 ' VkUpdateSamplers* pUS = (VkUpdateSamplers*)pNext;\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]969 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]970 ' pUS->pSamplers = (VK_SAMPLER*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUS->pSamplers);\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]971 ' break;\n',
972 ' }\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]973 ' case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]974 ' {\n',
975 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]976 ' VkUpdateSamplerTextures* pUST = (VkUpdateSamplerTextures*)pNext;\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]977 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]978 ' pUST->pSamplerImageViews = (VK_SAMPLER_IMAGE_VIEW_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews);\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]979 ' uint32_t i;\n',
980 ' for (i = 0; i < pUST->count; i++) {\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]981 ' VkImageViewAttachInfo** ppLocalImageView = (VkImageViewAttachInfo**)&pUST->pSamplerImageViews[i].pImageView;\n',
982 ' *ppLocalImageView = (VkImageViewAttachInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews[i].pImageView);\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]983 ' }\n',
984 ' break;\n',
985 ' }\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]986 ' case VK_STRUCTURE_TYPE_UPDATE_IMAGES:\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]987 ' {\n',
988 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]989 ' VkUpdateImages* pUI = (VkUpdateImages*)pNext;\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]990 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]991 ' VkImageViewAttachInfo** ppLocalImageView = (VkImageViewAttachInfo**)&pUI->pImageViews;\n',
992 ' *ppLocalImageView = (VkImageViewAttachInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews);\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]993 ' uint32_t i;\n',
994 ' for (i = 0; i < pUI->count; i++) {\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]995 ' VkImageViewAttachInfo** ppLocalImageViews = (VkImageViewAttachInfo**)&pUI->pImageViews[i];\n',
996 ' *ppLocalImageViews = (VkImageViewAttachInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews[i]);\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]997 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]998 ' break;\n',
999 ' }\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1000 ' case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1001 ' {\n',
1002 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1003 ' VkUpdateBuffers* pUB = (VkUpdateBuffers*)pNext;\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1004 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1005 ' VkBufferViewAttachInfo** ppLocalBufferView = (VkBufferViewAttachInfo**)&pUB->pBufferViews;\n',
1006 ' *ppLocalBufferView = (VkBufferViewAttachInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews);\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1007 ' uint32_t i;\n',
1008 ' for (i = 0; i < pUB->count; i++) {\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1009 ' VkBufferViewAttachInfo** ppLocalBufferViews = (VkBufferViewAttachInfo**)&pUB->pBufferViews[i];\n',
1010 ' *ppLocalBufferViews = (VkBufferViewAttachInfo*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews[i]);\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1011 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1012 ' break;\n',
1013 ' }\n',
1014 ' default:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1015 ' {\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1016 ' glv_LogError("Encountered an unexpected type in update descriptors pUpdateChain.\\n");\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1017 ' pPacket->header = NULL;\n',
1018 ' pNext->pNext = NULL;\n',
1019 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1020 ' }\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1021 ' pNext = (VkUpdateSamplers*)pNext->pNext;\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1022 '}']},
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1023 'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['if (pPacket->pCreateInfo->sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) {\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1024 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1025 ' void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',
1026 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1027 ' VkPipelineShaderStageCreateInfo* pNext = (VkPipelineShaderStageCreateInfo*)pPacket->pCreateInfo->pNext;\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1028 ' while ((NULL != pNext) && (VK_NULL_HANDLE != pNext))\n', '{\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1029 ' switch(pNext->sType)\n', ' {\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1030 ' case VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',
1031 ' case VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',
1032 ' case VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',
1033 ' case VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',
1034 ' case VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',
1035 ' case VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1036 ' {\n',
1037 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1038 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1039 ' break;\n',
1040 ' }\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1041 ' case VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1042 ' {\n',
1043 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1044 ' VkPipelineCbStateCreateInfo *pCb = (VkPipelineCbStateCreateInfo *) pNext;\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1045 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1046 ' pCb->pAttachments = (VkPipelineCbAttachmentState*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pCb->pAttachments);\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1047 ' break;\n',
1048 ' }\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1049 ' case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1050 ' {\n',
1051 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1052 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1053 ' interpret_pipeline_shader(pHeader, &pNext->shader);\n',
1054 ' break;\n',
1055 ' }\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1056 ' case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1057 ' {\n',
1058 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1059 ' VkPipelineVertexInputCreateInfo *pVi = (VkPipelineVertexInputCreateInfo *) pNext;\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1060 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1061 ' pVi->pVertexBindingDescriptions = (VkVertexInputBindingDescription*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',
1062 ' pVi->pVertexAttributeDescriptions = (VkVertexInputAttributeDescription*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1063 ' break;\n',
1064 ' }\n',
1065 ' default:\n',
1066 ' {\n',
1067 ' glv_LogError("Encountered an unexpected type in pipeline state list.\\n");\n',
1068 ' pPacket->header = NULL;\n',
1069 ' pNext->pNext = NULL;\n',
1070 ' }\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1071 ' }\n',
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1072 ' pNext = (VkPipelineShaderStageCreateInfo*)pNext->pNext;\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1073 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1074 '} else {\n',
1075 ' // This is unexpected.\n',
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1076 ' glv_LogError("CreateGraphicsPipeline must have CreateInfo stype of VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.\\n");\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1077 ' pPacket->header = NULL;\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1078 '}']},
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1079 'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (VkPipelineShader*)(&pPacket->pCreateInfo->cs));']}}
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1080 if_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1081 if_body.append('typedef struct struct_vkApiVersion {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1082 if_body.append(' glv_trace_packet_header* header;')
1083 if_body.append(' uint32_t version;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1084 if_body.append('} struct_vkApiVersion;\n')
1085 if_body.append('static struct_vkApiVersion* interpret_body_as_vkApiVersion(glv_trace_packet_header* pHeader, BOOL check_version)')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1086 if_body.append('{')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1087 if_body.append(' struct_vkApiVersion* pPacket = (struct_vkApiVersion*)pHeader->pBody;')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1088 if_body.append(' pPacket->header = pHeader;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1089 if_body.append(' if (check_version && pPacket->version != VK_API_VERSION)')
1090 if_body.append(' glv_LogError("Trace file from older VK version 0x%x, vk replayer built from version 0x%x, replayer may fail\\n", pPacket->version, VK_API_VERSION);')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1091 if_body.append(' return pPacket;')
1092 if_body.append('}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1093 for proto in self.protos:
1094 if 'Wsi' not in proto.name and 'Dbg' not in proto.name:
1095 if 'UnmapMemory' == proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1096 proto.params.append(vulkan.Param("void*", "pData"))
1097 if_body.append('typedef struct struct_vk%s {' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1098 if_body.append(' glv_trace_packet_header* header;')
1099 for p in proto.params:
1100 if '[4]' in p.ty:
1101 if_body.append(' %s %s[4];' % (p.ty.strip('[4]'), p.name))
1102 else:
1103 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1104 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1105 if_body.append(' %s result;' % proto.ret)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1106 if_body.append('} struct_vk%s;\n' % proto.name)
1107 if_body.append('static struct_vk%s* interpret_body_as_vk%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1108 if_body.append('{')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1109 if_body.append(' struct_vk%s* pPacket = (struct_vk%s*)pHeader->pBody;' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1110 if_body.append(' pPacket->header = pHeader;')
1111 for p in proto.params:
1112 if '*' in p.ty:
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600[diff] [blame]1113 if 'DeviceCreateInfo' in p.ty:
1114 if_body.append(' pPacket->%s = interpret_VkDeviceCreateInfo(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1115 else:
1116 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]1117 # TODO : Generalize this custom code to kill dict data struct above.
1118 # Really the point of this block is to catch params w/ embedded ptrs to structs and chains of structs
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1119 if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
1120 if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])
1121 if_body.append(' {')
1122 if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))
1123 if_body.append(' }')
1124 if_body.append(' return pPacket;')
1125 if_body.append('}\n')
1126 return "\n".join(if_body)
1127
1128 def _generate_interp_funcs_ext(self, func_class='Wsi'):
1129 if_body = []
1130 for proto in self.protos:
1131 if func_class in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1132 if_body.append('typedef struct struct_vk%s {' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1133 if_body.append(' glv_trace_packet_header* pHeader;')
1134 for p in proto.params:
1135 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1136 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1137 if_body.append(' %s result;' % proto.ret)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1138 if_body.append('} struct_vk%s;\n' % proto.name)
1139 if_body.append('static struct_vk%s* interpret_body_as_vk%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1140 if_body.append('{')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1141 if_body.append(' struct_vk%s* pPacket = (struct_vk%s*)pHeader->pBody;' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1142 if_body.append(' pPacket->pHeader = pHeader;')
1143 for p in proto.params:
1144 if '*' in p.ty:
1145 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
1146 if_body.append(' return pPacket;')
1147 if_body.append('}\n')
1148 return "\n".join(if_body)
1149
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1150 def _generate_replay_func_ptrs(self):
1151 xf_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1152 xf_body.append('struct vkFuncs {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1153 xf_body.append(' void init_funcs(void * libHandle);')
1154 xf_body.append(' void *m_libHandle;\n')
1155 for proto in self.protos:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1156 xf_body.append(' typedef %s( VKAPI * type_vk%s)(' % (proto.ret, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1157 for p in proto.params:
1158 if '[4]' in p.ty:
1159 xf_body.append(' %s %s[4],' % (p.ty.strip('[4]'), p.name))
1160 else:
1161 xf_body.append(' %s %s,' % (p.ty, p.name))
1162 xf_body[-1] = xf_body[-1].replace(',', ');')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1163 xf_body.append(' type_vk%s real_vk%s;' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1164 xf_body.append('};')
1165 return "\n".join(xf_body)
1166
1167 def _map_decl(self, type1, type2, name):
1168 return ' std::map<%s, %s> %s;' % (type1, type2, name)
1169
1170 def _add_to_map_decl(self, type1, type2, name):
1171 txt = ' void add_to_map(%s* pTraceVal, %s* pReplayVal)\n {\n' % (type1, type2)
1172 txt += ' assert(pTraceVal != NULL);\n'
1173 txt += ' assert(pReplayVal != NULL);\n'
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1174 txt += ' %s[*pTraceVal] = *pReplayVal;\n }\n' % name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1175 return txt
1176
1177 def _rm_from_map_decl(self, ty, name):
1178 txt = ' void rm_from_map(const %s& key)\n {\n' % (ty)
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1179 txt += ' %s.erase(key);\n }\n' % name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1180 return txt
1181
1182 def _remap_decl(self, ty, name):
1183 txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)
1184 txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1185 txt += ' return (q == %s.end()) ? VK_NULL_HANDLE : q->second;\n }\n' % name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1186 return txt
1187
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1188 def _generate_replay_objMemory_funcs(self):
1189 rof_body = []
1190 # Custom code for memory mapping functions for app writes into mapped memory
1191 rof_body.append('// memory mapping functions for app writes into mapped memory')
1192 rof_body.append(' bool isPendingAlloc()')
1193 rof_body.append(' {')
1194 rof_body.append(' return m_pendingAlloc;')
1195 rof_body.append(' }')
1196 rof_body.append('')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1197 rof_body.append(' void setAllocInfo(const VkMemoryAllocInfo *info, const bool pending)')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1198 rof_body.append(' {')
1199 rof_body.append(' m_pendingAlloc = pending;')
1200 rof_body.append(' m_allocInfo = *info;')
1201 rof_body.append(' }')
1202 rof_body.append('')
1203 rof_body.append(' void setMemoryDataAddr(void *pBuf)')
1204 rof_body.append(' {')
1205 rof_body.append(' if (m_mapRange.empty())')
1206 rof_body.append(' {')
1207 rof_body.append(' glv_LogError("gpuMemory::setMemoryDataAddr() m_mapRange is empty\\n");')
1208 rof_body.append(' return;')
1209 rof_body.append(' }')
1210 rof_body.append(' MapRange mr = m_mapRange.back();')
1211 rof_body.append(' if (mr.pData != NULL)')
1212 rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() data already mapped overwrite old mapping\\n");')
1213 rof_body.append(' else if (pBuf == NULL)')
1214 rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() adding NULL pointer\\n");')
1215 rof_body.append(' mr.pData = pBuf;')
1216 rof_body.append(' }')
1217 rof_body.append('')
1218 rof_body.append(' void setMemoryMapRange(void *pBuf, const size_t size, const size_t offset, const bool pending)')
1219 rof_body.append(' {')
1220 rof_body.append(' MapRange mr;')
1221 rof_body.append(' mr.pData = pBuf;')
1222 rof_body.append(' mr.size = size;')
1223 rof_body.append(' mr.offset = offset;')
1224 rof_body.append(' mr.pending = pending;')
1225 rof_body.append(' m_mapRange.push_back(mr);')
1226 rof_body.append(' }')
1227 rof_body.append('')
1228 rof_body.append(' void copyMappingData(const void* pSrcData)')
1229 rof_body.append(' {')
1230 rof_body.append(' if (m_mapRange.empty())')
1231 rof_body.append(' {')
1232 rof_body.append(' glv_LogError("gpuMemory::copyMappingData() m_mapRange is empty\\n");')
1233 rof_body.append(' return;')
1234 rof_body.append(' }')
1235 rof_body.append(' MapRange mr = m_mapRange.back();')
1236 rof_body.append(' if (!pSrcData || !mr.pData)')
1237 rof_body.append(' {')
1238 rof_body.append(' if (!pSrcData)')
1239 rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null src pointer\\n");')
1240 rof_body.append(' else')
1241 rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null dest pointer size=%u\\n", m_allocInfo.allocationSize);')
1242 rof_body.append(' m_mapRange.pop_back();')
1243 rof_body.append(' return;')
1244 rof_body.append(' }')
1245 rof_body.append(' memcpy(mr.pData, pSrcData, m_allocInfo.allocationSize);')
1246 rof_body.append(' if (!mr.pending)')
1247 rof_body.append(' m_mapRange.pop_back();')
1248 rof_body.append(' }')
1249 rof_body.append('')
1250 rof_body.append(' size_t getMemoryMapSize()')
1251 rof_body.append(' {')
1252 rof_body.append(' return (!m_mapRange.empty()) ? m_mapRange.back().size : 0;')
1253 rof_body.append(' }\n')
1254 return "\n".join(rof_body)
1255
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1256 def _generate_replay_objmapper_class(self):
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1257 # Create dict mapping member var names to VK type (i.e. 'm_imageViews' : 'VkImage_VIEW')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1258 obj_map_dict = {}
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1259 for ty in vulkan.object_type_list:
1260 if ty in vulkan.object_parent_list:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1261 continue
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1262 if (ty.startswith('Vk')):
1263 mem_var = ty.replace('Vk', '').lower()
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1264 mem_var_list = mem_var.split('_')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1265 mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))
1266 obj_map_dict[mem_var] = ty
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1267 rc_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1268 rc_body.append('typedef struct _VKAllocInfo {')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1269 rc_body.append(' VkGpuSize size;')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1270 rc_body.append(' void *pData;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1271 rc_body.append('} VKAllocInfo;')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1272 rc_body.append('')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1273 rc_body.append('class objMemory {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1274 rc_body.append('public:')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1275 rc_body.append(' objMemory() : m_numAllocations(0), m_pMemReqs(NULL) {}')
1276 rc_body.append(' ~objMemory() { free(m_pMemReqs);}')
1277 rc_body.append(' void setCount(const uint32_t num)')
1278 rc_body.append(' {')
1279 rc_body.append(' m_numAllocations = num;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1280 rc_body.append(' }\n')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1281 rc_body.append(' void setReqs(const VkMemoryRequirements *pReqs, const uint32_t num)')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1282 rc_body.append(' {')
1283 rc_body.append(' if (m_numAllocations != num && m_numAllocations != 0)')
1284 rc_body.append(' glv_LogError("objMemory::setReqs, internal mismatch on number of allocations");')
1285 rc_body.append(' if (m_pMemReqs == NULL && pReqs != NULL)')
1286 rc_body.append(' {')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1287 rc_body.append(' m_pMemReqs = (VkMemoryRequirements *) glv_malloc(num * sizeof(VkMemoryRequirements));')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1288 rc_body.append(' if (m_pMemReqs == NULL)')
1289 rc_body.append(' {')
1290 rc_body.append(' glv_LogError("objMemory::setReqs out of memory");')
1291 rc_body.append(' return;')
1292 rc_body.append(' }')
1293 rc_body.append(' memcpy(m_pMemReqs, pReqs, num);')
1294 rc_body.append(' }')
1295 rc_body.append(' }\n')
1296 rc_body.append('private:')
1297 rc_body.append(' uint32_t m_numAllocations;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1298 rc_body.append(' VkMemoryRequirements *m_pMemReqs;')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1299 rc_body.append('};')
1300 rc_body.append('')
1301 rc_body.append('class gpuMemory {')
1302 rc_body.append('public:')
1303 rc_body.append(' gpuMemory() : m_pendingAlloc(false) {m_allocInfo.allocationSize = 0;}')
1304 rc_body.append(' ~gpuMemory() {}')
1305 rc_body.append(self._generate_replay_objMemory_funcs())
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1306 rc_body.append('private:')
1307 rc_body.append(' bool m_pendingAlloc;')
1308 rc_body.append(' struct MapRange {')
1309 rc_body.append(' bool pending;')
1310 rc_body.append(' size_t size;')
1311 rc_body.append(' size_t offset;')
1312 rc_body.append(' void* pData;')
1313 rc_body.append(' };')
1314 rc_body.append(' std::vector<MapRange> m_mapRange;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1315 rc_body.append(' VkMemoryAllocInfo m_allocInfo;')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1316 rc_body.append('};')
1317 rc_body.append('')
1318 rc_body.append('typedef struct _imageObj {')
1319 rc_body.append(' objMemory imageMem;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1320 rc_body.append(' VkImage replayImage;')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1321 rc_body.append(' } imageObj;')
1322 rc_body.append('')
1323 rc_body.append('typedef struct _bufferObj {')
1324 rc_body.append(' objMemory bufferMem;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1325 rc_body.append(' VkBuffer replayBuffer;')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1326 rc_body.append(' } bufferObj;')
1327 rc_body.append('')
1328 rc_body.append('typedef struct _gpuMemObj {')
1329 rc_body.append(' gpuMemory *pGpuMem;')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1330 rc_body.append(' VkGpuMemory replayGpuMem;')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1331 rc_body.append(' } gpuMemObj;')
1332 rc_body.append('')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1333 rc_body.append('class vkReplayObjMapper {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1334 rc_body.append('public:')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1335 rc_body.append(' vkReplayObjMapper() {}')
1336 rc_body.append(' ~vkReplayObjMapper() {}')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1337 rc_body.append('')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1338 rc_body.append(' bool m_adjustForGPU; // true if replay adjusts behavior based on GPU')
1339 # Code for memory objects for handling replay GPU != trace GPU object memory requirements
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1340 rc_body.append(' void init_objMemCount(const VkBaseObject& object, const uint32_t &num)\n {')
1341 rc_body.append(' VkImage img = static_cast <VkImage> (object);')
1342 rc_body.append(' std::map<VkImage, imageObj>::const_iterator it = m_images.find(img);')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1343 rc_body.append(' if (it != m_images.end())')
1344 rc_body.append(' {')
1345 rc_body.append(' objMemory obj = it->second.imageMem;')
1346 rc_body.append(' obj.setCount(num);')
1347 rc_body.append(' return;')
1348 rc_body.append(' }')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1349 rc_body.append(' VkBuffer buf = static_cast <VkBuffer> (object);')
1350 rc_body.append(' std::map<VkBuffer, bufferObj>::const_iterator itb = m_buffers.find(buf);')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1351 rc_body.append(' if (itb != m_buffers.end())')
1352 rc_body.append(' {')
1353 rc_body.append(' objMemory obj = itb->second.bufferMem;')
1354 rc_body.append(' obj.setCount(num);')
1355 rc_body.append(' return;')
1356 rc_body.append(' }')
1357 rc_body.append(' return;')
1358 rc_body.append(' }\n')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1359 rc_body.append(' void init_objMemReqs(const VkBaseObject& object, const VkMemoryRequirements *pMemReqs, const unsigned int num)\n {')
1360 rc_body.append(' VkImage img = static_cast <VkImage> (object);')
1361 rc_body.append(' std::map<VkImage, imageObj>::const_iterator it = m_images.find(img);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1362 rc_body.append(' if (it != m_images.end())')
1363 rc_body.append(' {')
1364 rc_body.append(' objMemory obj = it->second.imageMem;')
1365 rc_body.append(' obj.setReqs(pMemReqs, num);')
1366 rc_body.append(' return;')
1367 rc_body.append(' }')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1368 rc_body.append(' VkBuffer buf = static_cast <VkBuffer> (object);')
1369 rc_body.append(' std::map<VkBuffer, bufferObj>::const_iterator itb = m_buffers.find(buf);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1370 rc_body.append(' if (itb != m_buffers.end())')
1371 rc_body.append(' {')
1372 rc_body.append(' objMemory obj = itb->second.bufferMem;')
1373 rc_body.append(' obj.setReqs(pMemReqs, num);')
1374 rc_body.append(' return;')
1375 rc_body.append(' }')
1376 rc_body.append(' return;')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1377 rc_body.append(' }')
1378 rc_body.append('')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1379 rc_body.append(' void clear_all_map_handles()\n {')
1380 for var in sorted(obj_map_dict):
1381 rc_body.append(' %s.clear();' % var)
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1382 rc_body.append(' }\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1383 for var in sorted(obj_map_dict):
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1384 if obj_map_dict[var] == 'VkImage':
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1385 rc_body.append(self._map_decl(obj_map_dict[var], 'imageObj', var))
1386 rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'imageObj', var))
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1387 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1388 rc_body.append(' VkImage remap(const VkImage& value)')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1389 rc_body.append(' {')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1390 rc_body.append(' std::map<VkImage, imageObj>::const_iterator q = m_images.find(value);')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1391 rc_body.append(' return (q == m_images.end()) ? VK_NULL_HANDLE : q->second.replayImage;')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1392 rc_body.append(' }\n')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1393 elif obj_map_dict[var] == 'VkBuffer':
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1394 rc_body.append(self._map_decl(obj_map_dict[var], 'bufferObj', var))
1395 rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'bufferObj', var))
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1396 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1397 rc_body.append(' VkBuffer remap(const VkBuffer& value)')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1398 rc_body.append(' {')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1399 rc_body.append(' std::map<VkBuffer, bufferObj>::const_iterator q = m_buffers.find(value);')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1400 rc_body.append(' return (q == m_buffers.end()) ? VK_NULL_HANDLE : q->second.replayBuffer;')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1401 rc_body.append(' }\n')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1402 elif obj_map_dict[var] == 'VkGpuMemory':
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1403 rc_body.append(self._map_decl(obj_map_dict[var], 'gpuMemObj', var))
1404 rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'gpuMemObj', var))
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1405 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1406 rc_body.append(' VkGpuMemory remap(const VkGpuMemory& value)')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1407 rc_body.append(' {')
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1408 rc_body.append(' std::map<VkGpuMemory, gpuMemObj>::const_iterator q = m_gpumemorys.find(value);')
1409 rc_body.append(' return (q == m_gpumemorys.end()) ? VK_NULL_HANDLE : q->second.replayGpuMem;')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1410 rc_body.append(' }\n')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1411 else:
1412 rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))
1413 rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))
1414 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1415 rc_body.append(self._remap_decl(obj_map_dict[var], var))
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1416 # VkDynamicStateObject code
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1417 state_obj_remap_types = vulkan.object_dynamic_state_list
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1418 rc_body.append(' VkDynamicStateObject remap(const VkDynamicStateObject& state)\n {')
1419 rc_body.append(' VkDynamicStateObject obj;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1420 for t in state_obj_remap_types:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1421 rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != VK_NULL_HANDLE)' % t)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1422 rc_body.append(' return obj;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1423 rc_body.append(' return VK_NULL_HANDLE;\n }')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1424 rc_body.append(' void rm_from_map(const VkDynamicStateObject& state)\n {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1425 for t in state_obj_remap_types:
1426 rc_body.append(' rm_from_map(static_cast <%s> (state));' % t)
1427 rc_body.append(' }')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1428 rc_body.append('')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1429 # OBJECT code
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1430 rc_body.append(' VkObject remap(const VkObject& object)\n {')
1431 rc_body.append(' VkObject obj;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1432 obj_remap_types = vulkan.object_list
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1433 for var in obj_remap_types:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1434 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != VK_NULL_HANDLE)' % (var))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1435 rc_body.append(' return obj;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1436 rc_body.append(' return VK_NULL_HANDLE;\n }')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1437 rc_body.append(' void rm_from_map(const VkObject & objKey)\n {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1438 for var in obj_remap_types:
1439 rc_body.append(' rm_from_map(static_cast <%s> (objKey));' % (var))
1440 rc_body.append(' }')
Tobin Ehlis3ef02702015-04-15 11:51:51 -0600[diff] [blame]1441 rc_body.append(' VkBaseObject remap(const VkBaseObject& object)\n {')
1442 rc_body.append(' VkBaseObject obj;')
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1443 base_obj_remap_types = ['VkDevice', 'VkQueue', 'VkGpuMemory', 'VkObject']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1444 for t in base_obj_remap_types:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1445 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != VK_NULL_HANDLE)' % t)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1446 rc_body.append(' return obj;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1447 rc_body.append(' return VK_NULL_HANDLE;')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]1448 rc_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1449 rc_body.append('};')
1450 return "\n".join(rc_body)
1451
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1452 def _generate_replay_init_funcs(self):
1453 rif_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1454 rif_body.append('void vkFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1455 for proto in self.protos:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1456 rif_body.append(' real_vk%s = (type_vk%s)(glv_platform_get_library_entrypoint(handle, "vk%s"));' % (proto.name, proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1457 rif_body.append('}')
1458 return "\n".join(rif_body)
1459
1460 def _get_packet_param(self, t, n):
1461 # list of types that require remapping
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1462 remap_list = vulkan.object_type_list
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1463 param_exclude_list = ['p1', 'p2', 'pGpus', 'pDescriptorSets']
1464 if t.strip('*').replace('const ', '') in remap_list and n not in param_exclude_list:
1465 if '*' in t:
1466 if 'const ' not in t:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1467 return 'm_objMapper.remap(*pPacket->%s)' % (n)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1468 else: # TODO : Don't remap array ptrs?
1469 return 'pPacket->%s' % (n)
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1470 return 'm_objMapper.remap(pPacket->%s)' % (n)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1471 return 'pPacket->%s' % (n)
1472
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1473 def _gen_replay_enum_gpus(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1474 ieg_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1475 ieg_body.append(' returnValue = manually_handle_vkEnumerateGpus(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1476 return "\n".join(ieg_body)
1477
1478 def _gen_replay_get_gpu_info(self):
1479 ggi_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1480 ggi_body.append(' returnValue = manually_handle_vkGetGpuInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1481 return "\n".join(ggi_body)
1482
1483 def _gen_replay_create_device(self):
1484 cd_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1485 cd_body.append(' returnValue = manually_handle_vkCreateDevice(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1486 return "\n".join(cd_body)
1487
1488 def _gen_replay_get_extension_support(self):
1489 ges_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1490 ges_body.append(' returnValue = manually_handle_vkGetExtensionSupport(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1491 return "\n".join(ges_body)
1492
1493 def _gen_replay_queue_submit(self):
1494 qs_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1495 qs_body.append(' returnValue = manually_handle_vkQueueSubmit(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1496 return "\n".join(qs_body)
1497
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1498 def _gen_replay_get_object_info(self):
1499 goi_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1500 goi_body.append(' returnValue = manually_handle_vkGetObjectInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1501 return "\n".join(goi_body)
1502
1503 def _gen_replay_get_format_info(self):
1504 gfi_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1505 gfi_body.append(' returnValue = manually_handle_vkGetFormatInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1506 return "\n".join(gfi_body)
1507
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1508 def _gen_replay_create_image(self):
1509 ci_body = []
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1510 ci_body.append(' imageObj local_imageObj;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1511 ci_body.append(' replayResult = m_vkFuncs.real_vkCreateImage(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_imageObj.replayImage);')
1512 ci_body.append(' if (replayResult == VK_SUCCESS)')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1513 ci_body.append(' {')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1514 ci_body.append(' m_objMapper.add_to_map(pPacket->pImage, &local_imageObj);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1515 ci_body.append(' }')
1516 return "\n".join(ci_body)
1517
1518 def _gen_replay_create_buffer(self):
1519 cb_body = []
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1520 cb_body.append(' bufferObj local_bufferObj;')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1521 cb_body.append(' replayResult = m_vkFuncs.real_vkCreateBuffer(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_bufferObj.replayBuffer);')
1522 cb_body.append(' if (replayResult == VK_SUCCESS)')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1523 cb_body.append(' {')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1524 cb_body.append(' m_objMapper.add_to_map(pPacket->pBuffer, &local_bufferObj);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1525 cb_body.append(' }')
1526 return "\n".join(cb_body)
1527
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1528 def _gen_replay_get_image_subresource_info(self):
1529 isi_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1530 isi_body.append(' returnValue = manually_handle_vkGetImageSubresourceInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1531 return "\n".join(isi_body)
1532
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]1533 def _gen_replay_update_descriptors(self):
1534 ud_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1535 ud_body.append(' returnValue = manually_handle_vkUpdateDescriptors(pPacket);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1536 return "\n".join(ud_body)
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]1537
1538 def _gen_replay_create_descriptor_set_layout(self):
1539 cdsl_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1540 cdsl_body.append(' returnValue = manually_handle_vkCreateDescriptorSetLayout(pPacket);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1541 return "\n".join(cdsl_body)
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]1542
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1543 def _gen_replay_create_graphics_pipeline(self):
1544 cgp_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1545 cgp_body.append(' returnValue = manually_handle_vkCreateGraphicsPipeline(pPacket);')
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -0600[diff] [blame]1546 return "\n".join(cgp_body)
1547
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1548 def _gen_replay_cmd_wait_events(self):
1549 cwe_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1550 cwe_body.append(' returnValue = manually_handle_vkCmdWaitEvents(pPacket);')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1551 return "\n".join(cwe_body)
1552
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]1553 def _gen_replay_cmd_pipeline_barrier(self):
1554 cpb_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1555 cpb_body.append(' returnValue = manually_handle_vkCmdPipelineBarrier(pPacket);')
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]1556 return "\n".join(cpb_body)
1557
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1558 def _gen_replay_create_framebuffer(self):
1559 cf_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1560 cf_body.append(' returnValue = manually_handle_vkCreateFramebuffer(pPacket);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1561 return "\n".join(cf_body)
1562
1563 def _gen_replay_create_renderpass(self):
1564 cr_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1565 cr_body.append(' returnValue = manually_handle_vkCreateRenderPass(pPacket);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1566 return "\n".join(cr_body)
1567
1568 def _gen_replay_begin_command_buffer(self):
1569 bcb_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1570 bcb_body.append(' returnValue = manually_handle_vkBeginCommandBuffer(pPacket);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1571 return "\n".join(bcb_body)
1572
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1573 def _gen_replay_store_pipeline(self):
1574 sp_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1575 sp_body.append(' returnValue = manually_handle_vkStorePipeline(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1576 return "\n".join(sp_body)
1577
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1578 def _gen_replay_get_multi_gpu_compatibility(self):
1579 gmgc_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1580 gmgc_body.append(' returnValue = manually_handle_vkGetMultiGpuCompatibility(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1581 return "\n".join(gmgc_body)
1582
1583 def _gen_replay_destroy_object(self):
1584 do_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1585 do_body.append(' returnValue = manually_handle_vkDestroyObject(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1586 return "\n".join(do_body)
1587
1588 def _gen_replay_wait_for_fences(self):
1589 wf_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1590 wf_body.append(' returnValue = manually_handle_vkWaitForFences(pPacket);')
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500[diff] [blame]1591 return "\n".join(wf_body)
1592
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1593 def _gen_replay_wsi_associate_connection(self):
1594 wac_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1595 wac_body.append(' returnValue = manually_handle_vkWsiX11AssociateConnection(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1596 return "\n".join(wac_body)
1597
1598 def _gen_replay_wsi_get_msc(self):
1599 wgm_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1600 wgm_body.append(' returnValue = manually_handle_vkWsiX11GetMSC(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1601 return "\n".join(wgm_body)
1602
1603 def _gen_replay_wsi_create_presentable_image(self):
1604 cpi_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1605 cpi_body.append(' returnValue = manually_handle_vkWsiX11CreatePresentableImage(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1606 return "\n".join(cpi_body)
1607
1608 def _gen_replay_wsi_queue_present(self):
1609 wqp_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1610 wqp_body.append(' returnValue = manually_handle_vkWsiX11QueuePresent(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1611 return "\n".join(wqp_body)
1612
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1613 def _gen_replay_alloc_memory(self):
1614 am_body = []
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1615 am_body.append(' gpuMemObj local_mem;')
1616 am_body.append(' if (!m_objMapper.m_adjustForGPU)')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1617 am_body.append(' replayResult = m_vkFuncs.real_vkAllocMemory(m_objMapper.remap(pPacket->device), pPacket->pAllocInfo, &local_mem.replayGpuMem);')
1618 am_body.append(' if (replayResult == VK_SUCCESS || m_objMapper.m_adjustForGPU)')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1619 am_body.append(' {')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]1620 am_body.append(' local_mem.pGpuMem = new (gpuMemory);')
1621 am_body.append(' if (local_mem.pGpuMem)')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1622 am_body.append(' local_mem.pGpuMem->setAllocInfo(pPacket->pAllocInfo, m_objMapper.m_adjustForGPU);')
1623 am_body.append(' m_objMapper.add_to_map(pPacket->pMem, &local_mem);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1624 am_body.append(' }')
1625 return "\n".join(am_body)
1626
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1627 def _gen_replay_free_memory(self):
1628 fm_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1629 fm_body.append(' returnValue = manually_handle_vkFreeMemory(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1630 return "\n".join(fm_body)
1631
1632 def _gen_replay_map_memory(self):
1633 mm_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1634 mm_body.append(' returnValue = manually_handle_vkMapMemory(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1635 return "\n".join(mm_body)
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1636
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1637 def _gen_replay_unmap_memory(self):
1638 um_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1639 um_body.append(' returnValue = manually_handle_vkUnmapMemory(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1640 return "\n".join(um_body)
1641
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1642 def _gen_replay_pin_system_memory(self):
1643 psm_body = []
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1644 psm_body.append(' gpuMemObj local_mem;')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame]1645 psm_body.append(' /* TODO do we need to skip (make pending) this call for m_adjustForGPU */')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1646 psm_body.append(' replayResult = m_vkFuncs.real_vkPinSystemMemory(m_objMapper.remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_mem.replayGpuMem);')
1647 psm_body.append(' if (replayResult == VK_SUCCESS)')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1648 psm_body.append(' m_objMapper.add_to_map(pPacket->pMem, &local_mem);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1649 return "\n".join(psm_body)
1650
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1651 # I don't think this function is being generated anymore (ie, it may have been removed from VK)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1652 def _gen_replay_bind_dynamic_memory_view(self):
1653 bdmv_body = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1654 bdmv_body.append(' VK_MEMORY_VIEW_ATTACH_INFO memView;')
1655 bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(VK_MEMORY_VIEW_ATTACH_INFO));')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1656 bdmv_body.append(' memView.mem = m_objMapper.remap(pPacket->pMemView->mem);')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1657 bdmv_body.append(' m_vkFuncs.real_vkCmdBindDynamicMemoryView(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1658 return "\n".join(bdmv_body)
1659
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1660 # Generate main replay case statements where actual replay API call is dispatched based on input packet data
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1661 def _generate_replay(self):
1662 # map protos to custom functions if body is fully custom
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1663 custom_body_dict = {'EnumerateGpus': self._gen_replay_enum_gpus,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1664 'GetGpuInfo': self._gen_replay_get_gpu_info,
1665 'CreateDevice': self._gen_replay_create_device,
1666 'GetExtensionSupport': self._gen_replay_get_extension_support,
1667 'QueueSubmit': self._gen_replay_queue_submit,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1668 'GetObjectInfo': self._gen_replay_get_object_info,
1669 'GetFormatInfo': self._gen_replay_get_format_info,
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1670 'CreateImage': self._gen_replay_create_image,
1671 'CreateBuffer': self._gen_replay_create_buffer,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1672 'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,
1673 'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1674 'CreateFramebuffer': self._gen_replay_create_framebuffer,
1675 'CreateRenderPass': self._gen_replay_create_renderpass,
1676 'BeginCommandBuffer': self._gen_replay_begin_command_buffer,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1677 'StorePipeline': self._gen_replay_store_pipeline,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1678 'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,
1679 'DestroyObject': self._gen_replay_destroy_object,
1680 'WaitForFences': self._gen_replay_wait_for_fences,
1681 'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,
1682 'WsiX11GetMSC': self._gen_replay_wsi_get_msc,
1683 'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,
1684 'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1685 'AllocMemory': self._gen_replay_alloc_memory,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1686 'FreeMemory': self._gen_replay_free_memory,
1687 'MapMemory': self._gen_replay_map_memory,
1688 'UnmapMemory': self._gen_replay_unmap_memory,
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1689 'PinSystemMemory': self._gen_replay_pin_system_memory,
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1690 'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view,
1691 'UpdateDescriptors': self._gen_replay_update_descriptors,
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1692 'CreateDescriptorSetLayout': self._gen_replay_create_descriptor_set_layout,
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]1693 'CmdWaitEvents': self._gen_replay_cmd_wait_events,
1694 'CmdPipelineBarrier': self._gen_replay_cmd_pipeline_barrier}
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1695 # TODO : Need to guard CreateInstance with "if (!m_display->m_initedVK)" check
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1696 # Despite returning a value, don't check these funcs b/c custom code includes check already
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1697 custom_check_ret_val = ['EnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport', 'QueueSubmit', 'GetObjectInfo',
1698 'GetFormatInfo', 'GetImageSubresourceInfo', 'CreateDescriptorSetLayout', 'CreateGraphicsPipeline',
1699 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'StorePipeline', 'GetMultiGpuCompatibility',
Peter Lohrmann95c369a2015-04-02 10:06:19 -0700[diff] [blame]1700 'DestroyObject', 'WaitForFences', 'FreeMemory', 'MapMemory', 'UnmapMemory',
1701 'WsiX11AssociateConnection', 'WsiX11GetMSC', 'WsiX11CreatePresentableImage', 'WsiX11QueuePresent']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1702 # multi-gpu Open funcs w/ list of local params to create
1703 custom_open_params = {'OpenSharedMemory': (-1,),
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1704 'OpenSharedSemaphore': (-1,),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1705 'OpenPeerMemory': (-1,),
1706 'OpenPeerImage': (-1, -2,)}
1707 # Functions that create views are unique from other create functions
Jon Ashburnb1b63ed2015-02-03 11:24:08 -0700[diff] [blame]1708 create_view_list = ['CreateBufferView', 'CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1709 # Functions to treat as "Create' that don't have 'Create' in the name
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1710 special_create_list = ['LoadPipeline', 'LoadPipelineDerivative', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1711 # A couple funcs use do while loops
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1712 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'}
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1713 rbody = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1714 rbody.append('glv_replay::GLV_REPLAY_RESULT vkReplay::replay(glv_trace_packet_header *packet)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1715 rbody.append('{')
1716 rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1717 rbody.append(' VkResult replayResult = VK_ERROR_UNKNOWN;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1718 rbody.append(' switch (packet->packet_id)')
1719 rbody.append(' {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1720 rbody.append(' case GLV_TPI_VK_vkApiVersion:')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]1721 rbody.append(' break; // nothing to replay on the version packet')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1722 for proto in self.protos:
1723 ret_value = False
1724 create_view = False
1725 create_func = False
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1726 # TODO : How to handle void* return of GetProcAddr?
1727 if ('void' not in proto.ret) and (proto.name not in custom_check_ret_val):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1728 ret_value = True
1729 if proto.name in create_view_list:
1730 create_view = True
1731 elif 'Create' in proto.name or proto.name in special_create_list:
1732 create_func = True
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1733 rbody.append(' case GLV_TPI_VK_vk%s:' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1734 rbody.append(' {')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1735 rbody.append(' struct_vk%s* pPacket = (struct_vk%s*)(packet->pBody);' % (proto.name, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1736 if proto.name in custom_body_dict:
1737 rbody.append(custom_body_dict[proto.name]())
1738 else:
1739 if proto.name in custom_open_params:
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1740 rbody.append(' VkDevice handle;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1741 for pidx in custom_open_params[proto.name]:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1742 rbody.append(' %s local_%s;' % (proto.params[pidx].ty.replace('const ', '').strip('*'), proto.params[pidx].name))
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1743 rbody.append(' handle = m_objMapper.remap(pPacket->device);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1744 elif create_view:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1745 rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').replace('const ', '')))
1746 rbody.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(%s));' % (proto.params[1].ty.strip('*').replace('const ', '')))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1747 if 'CreateComputePipeline' == proto.name:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1748 rbody.append(' createInfo.cs.shader = m_objMapper.remap(pPacket->pCreateInfo->cs.shader);')
Jon Ashburnb1b63ed2015-02-03 11:24:08 -0700[diff] [blame]1749 elif 'CreateBufferView' == proto.name:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1750 rbody.append(' createInfo.buffer = m_objMapper.remap(pPacket->pCreateInfo->buffer);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1751 else:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1752 rbody.append(' createInfo.image = m_objMapper.remap(pPacket->pCreateInfo->image);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1753 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1754 elif create_func: # Declare local var to store created handle into
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1755 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]1756 if 'AllocDescriptorSets' == proto.name:
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1757 rbody.append(' %s local_%s[100];' % (proto.params[-2].ty.strip('*').replace('const ', ''), proto.params[-2].name))
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1758 rbody.append(' VkDescriptorSetLayout localDescSets[100];')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1759 rbody.append(' assert(pPacket->count <= 100);')
1760 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
1761 rbody.append(' {')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1762 rbody.append(' localDescSets[i] = m_objMapper.remap(pPacket->%s[i]);' % (proto.params[-3].name))
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1763 rbody.append(' }')
1764 elif proto.name == 'ClearDescriptorSets':
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1765 rbody.append(' VkDescriptorSet localDescSets[100];')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1766 rbody.append(' assert(pPacket->count <= 100);')
1767 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1768 rbody.append(' {')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1769 rbody.append(' localDescSets[i] = m_objMapper.remap(pPacket->%s[i]);' % (proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1770 rbody.append(' }')
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1771 elif proto.name == 'ResetFences':
1772 rbody.append(' VkFence* fences = GLV_NEW_ARRAY(VkFence, pPacket->fenceCount);')
1773 rbody.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')
1774 rbody.append(' {')
1775 rbody.append(' fences[i] = m_objMapper.remap(pPacket->%s[i]);' % (proto.params[-1].name))
1776 rbody.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1777 elif proto.name in do_while_dict:
1778 rbody.append(' do {')
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]1779 elif proto.name == 'EnumerateLayers':
1780 rbody.append(' char **bufptr = GLV_NEW_ARRAY(char *, pPacket->maxLayerCount);')
1781 rbody.append(' char **ptrLayers = (pPacket->pOutLayers == NULL) ? bufptr : (char **) pPacket->pOutLayers;')
1782 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
1783 rbody.append(' bufptr[i] = GLV_NEW_ARRAY(char, pPacket->maxStringSize);')
Jon Ashburnd698ca22015-02-12 12:37:46 -0700[diff] [blame]1784 elif proto.name == 'DestroyInstance':
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1785 rbody.append(' vkDbgUnregisterMsgCallback(m_objMapper.remap(pPacket->instance), g_fpDbgMsgCallback);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1786 rr_string = ' '
1787 if ret_value:
1788 rr_string = ' replayResult = '
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1789 rr_string += 'm_vkFuncs.real_vk%s(' % proto.name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1790 for p in proto.params:
1791 # For last param of Create funcs, pass address of param
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]1792 if create_func:
1793 if p.name == proto.params[-1].name:
1794 rr_string += '&local_%s, ' % p.name
1795 elif proto.name == 'AllocDescriptorSets' and p.name == proto.params[-2].name:
1796 rr_string += 'local_%s, ' % p.name
1797 else:
1798 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1799 else:
1800 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
1801 rr_string = '%s);' % rr_string[:-2]
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1802 if proto.name in custom_open_params:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1803 rr_list = rr_string.split(', ')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1804 rr_list[0] = rr_list[0].replace('m_objMapper.remap(pPacket->device)', 'handle')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1805 for pidx in custom_open_params[proto.name]:
1806 rr_list[pidx] = '&local_%s' % proto.params[pidx].name
1807 rr_string = ', '.join(rr_list)
1808 rr_string += ');'
1809 elif create_view:
1810 rr_list = rr_string.split(', ')
1811 rr_list[-2] = '&createInfo'
1812 rr_list[-1] = '&local_%s);' % proto.params[-1].name
1813 rr_string = ', '.join(rr_list)
1814 # this is a sneaky shortcut to use generic create code below to add_to_map
1815 create_func = True
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]1816 elif proto.name == 'EnumerateLayers':
1817 rr_string = rr_string.replace('pPacket->pOutLayers', 'ptrLayers')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1818 elif proto.name == 'ClearDescriptorSets':
1819 rr_string = rr_string.replace('pPacket->pDescriptorSets', 'localDescSets')
1820 elif proto.name == 'AllocDescriptorSets':
1821 rr_string = rr_string.replace('pPacket->pSetLayouts', 'localDescSets')
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1822 elif proto.name == 'ResetFences':
1823 rr_string = rr_string.replace('m_objMapper.remap(*pPacket->pFences)', 'fences')
1824
1825 # insert the real_*(..) call
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1826 rbody.append(rr_string)
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1827
1828 # handle return values or anything that needs to happen after the real_*(..) call
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1829 if 'DestroyDevice' in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1830 rbody.append(' if (replayResult == VK_SUCCESS)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1831 rbody.append(' {')
Peter Lohrmann53e89242015-02-27 15:35:15 -0800[diff] [blame]1832 rbody.append(' m_pCBDump = NULL;')
1833 rbody.append(' m_pDSDump = NULL;')
Peter Lohrmanncaf39d52015-03-24 17:19:24 -0700[diff] [blame]1834 rbody.append(' m_pGlvSnapshotPrint = NULL;')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1835 rbody.append(' m_objMapper.rm_from_map(pPacket->device);')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1836 rbody.append(' m_display->m_initedVK = false;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1837 rbody.append(' }')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]1838 if 'DestroyInstance' in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1839 rbody.append(' if (replayResult == VK_SUCCESS)')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]1840 rbody.append(' {')
Jon Ashburn6f58a162015-02-03 09:17:12 -0700[diff] [blame]1841 rbody.append(' // TODO need to handle multiple instances and only clearing maps within an instance.')
1842 rbody.append(' // TODO this only works with a single instance used at any given time.')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1843 rbody.append(' m_objMapper.clear_all_map_handles();')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]1844 rbody.append(' }')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]1845 elif 'AllocDescriptorSets' in proto.name:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1846 rbody.append(' if (replayResult == VK_SUCCESS)')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]1847 rbody.append(' {')
1848 rbody.append(' for (uint32_t i = 0; i < local_pCount; i++) {')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1849 rbody.append(' m_objMapper.add_to_map(&pPacket->%s[i], &local_%s[i]);' % (proto.params[-2].name, proto.params[-2].name))
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]1850 rbody.append(' }')
1851 rbody.append(' }')
Peter Lohrmanne70d1392015-04-15 12:45:51 -0700[diff] [blame]1852 elif proto.name == 'ResetFences':
1853 rbody.append(' GLV_DELETE(fences);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1854 elif create_func: # save handle mapping if create successful
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1855 rbody.append(' if (replayResult == VK_SUCCESS)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1856 rbody.append(' {')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1857 rbody.append(' m_objMapper.add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1858 if 'AllocMemory' == proto.name:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1859 rbody.append(' m_objMapper.add_entry_to_mapData(local_%s, pPacket->pAllocInfo->allocationSize);' % (proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1860 rbody.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1861 elif proto.name in do_while_dict:
1862 rbody[-1] = ' %s' % rbody[-1]
1863 rbody.append(' } while (%s);' % do_while_dict[proto.name])
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1864 rbody.append(' if (pPacket->result != VK_NOT_READY || replayResult != VK_SUCCESS)')
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]1865 elif proto.name == 'EnumerateLayers':
1866 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
1867 rbody.append(' GLV_DELETE(bufptr[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1868 if ret_value:
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1869 rbody.append(' CHECK_RETURN_VALUE(vk%s);' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1870 if 'MsgCallback' in proto.name:
1871 rbody.pop()
1872 rbody.pop()
1873 rbody.pop()
1874 rbody.append(' // Just eating these calls as no way to restore dbg func ptr.')
1875 rbody.append(' break;')
1876 rbody.append(' }')
1877 rbody.append(' default:')
1878 rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')
1879 rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')
1880 rbody.append(' break;')
1881 rbody.append(' }')
1882 rbody.append(' return returnValue;')
1883 rbody.append('}')
1884 return "\n".join(rbody)
1885
1886class GlaveTraceHeader(Subcommand):
1887 def generate_header(self):
1888 header_txt = []
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]1889 header_txt.append('#include "glv_vk_vk_structs.h"')
1890 header_txt.append('#include "glv_vk_packet_id.h"\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1891 header_txt.append('void AttachHooks();')
1892 header_txt.append('void DetachHooks();')
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]1893 header_txt.append('void InitTracer(void);\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1894 return "\n".join(header_txt)
1895
1896 def generate_body(self):
1897 body = [self._generate_trace_func_ptrs(),
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]1898 self._generate_trace_func_protos(),
1899 self._generate_trace_real_func_ptr_protos()]
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1900
1901 return "\n".join(body)
1902
1903class GlaveTraceC(Subcommand):
1904 def generate_header(self):
1905 header_txt = []
1906 header_txt.append('#include "glv_platform.h"')
1907 header_txt.append('#include "glv_common.h"')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1908 header_txt.append('#include "glvtrace_vk_helpers.h"')
1909 header_txt.append('#include "glvtrace_vk_vk.h"')
1910 header_txt.append('#include "glvtrace_vk_vkdbg.h"')
1911 header_txt.append('#include "glvtrace_vk_vkwsix11ext.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1912 header_txt.append('#include "glv_interconnect.h"')
1913 header_txt.append('#include "glv_filelike.h"')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1914 header_txt.append('#include "vk_struct_size_helper.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1915 header_txt.append('#ifdef WIN32')
1916 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
1917 header_txt.append('#endif')
1918 header_txt.append('#include "glv_trace_packet_utils.h"')
1919 header_txt.append('#include <stdio.h>\n')
1920 return "\n".join(header_txt)
1921
1922 def generate_body(self):
1923 body = [self._generate_func_ptr_assignments(),
1924 self._generate_attach_hooks(),
1925 self._generate_detach_hooks(),
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1926 self._generate_init_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1927 self._generate_trace_funcs()]
1928
1929 return "\n".join(body)
1930
1931class GlavePacketID(Subcommand):
1932 def generate_header(self):
1933 header_txt = []
1934 header_txt.append('#pragma once\n')
1935 header_txt.append('#include "glv_trace_packet_utils.h"')
1936 header_txt.append('#include "glv_trace_packet_identifiers.h"')
1937 header_txt.append('#include "glv_interconnect.h"')
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]1938 header_txt.append('#include "glv_vk_vk_structs.h"')
1939 header_txt.append('#include "glv_vk_vkdbg_structs.h"')
1940 header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1941 header_txt.append('#include "vk_enum_string_helper.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]1942 header_txt.append('#if defined(WIN32)')
1943 header_txt.append('#define snprintf _snprintf')
1944 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1945 header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')
1946 header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\\n");\n')
1947 header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')
1948 header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')
1949 header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1950 header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_VULKAN, GLV_TPI_VK_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1951 header_txt.append('#define FINISH_TRACE_PACKET() \\')
1952 header_txt.append(' glv_finalize_trace_packet(pHeader); \\')
1953 header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')
1954 header_txt.append(' glv_delete_trace_packet(&pHeader);')
1955 return "\n".join(header_txt)
1956
1957 def generate_body(self):
1958 body = [self._generate_packet_id_enum(),
1959 self._generate_stringify_func(),
1960 self._generate_interp_func()]
1961
1962 return "\n".join(body)
1963
1964class GlaveCoreStructs(Subcommand):
1965 def generate_header(self):
1966 header_txt = []
1967 header_txt.append('#pragma once\n')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1968 header_txt.append('#include "vulkan.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1969 header_txt.append('#include "glv_trace_packet_utils.h"\n')
1970 return "\n".join(header_txt)
1971
1972 def generate_body(self):
1973 body = [self._generate_struct_util_funcs(),
1974 self._generate_interp_funcs()]
1975
1976 return "\n".join(body)
1977
1978class GlaveWsiHeader(Subcommand):
1979 def generate_header(self):
1980 header_txt = []
1981 header_txt.append('#pragma once\n')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1982 header_txt.append('#include "vulkan.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]1983 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1984 header_txt.append('#include "vkWsiX11Ext.h"\n')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]1985 header_txt.append('#else')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1986 header_txt.append('#include "vkWsiWinExt.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]1987 header_txt.append('#endif')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]1988 header_txt.append('void AttachHooks_vkwsix11ext();')
1989 header_txt.append('void DetachHooks_vkwsix11ext();')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1990 return "\n".join(header_txt)
1991
1992 def generate_body(self):
1993 body = [self._generate_trace_func_ptrs_ext(),
1994 self._generate_trace_func_protos_ext()]
1995
1996 return "\n".join(body)
1997
1998class GlaveWsiC(Subcommand):
1999 def generate_header(self):
2000 header_txt = []
2001 header_txt.append('#include "glv_platform.h"')
2002 header_txt.append('#include "glv_common.h"')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2003 header_txt.append('#include "glvtrace_vk_vkwsix11ext.h"')
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]2004 header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
2005 header_txt.append('#include "glv_vk_packet_id.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2006 header_txt.append('#ifdef WIN32')
2007 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2008 header_txt.append('#endif')
2009 return "\n".join(header_txt)
2010
2011 def generate_body(self):
2012 body = [self._generate_func_ptr_assignments_ext(),
2013 self._generate_attach_hooks_ext(),
2014 self._generate_detach_hooks_ext(),
2015 self._generate_trace_funcs_ext()]
2016
2017 return "\n".join(body)
2018
2019class GlaveWsiStructs(Subcommand):
2020 def generate_header(self):
2021 header_txt = []
2022 header_txt.append('#pragma once\n')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2023 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2024 header_txt.append('#include "vkWsiX11Ext.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2025 header_txt.append('#else')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2026 header_txt.append('#include "vkWsiWinExt.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2027 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2028 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2029 return "\n".join(header_txt)
2030
2031 def generate_body(self):
2032 body = [self._generate_interp_funcs_ext()]
2033
2034 return "\n".join(body)
2035
2036class GlaveDbgHeader(Subcommand):
2037 def generate_header(self):
2038 header_txt = []
2039 header_txt.append('#pragma once\n')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2040 header_txt.append('#include "vulkan.h"')
2041 header_txt.append('#include "vkDbg.h"\n')
2042 header_txt.append('void AttachHooks_vkdbg();')
2043 header_txt.append('void DetachHooks_vkdbg();')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2044 return "\n".join(header_txt)
2045
2046 def generate_body(self):
2047 body = [self._generate_trace_func_ptrs_ext('Dbg'),
2048 self._generate_trace_func_protos_ext('Dbg')]
2049
2050 return "\n".join(body)
2051
2052class GlaveDbgC(Subcommand):
2053 def generate_header(self):
2054 header_txt = []
2055 header_txt.append('#include "glv_platform.h"')
2056 header_txt.append('#include "glv_common.h"')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2057 header_txt.append('#include "glvtrace_vk_vk.h"')
2058 header_txt.append('#include "glvtrace_vk_vkdbg.h"')
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]2059 header_txt.append('#include "glv_vk_vkdbg_structs.h"')
2060 header_txt.append('#include "glv_vk_packet_id.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2061 header_txt.append('#ifdef WIN32')
2062 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2063 header_txt.append('#endif')
2064 return "\n".join(header_txt)
2065
2066 def generate_body(self):
2067 body = [self._generate_func_ptr_assignments_ext('Dbg'),
2068 self._generate_attach_hooks_ext('Dbg'),
2069 self._generate_detach_hooks_ext('Dbg'),
2070 self._generate_trace_funcs_ext('Dbg')]
2071
2072 return "\n".join(body)
2073
2074class GlaveDbgStructs(Subcommand):
2075 def generate_header(self):
2076 header_txt = []
2077 header_txt.append('#pragma once\n')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2078 header_txt.append('#include "vkDbg.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2079 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2080 return "\n".join(header_txt)
2081
2082 def generate_body(self):
2083 body = [self._generate_interp_funcs_ext('Dbg')]
2084
2085 return "\n".join(body)
2086
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2087class GlaveReplayVkFuncPtrs(Subcommand):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2088 def generate_header(self):
2089 header_txt = []
2090 header_txt.append('#pragma once\n')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2091 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2092 header_txt.append('#include <xcb/xcb.h>\n')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2093 header_txt.append('#endif')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2094 header_txt.append('#include "vulkan.h"')
2095 header_txt.append('#include "vkDbg.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2096 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2097 header_txt.append('#include "vkWsiX11Ext.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2098 header_txt.append('#else')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2099 header_txt.append('#include "vkWsiWinExt.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2100 header_txt.append('#endif')
Peter Lohrmannaf44b452015-03-30 18:29:22 -0700[diff] [blame]2101
2102 def generate_body(self):
2103 body = [self._generate_replay_func_ptrs()]
2104 return "\n".join(body)
2105
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2106class GlaveReplayObjMapperHeader(Subcommand):
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2107 def generate_header(self):
Ian Elliott91e681e2015-02-18 15:35:00 -0700[diff] [blame]2108 header_txt = []
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2109 header_txt.append('#pragma once\n')
2110 header_txt.append('#include <set>')
2111 header_txt.append('#include <map>')
2112 header_txt.append('#include <vector>')
2113 header_txt.append('#include <string>')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2114 header_txt.append('#include "vulkan.h"')
2115 header_txt.append('#include "vkDbg.h"')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]2116 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2117 header_txt.append('#include "vkWsiX11Ext.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2118 header_txt.append('#else')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2119 header_txt.append('#include "vkWsiWinExt.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2120 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2121 return "\n".join(header_txt)
2122
2123 def generate_body(self):
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2124 body = [self._generate_replay_objmapper_class()]
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2125 return "\n".join(body)
2126
2127class GlaveReplayC(Subcommand):
2128 def generate_header(self):
2129 header_txt = []
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2130 header_txt.append('#include "glvreplay_vk_vkreplay.h"\n')
2131 header_txt.append('#include "glvreplay_vk.h"\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2132 header_txt.append('#include "glvreplay_main.h"\n')
2133 header_txt.append('#include <algorithm>')
2134 header_txt.append('#include <queue>')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]2135 header_txt.append('\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2136 header_txt.append('extern "C" {')
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]2137 header_txt.append('#include "glv_vk_vk_structs.h"')
2138 header_txt.append('#include "glv_vk_vkdbg_structs.h"')
2139 header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
2140 header_txt.append('#include "glv_vk_packet_id.h"')
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2141 header_txt.append('#include "vk_enum_string_helper.h"\n}\n')
2142 header_txt.append('#define APP_NAME "glvreplay_vk"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2143 header_txt.append('#define IDI_ICON 101\n')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]2144
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2145 return "\n".join(header_txt)
2146
2147 def generate_body(self):
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]2148 body = [self._generate_replay_init_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2149 self._generate_replay()]
2150
2151 return "\n".join(body)
2152
2153def main():
2154 subcommands = {
2155 "glave-trace-h" : GlaveTraceHeader,
2156 "glave-trace-c" : GlaveTraceC,
2157 "glave-packet-id" : GlavePacketID,
2158 "glave-core-structs" : GlaveCoreStructs,
2159 "glave-wsi-trace-h" : GlaveWsiHeader,
2160 "glave-wsi-trace-c" : GlaveWsiC,
2161 "glave-wsi-trace-structs" : GlaveWsiStructs,
2162 "glave-dbg-trace-h" : GlaveDbgHeader,
2163 "glave-dbg-trace-c" : GlaveDbgC,
2164 "glave-dbg-trace-structs" : GlaveDbgStructs,
Courtney Goeltzenleuchter4bffc072015-04-14 16:33:28 -0600[diff] [blame]2165 "glave-replay-vk-funcs" : GlaveReplayVkFuncPtrs,
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2166 "glave-replay-obj-mapper-h" : GlaveReplayObjMapperHeader,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2167 "glave-replay-c" : GlaveReplayC,
2168 }
2169
2170 if len(sys.argv) < 2 or sys.argv[1] not in subcommands:
2171 print("Usage: %s <subcommand> [options]" % sys.argv[0])
2172 print
2173 print("Available sucommands are: %s" % " ".join(subcommands))
2174 exit(1)
2175
2176 subcmd = subcommands[sys.argv[1]](sys.argv[2:])
2177 subcmd.run()
2178
2179if __name__ == "__main__":
2180 main()