Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 3f0d69789bbb8b2bde0447cc3b416257347b8e4d / . / tools / glave / scripts / vk_generate.py
blob: 1d59dfd34a3b8125da8f7537b5a840729b1a1308 [file] [log] [blame]
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1#!/usr/bin/env python3
2#
3# XGL
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 Lohrmann26142522015-03-27 11:39:30 -0700[diff] [blame]26import os, sys
27
28# add main repo directory so xgl.py can be imported. This needs to be a complete path.
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
33import xgl
34
35class Subcommand(object):
36 def __init__(self, argv):
37 self.argv = argv
Chia-I Wuec30dcb2015-01-01 08:46:31 +0800[diff] [blame]38 self.headers = xgl.headers
39 self.protos = xgl.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/*
66 * XGL
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
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]99 def _get_printf_params(self, xgl_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
102 if "_TYPE" in xgl_type: # TODO : This should be generic ENUM check
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]103 return ("%s", "string_%s(%s)" % (xgl_type.replace('const ', '').strip('*'), name), deref)
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]104 if "char*" == xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]105 return ("%s", name, "*")
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]106 if "uint64_t" in xgl_type:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]107 if '*' in xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]108 return ("%lu", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
109 return ("%lu", name, deref)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]110 if "size_t" in xgl_type:
Chia-I Wu54ed0792014-12-27 14:14:50 +0800[diff] [blame]111 if '*' in xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]112 return ("%zu", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
113 return ("%zu", name, deref)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]114 if "float" in xgl_type:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]115 if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]116 return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name), deref)
117 return ("%f", name, deref)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]118 if "bool" in xgl_type or 'xcb_randr_crtc_t' in xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]119 return ("%u", name, deref)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]120 if True in [t in xgl_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]121 if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]122 return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name), deref)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]123 if '*' in xgl_type:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]124 return ("%i", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
125 return ("%i", name, deref)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]126 if output_param:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]127 return ("%p", "(void*)%s" % name, deref)
128 return ("%p", "(void*)(%s)" % name, deref)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]129
130 def _generate_trace_func_ptrs(self):
131 func_ptrs = []
132 func_ptrs.append('// Pointers to real functions and declarations of hooked functions')
133 func_ptrs.append('#ifdef WIN32')
134 func_ptrs.append('extern INIT_ONCE gInitOnce;')
135 for proto in self.protos:
136 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:
137 func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))
138
139 func_ptrs.append('\n#elif defined(PLATFORM_LINUX)')
140 func_ptrs.append('extern pthread_once_t gInitOnce;')
141 for proto in self.protos:
142 if True not in [skip_str in proto.name for skip_str in ['Dbg', 'Wsi']]:
143 func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))
144
145 func_ptrs.append('#endif\n')
146 return "\n".join(func_ptrs)
147
148 def _generate_trace_func_ptrs_ext(self, func_class='Wsi'):
149 func_ptrs = []
150 func_ptrs.append('#ifdef WIN32')
151 for proto in self.protos:
152 if func_class in proto.name:
153 func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))
154
155 func_ptrs.append('#elif defined(__linux__)')
156 for proto in self.protos:
157 if func_class in proto.name:
158 func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))
159
160 func_ptrs.append('#endif\n')
161 return "\n".join(func_ptrs)
162
163 def _generate_trace_func_protos(self):
164 func_protos = []
165 func_protos.append('// Hooked function prototypes\n')
166 for proto in self.protos:
167 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Ian Elliotte5a22a72015-02-26 17:01:30 -0700[diff] [blame]168 func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]169
170 return "\n".join(func_protos)
171
172 def _generate_trace_func_protos_ext(self, func_class='Wsi'):
173 func_protos = []
174 func_protos.append('// Hooked function prototypes\n')
175 for proto in self.protos:
176 if func_class in proto.name:
Ian Elliotte5a22a72015-02-26 17:01:30 -0700[diff] [blame]177 func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]178
179 return "\n".join(func_protos)
180
181
182 def _generate_func_ptr_assignments(self):
183 func_ptr_assign = []
184 for proto in self.protos:
185 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
186 func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
187 for p in proto.params:
188 if 'color' == p.name:
189 func_ptr_assign.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))
190 else:
191 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
192 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
193 func_ptr_assign.append('static BOOL isHooked = FALSE;\n')
194 return "\n".join(func_ptr_assign)
195
196 def _generate_func_ptr_assignments_ext(self, func_class='Wsi'):
197 func_ptr_assign = []
198 for proto in self.protos:
199 if func_class in proto.name:
200 func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
201 for p in proto.params:
202 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
203 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
204 return "\n".join(func_ptr_assign)
205
206 def _generate_attach_hooks(self):
207 hooks_txt = []
208 hooks_txt.append('void AttachHooks()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)')
209 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]210 # TODO : Verify if CreateInstance is appropriate to key off of here
211 hooks_txt.append(' if (real_xglCreateInstance != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]212 hooks_txt.append(' {\n isHooked = TRUE;')
213 hook_operator = '='
214 for proto in self.protos:
215 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
216 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
217 hook_operator = '&='
218 hooks_txt.append(' }\n')
219 hooks_txt.append(' if (!hookSuccess)\n {')
220 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
221 hooks_txt.append(' Mhook_EndMultiOperation();\n')
222 hooks_txt.append('#elif defined(__linux__)')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]223 hooks_txt.append(' if (real_xglCreateInstance == xglCreateInstance)')
224 hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateInstance,"xglCreateInstance");')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]225 hooks_txt.append(' isHooked = TRUE;')
226 for proto in self.protos:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]227 if 'Dbg' not in proto.name and 'Wsi' not in proto.name and 'CreateInstance' not in proto.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]228 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
229 hooks_txt.append(' if (!hookSuccess)\n {')
230 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
231 hooks_txt.append('#endif\n}\n')
232 return "\n".join(hooks_txt)
233
234 def _generate_attach_hooks_ext(self, func_class='Wsi'):
235 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
236 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
237 hooks_txt = []
238 hooks_txt.append('void AttachHooks%s()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)' % func_ext_dict[func_class])
239 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
240 hooks_txt.append(' if (real_xgl%s != NULL)' % first_proto_dict[func_class])
241 hooks_txt.append(' {')
242 hook_operator = '='
243 for proto in self.protos:
244 if func_class in proto.name:
245 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
246 hook_operator = '&='
247 hooks_txt.append(' }\n')
248 hooks_txt.append(' if (!hookSuccess)\n {')
249 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
250 hooks_txt.append(' Mhook_EndMultiOperation();\n')
251 hooks_txt.append('#elif defined(__linux__)')
252 hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (first_proto_dict[func_class], first_proto_dict[func_class]))
253 for proto in self.protos:
254 if func_class in proto.name and first_proto_dict[func_class] not in proto.name:
255 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
256 hooks_txt.append(' if (!hookSuccess)\n {')
257 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
258 hooks_txt.append('#endif\n}\n')
259 return "\n".join(hooks_txt)
260
261 def _generate_detach_hooks(self):
262 hooks_txt = []
263 hooks_txt.append('void DetachHooks()\n{\n#ifdef __linux__\n return;\n#elif defined(WIN32)')
264 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xglGetGpuInfo != NULL)\n {')
265 hook_operator = '='
266 for proto in self.protos:
267 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
268 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
269 hook_operator = '&='
270 hooks_txt.append(' }\n isHooked = FALSE;')
271 hooks_txt.append(' if (!unhookSuccess)\n {')
272 hooks_txt.append(' glv_LogError("Failed to unhook XGL.");\n }')
273 hooks_txt.append('#endif\n}')
274 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')
275 return "\n".join(hooks_txt)
276
277 def _generate_detach_hooks_ext(self, func_class='Wsi'):
278 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
279 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
280 hooks_txt = []
281 hooks_txt.append('void DetachHooks%s()\n{\n#ifdef WIN32' % func_ext_dict[func_class])
282 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xgl%s != NULL)\n {' % first_proto_dict[func_class])
283 hook_operator = '='
284 for proto in self.protos:
285 if func_class in proto.name:
286 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
287 hook_operator = '&='
288 hooks_txt.append(' }')
289 hooks_txt.append(' if (!unhookSuccess)\n {')
290 hooks_txt.append(' glv_LogError("Failed to unhook XGL ext %s.");\n }' % func_class)
291 hooks_txt.append('#elif defined(__linux__)\n return;\n#endif\n}\n')
292 return "\n".join(hooks_txt)
293
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]294 def _generate_init_funcs(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]295 init_tracer = []
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]296 init_tracer.append('void send_xgl_api_version_packet()\n{')
297 init_tracer.append(' struct_xglApiVersion* pPacket;')
298 init_tracer.append(' glv_trace_packet_header* pHeader;')
299 init_tracer.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_xglApiVersion, sizeof(struct_xglApiVersion), 0);')
300 init_tracer.append(' pPacket = interpret_body_as_xglApiVersion(pHeader, FALSE);')
301 init_tracer.append(' pPacket->version = XGL_API_VERSION;')
302 init_tracer.append(' FINISH_TRACE_PACKET();\n}\n')
303
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]304 init_tracer.append('static GLV_CRITICAL_SECTION g_memInfoLock;')
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]305 init_tracer.append('void InitTracer(void)\n{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]306 init_tracer.append(' char *ipAddr = glv_get_global_var("GLVLIB_TRACE_IPADDR");')
307 init_tracer.append(' if (ipAddr == NULL)')
308 init_tracer.append(' ipAddr = "127.0.0.1";')
Jon Ashburn0fed6752015-01-09 17:36:10 -0700[diff] [blame]309 init_tracer.append(' gMessageStream = glv_MessageStream_create(FALSE, ipAddr, GLV_BASE_PORT + GLV_TID_XGL);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]310 init_tracer.append(' glv_trace_set_trace_file(glv_FileLike_create_msg(gMessageStream));')
311 init_tracer.append('// glv_tracelog_set_log_file(glv_FileLike_create_file(fopen("glv_log_traceside.txt","w")));')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]312 init_tracer.append(' glv_tracelog_set_tracer_id(GLV_TID_XGL);')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]313 init_tracer.append(' glv_create_critical_section(&g_memInfoLock);')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]314 init_tracer.append(' send_xgl_api_version_packet();\n}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]315 return "\n".join(init_tracer)
316
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]317 def _gen_unmap_memory(self):
318 um_body = []
319 um_body.append('GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglUnmapMemory(')
320 um_body.append(' XGL_GPU_MEMORY mem)')
321 um_body.append('{')
322 um_body.append(' glv_trace_packet_header* pHeader;')
323 um_body.append(' XGL_RESULT result;')
324 um_body.append(' struct_xglUnmapMemory* pPacket;')
325 um_body.append(' XGLAllocInfo *entry;')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]326 um_body.append(' SEND_ENTRYPOINT_PARAMS("xglUnmapMemory(mem %p)\\n", mem);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]327 um_body.append(' // insert into packet the data that was written by CPU between the xglMapMemory call and here')
328 um_body.append(' // Note must do this prior to the real xglUnMap() or else may get a FAULT')
Jon Ashburn9c8c3622015-02-25 13:51:07 -0700[diff] [blame]329 um_body.append(' glv_enter_critical_section(&g_memInfoLock);')
330 um_body.append(' entry = find_mem_info_entry(mem);')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]331 um_body.append(' CREATE_TRACE_PACKET(xglUnmapMemory, (entry) ? entry->size : 0);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]332 um_body.append(' pPacket = interpret_body_as_xglUnmapMemory(pHeader);')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]333 um_body.append(' if (entry)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]334 um_body.append(' {')
335 um_body.append(' assert(entry->handle == mem);')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]336 um_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pData), entry->size, entry->pData);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]337 um_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));')
338 um_body.append(' entry->pData = NULL;')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]339 um_body.append(' } else')
340 um_body.append(' {')
341 um_body.append(' glv_LogError("Failed to copy app memory into trace packet (idx = %u) on xglUnmapMemory\\n", pHeader->global_packet_index);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]342 um_body.append(' }')
Jon Ashburn9c8c3622015-02-25 13:51:07 -0700[diff] [blame]343 um_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]344 um_body.append(' result = real_xglUnmapMemory(mem);')
345 um_body.append(' pPacket->mem = mem;')
346 um_body.append(' pPacket->result = result;')
347 um_body.append(' FINISH_TRACE_PACKET();')
348 um_body.append(' return result;')
349 um_body.append('}\n')
350 return "\n".join(um_body)
351
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]352 # Take a list of params and return a list of dicts w/ ptr param details
353 def _get_packet_ptr_param_list(self, params):
354 ptr_param_list = []
355 # TODO : This is a slightly nicer way to handle custom cases than initial code, however
356 # this can still be further generalized to eliminate more custom code
357 # big case to handle is when ptrs to structs have embedded data that needs to be accounted for in packet
358 custom_ptr_dict = {'XGL_DEVICE_CREATE_INFO': {'add_txt': 'add_XGL_DEVICE_CREATE_INFO_to_packet(pHeader, (XGL_DEVICE_CREATE_INFO**) &(pPacket->pCreateInfo), pCreateInfo)',
359 'finalize_txt': ''},
360 'XGL_APPLICATION_INFO': {'add_txt': 'add_XGL_APPLICATION_INFO_to_packet(pHeader, (XGL_APPLICATION_INFO**)&(pPacket->pAppInfo), pAppInfo)',
361 'finalize_txt': ''},
362 'XGL_PHYSICAL_GPU': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), *pGpuCount*sizeof(XGL_PHYSICAL_GPU), pGpus)',
363 'finalize_txt': 'default'},
364 'pDataSize': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize)',
365 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize))'},
366 'pData': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData)',
367 'finalize_txt': 'default'},
368 'pName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pName), ((pName != NULL) ? strlen(pName) + 1 : 0), pName)',
369 'finalize_txt': 'default'},
370 'pExtName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pExtName), ((pExtName != NULL) ? strlen(pExtName) + 1 : 0), pExtName)',
371 'finalize_txt': 'default'},
372 'pDescriptorSets': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets)',
373 'finalize_txt': 'default'},
374 'pUpdateChain': {'add_txt': 'add_update_descriptors_to_trace_packet(pHeader, (void**)&(pPacket->pUpdateChain), pUpdateChain)',
375 'finalize_txt': 'default'},
376 'XGL_SHADER_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_SHADER_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), ((pCreateInfo != NULL) ? pCreateInfo->codeSize : 0), pCreateInfo->pCode)',
377 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
378 'XGL_FRAMEBUFFER_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_FRAMEBUFFER_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments), colorCount * sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO), pCreateInfo->pColorAttachments);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment), dsSize, pCreateInfo->pDepthStencilAttachment)',
379 '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))'},
380 'XGL_RENDER_PASS_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_RENDER_PASS_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps), colorCount * sizeof(XGL_ATTACHMENT_LOAD_OP), pCreateInfo->pColorLoadOps);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps), colorCount * sizeof(XGL_ATTACHMENT_STORE_OP), pCreateInfo->pColorStoreOps);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues), colorCount * sizeof(XGL_CLEAR_COLOR), pCreateInfo->pColorLoadClearValues)',
381 'finalize_txt': '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))'},
382 'XGL_CMD_BUFFER_BEGIN_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pBeginInfo), sizeof(XGL_CMD_BUFFER_BEGIN_INFO), pBeginInfo);\n add_begin_cmdbuf_to_trace_packet(pHeader, (void**)&(pPacket->pBeginInfo->pNext), pBeginInfo->pNext)',
383 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBeginInfo))'},
384 'XGL_DYNAMIC_VP_STATE_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pViewports), vpsCount * sizeof(XGL_VIEWPORT), pCreateInfo->pViewports);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pScissors), vpsCount * sizeof(XGL_RECT), pCreateInfo->pScissors)',
385 '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))'},
386 'XGL_MEMORY_ALLOC_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(XGL_MEMORY_ALLOC_INFO), pAllocInfo);\n add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo->pNext), pAllocInfo->pNext)',
387 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo))'},
388 'XGL_GRAPHICS_PIPELINE_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), pCreateInfo);\n add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext)',
389 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
390 'XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSetLayoutInfoList), sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), pSetLayoutInfoList);\n if (pSetLayoutInfoList)\n add_create_ds_layout_to_trace_packet(pHeader, (void**)&(pPacket->pSetLayoutInfoList->pNext), pSetLayoutInfoList->pNext)',
391 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSetLayoutInfoList))'},
392 'XGL_DESCRIPTOR_REGION_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), rgCount * sizeof(XGL_DESCRIPTOR_TYPE_COUNT), pCreateInfo->pTypeCount)',
393 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
394 'XGL_COMPUTE_PIPELINE_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO), pCreateInfo);\n add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);\n add_pipeline_shader_to_trace_packet(pHeader, (XGL_PIPELINE_SHADER*)&pPacket->pCreateInfo->cs, &pCreateInfo->cs)',
395 'finalize_txt': 'finalize_pipeline_shader_address(pHeader, &pPacket->pCreateInfo->cs);\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
396 }
397 for p in params:
398 pp_dict = {}
399 if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
400 if 'const' in p.ty.lower() and 'count' in params[params.index(p)-1].name.lower():
401 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)
402 elif p.ty.strip('*').replace('const ', '') in custom_ptr_dict:
403 pp_dict['add_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['add_txt']
404 pp_dict['finalize_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['finalize_txt']
405 elif p.name in custom_ptr_dict:
406 pp_dict['add_txt'] = custom_ptr_dict[p.name]['add_txt']
407 pp_dict['finalize_txt'] = custom_ptr_dict[p.name]['finalize_txt']
408 # TODO : This is custom hack to account for 2 pData items with dataSize param for sizing
409 if 'pData' == p.name and 'dataSize' == params[params.index(p)-1].name:
410 pp_dict['add_txt'] = pp_dict['add_txt'].replace('_dataSize', 'dataSize')
411 else:
412 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)
413 if 'finalize_txt' not in pp_dict or 'default' == pp_dict['finalize_txt']:
414 pp_dict['finalize_txt'] = 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s))' % (p.name)
415 pp_dict['index'] = params.index(p)
416 ptr_param_list.append(pp_dict)
417 return ptr_param_list
418
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]419 # Take a list of params and return a list of packet size elements
420 def _get_packet_size(self, params):
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]421 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]422 skip_list = [] # store params that are already accounted for so we don't count them twice
423 # Dict of specific params with unique custom sizes
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]424 custom_size_dict = {'pSetBindPoints': '(XGL_SHADER_STAGE_COMPUTE * sizeof(uint32_t))', # Accounting for largest possible array
425 }
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]426 for p in params:
427 #First handle custom cases
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]428 if p.name in ['pCreateInfo', 'pUpdateChain', 'pSetLayoutInfoList', 'pBeginInfo', 'pAllocInfo']:
429 ps.append('get_struct_chain_size((void*)%s)' % p.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]430 skip_list.append(p.name)
431 elif p.name in custom_size_dict:
432 ps.append(custom_size_dict[p.name])
433 skip_list.append(p.name)
434 # Skip any params already handled
435 if p.name in skip_list:
436 continue
437 # Now check to identify dynamic arrays which depend on two params
438 if 'count' in p.name.lower():
439 next_idx = params.index(p)+1
440 # If next element is a const *, then multiply count and array type
441 if next_idx < len(params) and '*' in params[next_idx].ty and 'const' in params[next_idx].ty.lower():
442 if '*' in p.ty:
443 ps.append('*%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
444 else:
445 ps.append('%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
446 skip_list.append(params[next_idx].name)
447 elif '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
448 if 'pData' == p.name:
449 if 'dataSize' == params[params.index(p)-1].name:
450 ps.append('dataSize')
451 elif 'counterCount' == params[params.index(p)-1].name:
452 ps.append('sizeof(%s)' % p.ty.strip('*').replace('const ', ''))
453 else:
454 ps.append('((pDataSize != NULL && pData != NULL) ? *pDataSize : 0)')
455 elif '**' in p.ty and 'void' in p.ty:
456 ps.append('sizeof(void*)')
457 elif 'void' in p.ty:
458 ps.append('sizeof(%s)' % p.name)
459 elif 'char' in p.ty:
460 ps.append('((%s != NULL) ? strlen(%s) + 1 : 0)' % (p.name, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]461 elif 'pDataSize' in p.name:
462 ps.append('((pDataSize != NULL) ? sizeof(size_t) : 0)')
463 elif 'IMAGE_SUBRESOURCE' in p.ty and 'pSubresource' == p.name:
464 ps.append('((pSubresource != NULL) ? sizeof(XGL_IMAGE_SUBRESOURCE) : 0)')
465 else:
466 ps.append('sizeof(%s)' % (p.ty.strip('*').replace('const ', '')))
467 return ps
468
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]469 # 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]470 # Here's the general flow of code insertion w/ option items flagged w/ "?"
471 # Result decl?
472 # Packet struct decl
473 # ?Special case : setup call to function first and do custom API call time tracking
474 # CREATE_PACKET
475 # Call (w/ result?)
476 # Assign packet values
477 # FINISH packet
478 # return result?
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]479 def _generate_trace_funcs(self):
480 func_body = []
481 for proto in self.protos:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]482 if 'UnmapMemory' == proto.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]483 func_body.append(self._gen_unmap_memory())
484 elif 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]485 raw_packet_update_list = [] # non-ptr elements placed directly into packet
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]486 ptr_packet_update_list = [] # ptr elements to be updated into packet
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]487 return_txt = ''
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]488 packet_size = []
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]489 in_data_size = False # flag when we need to capture local input size variable for in/out size
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]490 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]491 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 if NULL
492 if '[' in p.ty: # Correctly declare static arrays in function parameters
493 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]494 else:
495 func_body.append(' %s %s,' % (p.ty, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]496 if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
497 if 'pDataSize' in p.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]498 in_data_size = True;
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]499 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]500 if '[' in p.ty:
Tobin Ehlis8a5a85b2015-02-25 11:30:27 -0700[diff] [blame]501 array_str = p.ty[p.ty.find('[')+1:p.ty.find(']')]
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]502 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]503 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]504 raw_packet_update_list.append(' pPacket->%s = %s;' % (p.name, p.name))
505 # Get list of packet size modifiers due to ptr params
506 packet_size = self._get_packet_size(proto.params)
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]507 ptr_packet_update_list = self._get_packet_ptr_param_list(proto.params)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]508 func_body[-1] = func_body[-1].replace(',', ')')
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]509 # End of function declaration portion, begin function body
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]510 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]511 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]512 func_body.append(' %s result;' % proto.ret)
513 return_txt = 'result = '
514 if in_data_size:
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]515 func_body.append(' size_t _dataSize;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]516 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]517 # functions that have non-standard sequence of packet creation and calling real function
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]518 # NOTE: Anytime we call the function before CREATE_TRACE_PACKET, need to add custom code for correctly tracking API call time
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]519 if 'CreateInstance' == proto.name:
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]520 func_body.append(' uint64_t startTime;')
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]521 func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')
522 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
523 func_body.append(' if (real_xglCreateInstance == xglCreateInstance)')
524 func_body.append(' {')
525 func_body.append(' glv_platform_get_next_lib_sym((void **) &real_xglCreateInstance,"xglCreateInstance");')
526 func_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]527 func_body.append(' startTime = glv_get_time();')
528 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Tobin Ehlis284cf2d2015-03-16 08:21:33 -0600[diff] [blame]529 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(XGL_INSTANCE) + get_struct_chain_size((void*)pAppInfo) + ((pAllocCb == NULL) ? 0 :sizeof(XGL_ALLOC_CALLBACKS)));' % (proto.name))
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]530 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]531 func_body.append(' if (isHooked == FALSE) {')
532 func_body.append(' AttachHooks();')
533 func_body.append(' AttachHooks_xgldbg();')
534 func_body.append(' AttachHooks_xglwsix11ext();')
535 func_body.append(' }')
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]536 elif 'EnumerateGpus' == proto.name:
537 func_body.append(' uint64_t startTime;')
538 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
539 func_body.append(' startTime = glv_get_time();')
540 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
541 func_body.append(' CREATE_TRACE_PACKET(xglEnumerateGpus, sizeof(uint32_t) + ((pGpus && pGpuCount) ? *pGpuCount * sizeof(XGL_PHYSICAL_GPU) : 0));')
542 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
543 elif 'EnumerateLayers' == proto.name:
544 func_body.append(' uint64_t startTime;')
545 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
546 func_body.append(' startTime = glv_get_time();')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]547 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]548 func_body.append(' size_t totStringSize = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]549 func_body.append(' uint32_t i = 0;')
550 func_body.append(' for (i = 0; i < *pOutLayerCount; i++)')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]551 func_body.append(' totStringSize += (pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1: 0;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]552 func_body.append(' CREATE_TRACE_PACKET(xgl%s, totStringSize + sizeof(size_t));' % (proto.name))
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]553 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]554 elif 'AllocDescriptorSets' == proto.name:
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]555 func_body.append(' uint64_t startTime;')
556 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
557 func_body.append(' startTime = glv_get_time();')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]558 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
559 func_body.append(' size_t customSize = (*pCount <= 0) ? (sizeof(XGL_DESCRIPTOR_SET)) : (*pCount * sizeof(XGL_DESCRIPTOR_SET));')
560 func_body.append(' CREATE_TRACE_PACKET(xglAllocDescriptorSets, sizeof(XGL_DESCRIPTOR_SET_LAYOUT) + customSize + sizeof(uint32_t));')
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]561 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]562 elif proto.name in ['CreateFramebuffer', 'CreateRenderPass', 'CreateDynamicViewportState',
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]563 'CreateDescriptorRegion', 'CmdWaitEvents', 'CmdPipelineBarrier']:
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]564 # 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]565 if 'CreateFramebuffer' == proto.name:
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]566 func_body.append(' int dsSize = (pCreateInfo != NULL && pCreateInfo->pDepthStencilAttachment != NULL) ? sizeof(XGL_DEPTH_STENCIL_BIND_INFO) : 0;')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]567 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && pCreateInfo->pColorAttachments != NULL) ? pCreateInfo->colorAttachmentCount : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]568 func_body.append(' CREATE_TRACE_PACKET(xglCreateFramebuffer, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_FRAMEBUFFER));')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]569 elif 'CreateRenderPass' == proto.name:
Jon Ashburnec7dcb42015-02-20 10:30:32 -0700[diff] [blame]570 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && (pCreateInfo->pColorLoadOps != NULL || pCreateInfo->pColorStoreOps != NULL || pCreateInfo->pColorLoadClearValues != NULL)) ? pCreateInfo->colorAttachmentCount : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]571 func_body.append(' CREATE_TRACE_PACKET(xglCreateRenderPass, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_RENDER_PASS));')
Jon Ashburn8e7dcd02015-02-04 08:50:35 -0700[diff] [blame]572 elif 'CreateDynamicViewportState' == proto.name:
Courtney Goeltzenleuchterc6e32f92015-02-11 14:13:34 -0700[diff] [blame]573 func_body.append(' uint32_t vpsCount = (pCreateInfo != NULL && pCreateInfo->pViewports != NULL) ? pCreateInfo->viewportAndScissorCount : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]574 func_body.append(' CREATE_TRACE_PACKET(xglCreateDynamicViewportState, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_DYNAMIC_VP_STATE_OBJECT));')
Jon Ashburnfb3769a2015-02-04 09:32:59 -0700[diff] [blame]575 elif 'CreateDescriptorRegion' == proto.name:
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]576 func_body.append(' uint32_t rgCount = (pCreateInfo != NULL && pCreateInfo->pTypeCount != NULL) ? pCreateInfo->count : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]577 func_body.append(' CREATE_TRACE_PACKET(xglCreateDescriptorRegion, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_DESCRIPTOR_REGION));')
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]578 else: # ['CmdWaitEvents', 'CmdPipelineBarrier']:
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]579 func_body.append(' size_t customSize;')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]580 event_array_type = 'XGL_EVENT'
581 if 'CmdPipelineBarrier' == proto.name:
582 event_array_type = 'XGL_SET_EVENT'
583 func_body.append(' uint32_t eventCount = (%s != NULL && %s->pEvents != NULL) ? %s->eventCount : 0;' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].name))
584 func_body.append(' uint32_t mbCount = (%s != NULL && %s->ppMemBarriers != NULL) ? %s->memBarrierCount : 0;' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].name))
Jon Ashburn1751d7a2015-02-10 13:49:30 -0700[diff] [blame]585 func_body.append(' customSize = (eventCount * sizeof(%s)) + mbCount * sizeof(void*) + calculate_memory_barrier_size(mbCount, %s->ppMemBarriers);' % (event_array_type, proto.params[-1].name))
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]586 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(%s) + customSize);' % (proto.name, proto.params[-1].ty.strip('*').replace('const ', '')))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]587 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
588 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]589 if (0 == len(packet_size)):
590 func_body.append(' CREATE_TRACE_PACKET(xgl%s, 0);' % (proto.name))
591 else:
592 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, ' + '.join(packet_size)))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]593 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]594 if in_data_size:
595 func_body.append(' _dataSize = (pDataSize == NULL || pData == NULL) ? 0 : *pDataSize;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]596 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]597 func_body.append('\n'.join(raw_packet_update_list))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]598 if 'MapMemory' == proto.name: # Custom code for MapMem case
599 func_body.append(' if (ppData != NULL)')
600 func_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]601 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppData), sizeof(void*), *ppData);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]602 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));')
603 func_body.append(' add_data_to_mem_info(mem, *ppData);')
604 func_body.append(' }')
605 func_body.append(' pPacket->result = result;')
606 func_body.append(' FINISH_TRACE_PACKET();')
607 elif 'EnumerateLayers' == proto.name: #custom code for EnumerateLayers case
608 func_body.append(' pPacket->gpu = gpu;')
609 func_body.append(' pPacket->maxLayerCount = maxLayerCount;')
610 func_body.append(' pPacket->maxStringSize = maxStringSize;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]611 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayerCount), sizeof(size_t), pOutLayerCount);')
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]612 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayerCount));')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]613 func_body.append(' for (i = 0; i < *pOutLayerCount; i++) {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]614 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayers[i]), ((pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1 : 0), pOutLayers[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]615 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayers[i]));')
616 func_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]617
618 func_body.append(' pPacket->pReserved = pReserved;')
619 func_body.append(' pPacket->result = result;')
620 func_body.append(' FINISH_TRACE_PACKET();')
621 else:
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]622 for pp_dict in ptr_packet_update_list: #buff_ptr_indices:
623 func_body.append(' %s;' % (pp_dict['add_txt']))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]624 # Some custom add_* and finalize_* function calls for Create* API calls
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]625 if proto.name in ['CmdWaitEvents', 'CmdPipelineBarrier']:
626 event_array_type = 'XGL_EVENT'
627 if 'CmdPipelineBarrier' == proto.name:
628 event_array_type = 'XGL_SET_EVENT'
629 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->pEvents), eventCount * sizeof(%s), %s->pEvents);' % (proto.params[-1].name, event_array_type, proto.params[-1].name))
630 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->pEvents));' % (proto.params[-1].name))
631 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->ppMemBarriers), mbCount * sizeof(void*), %s->ppMemBarriers);' % (proto.params[-1].name, proto.params[-1].name))
632 func_body.append(' uint32_t i, siz;')
633 func_body.append(' for (i = 0; i < mbCount; i++) {')
634 func_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) %s->ppMemBarriers[i];' % proto.params[-1].name)
635 func_body.append(' switch (pNext->sType) {')
636 func_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:')
637 func_body.append(' siz = sizeof(XGL_MEMORY_BARRIER);')
638 func_body.append(' break;')
639 func_body.append(' case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:')
640 func_body.append(' siz = sizeof(XGL_BUFFER_MEMORY_BARRIER);')
641 func_body.append(' break;')
642 func_body.append(' case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:')
643 func_body.append(' siz = sizeof(XGL_IMAGE_MEMORY_BARRIER);')
644 func_body.append(' break;')
645 func_body.append(' default:')
646 func_body.append(' assert(0);')
647 func_body.append(' siz = 0;')
648 func_body.append(' break;')
649 func_body.append(' }')
650 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->ppMemBarriers[i]), siz, %s->ppMemBarriers[i]);' % (proto.params[-1].name, proto.params[-1].name))
651 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->ppMemBarriers[i]));' % (proto.params[-1].name))
652 func_body.append(' }')
653 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->ppMemBarriers));' % (proto.params[-1].name))
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]654 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]655 func_body.append(' pPacket->result = result;')
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]656 for pp_dict in ptr_packet_update_list:
657 if ('DEVICE_CREATE_INFO' 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):
658 func_body.append(' %s;' % (pp_dict['finalize_txt']))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]659 func_body.append(' FINISH_TRACE_PACKET();')
660 if 'AllocMemory' in proto.name:
661 func_body.append(' add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);')
662 elif 'FreeMemory' in proto.name:
663 func_body.append(' rm_handle_from_mem_info(mem);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]664 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]665 func_body.append(' return result;')
666 func_body.append('}\n')
667 return "\n".join(func_body)
668
669 def _generate_trace_funcs_ext(self, func_class='Wsi'):
670 thread_once_funcs = ['DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback', 'DbgSetGlobalOption']
671 func_body = []
672 for proto in self.protos:
673 if func_class in proto.name:
674 packet_update_txt = ''
675 return_txt = ''
676 packet_size = ''
677 buff_ptr_indices = []
678 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
679 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL
680 func_body.append(' %s %s,' % (p.ty, p.name))
681 if 'Size' in p.name:
682 packet_size += p.name
683 if '*' in p.ty and 'pSysMem' != p.name:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]684 if 'char' in p.ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]685 packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]686 elif 'Size' not in packet_size:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]687 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]688 buff_ptr_indices.append(proto.params.index(p))
689 if 'pConnectionInfo' in p.name:
690 packet_size += '((pConnectionInfo->pConnection != NULL) ? sizeof(void *) : 0)'
691 else:
692 packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)
693 if '' == packet_size:
694 packet_size = '0'
695 else:
696 packet_size = packet_size.strip(' + ')
697 func_body[-1] = func_body[-1].replace(',', ')')
698 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]699 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]700 func_body.append(' %s result;' % proto.ret)
701 return_txt = 'result = '
702 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
703 if proto.name in thread_once_funcs:
704 func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')
705 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]706 if 'DbgRegisterMsgCallback' in proto.name:
707 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(char));' % proto.name)
708 else:
709 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]710 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
711 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
712 func_body.append(packet_update_txt.strip('\n'))
713 for idx in buff_ptr_indices:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]714 if 'char' in proto.params[idx].ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]715 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]716 elif 'Size' in proto.params[idx-1].name:
717 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]718 elif 'DbgRegisterMsgCallback' in proto.name:
719 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]720 else:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]721 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]722 if 'WsiX11AssociateConnection' in proto.name:
723 func_body.append(' if (pConnectionInfo->pConnection != NULL) {')
724 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection), sizeof(void *), pConnectionInfo->pConnection);')
725 func_body.append(' glv_finalize_buffer_address(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection));')
726 func_body.append(' }')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]727 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]728 func_body.append(' pPacket->result = result;')
729 for idx in buff_ptr_indices:
730 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))
731 func_body.append(' FINISH_TRACE_PACKET();')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]732 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]733 func_body.append(' return result;')
734 func_body.append('}\n')
735 return "\n".join(func_body)
736
737 def _generate_helper_funcs(self):
738 hf_body = []
739 hf_body.append('// Support for shadowing CPU mapped memory')
740 hf_body.append('typedef struct _XGLAllocInfo {')
741 hf_body.append(' XGL_GPU_SIZE size;')
742 hf_body.append(' XGL_GPU_MEMORY handle;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]743 hf_body.append(' void *pData;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]744 hf_body.append(' BOOL valid;')
745 hf_body.append('} XGLAllocInfo;')
746 hf_body.append('typedef struct _XGLMemInfo {')
747 hf_body.append(' unsigned int numEntrys;')
748 hf_body.append(' XGLAllocInfo *pEntrys;')
749 hf_body.append(' XGLAllocInfo *pLastMapped;')
750 hf_body.append(' unsigned int capacity;')
751 hf_body.append('} XGLMemInfo;')
752 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]753 hf_body.append('static XGLMemInfo g_memInfo = {0, NULL, NULL, 0};')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]754 hf_body.append('')
755 hf_body.append('static void init_mem_info_entrys(XGLAllocInfo *ptr, const unsigned int num)')
756 hf_body.append('{')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]757 hf_body.append(' unsigned int i;')
758 hf_body.append(' for (i = 0; i < num; i++)')
759 hf_body.append(' {')
760 hf_body.append(' XGLAllocInfo *entry = ptr + i;')
761 hf_body.append(' entry->pData = NULL;')
762 hf_body.append(' entry->size = 0;')
763 hf_body.append(' entry->handle = NULL;')
764 hf_body.append(' entry->valid = FALSE;')
765 hf_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]766 hf_body.append('}')
767 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]768 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]769 hf_body.append('static void init_mem_info()')
770 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]771 hf_body.append(' g_memInfo.numEntrys = 0;')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]772 hf_body.append(' g_memInfo.capacity = 4096;')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]773 hf_body.append(' g_memInfo.pLastMapped = NULL;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]774 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]775 hf_body.append(' g_memInfo.pEntrys = GLV_NEW_ARRAY(XGLAllocInfo, g_memInfo.capacity);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]776 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]777 hf_body.append(' if (g_memInfo.pEntrys == NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]778 hf_body.append(' glv_LogError("init_mem_info() malloc failed\\n");')
779 hf_body.append(' else')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]780 hf_body.append(' init_mem_info_entrys(g_memInfo.pEntrys, g_memInfo.capacity);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]781 hf_body.append('}')
782 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]783 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]784 hf_body.append('static void delete_mem_info()')
785 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]786 hf_body.append(' GLV_DELETE(g_memInfo.pEntrys);')
787 hf_body.append(' g_memInfo.pEntrys = NULL;')
788 hf_body.append(' g_memInfo.numEntrys = 0;')
789 hf_body.append(' g_memInfo.capacity = 0;')
790 hf_body.append(' g_memInfo.pLastMapped = NULL;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]791 hf_body.append('}')
792 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]793 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]794 hf_body.append('static XGLAllocInfo * get_mem_info_entry()')
795 hf_body.append('{')
796 hf_body.append(' unsigned int i;')
797 hf_body.append(' XGLAllocInfo *entry;')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]798 hf_body.append(' if (g_memInfo.numEntrys > g_memInfo.capacity)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]799 hf_body.append(' {')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]800 hf_body.append(' glv_LogError("get_mem_info_entry() bad internal state numEntrys %u\\n", g_memInfo.numEntrys);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]801 hf_body.append(' return NULL;')
802 hf_body.append(' }')
803 hf_body.append('')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]804 hf_body.append(' entry = g_memInfo.pEntrys;')
805 hf_body.append(' for (i = 0; i < g_memInfo.numEntrys; i++)')
806 hf_body.append(' {')
807 hf_body.append(' if ((entry + i)->valid == FALSE)')
808 hf_body.append(' return entry + i;')
809 hf_body.append(' }')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]810 hf_body.append(' if (g_memInfo.numEntrys == g_memInfo.capacity)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]811 hf_body.append(' { // grow the array 2x')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]812 hf_body.append(' g_memInfo.capacity *= 2;')
813 hf_body.append(' g_memInfo.pEntrys = (XGLAllocInfo *) GLV_REALLOC(g_memInfo.pEntrys, g_memInfo.capacity * sizeof(XGLAllocInfo));')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]814 hf_body.append(' if (g_memInfo.pEntrys == NULL)')
815 hf_body.append(' glv_LogError("get_mem_info_entry() realloc failed\\n");')
816 hf_body.append(' //glv_LogInfo("realloc memInfo from %u to %u\\n", g_memInfo.capacity /2, g_memInfo.capacity);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]817 hf_body.append(' //init the newly added entrys')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]818 hf_body.append(' init_mem_info_entrys(g_memInfo.pEntrys + g_memInfo.capacity / 2, g_memInfo.capacity / 2);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]819 hf_body.append(' }')
820 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]821 hf_body.append(' assert(g_memInfo.numEntrys < g_memInfo.capacity);')
Jon Ashburn51a52e82015-02-20 14:48:27 -0700[diff] [blame]822 hf_body.append(' entry = g_memInfo.pEntrys + g_memInfo.numEntrys;')
823 hf_body.append(' g_memInfo.numEntrys++;')
824 hf_body.append(' assert(entry->valid == FALSE);')
825 hf_body.append(' return entry;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]826 hf_body.append('}')
827 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]828 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]829 hf_body.append('static XGLAllocInfo * find_mem_info_entry(const XGL_GPU_MEMORY handle)')
830 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]831 hf_body.append(' XGLAllocInfo *entry;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]832 hf_body.append(' unsigned int i;')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]833 hf_body.append(' entry = g_memInfo.pEntrys;')
834 hf_body.append(' if (g_memInfo.pLastMapped && g_memInfo.pLastMapped->handle == handle && g_memInfo.pLastMapped->valid)')
835 hf_body.append(' {')
836 hf_body.append(' return g_memInfo.pLastMapped;')
837 hf_body.append(' }')
838 hf_body.append(' for (i = 0; i < g_memInfo.numEntrys; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]839 hf_body.append(' {')
840 hf_body.append(' if ((entry + i)->valid && (handle == (entry + i)->handle))')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]841 hf_body.append(' {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]842 hf_body.append(' return entry + i;')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]843 hf_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]844 hf_body.append(' }')
845 hf_body.append('')
846 hf_body.append(' return NULL;')
847 hf_body.append('}')
848 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]849 hf_body.append('static XGLAllocInfo * find_mem_info_entry_lock(const XGL_GPU_MEMORY handle)')
850 hf_body.append('{')
851 hf_body.append(' XGLAllocInfo *res;')
852 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
853 hf_body.append(' res = find_mem_info_entry(handle);')
854 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
855 hf_body.append(' return res;')
856 hf_body.append('}')
857 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]858 hf_body.append('static void add_new_handle_to_mem_info(const XGL_GPU_MEMORY handle, XGL_GPU_SIZE size, void *pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]859 hf_body.append('{')
860 hf_body.append(' XGLAllocInfo *entry;')
861 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]862 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
863 hf_body.append(' if (g_memInfo.capacity == 0)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]864 hf_body.append(' init_mem_info();')
865 hf_body.append('')
866 hf_body.append(' entry = get_mem_info_entry();')
867 hf_body.append(' if (entry)')
868 hf_body.append(' {')
869 hf_body.append(' entry->valid = TRUE;')
870 hf_body.append(' entry->handle = handle;')
871 hf_body.append(' entry->size = size;')
872 hf_body.append(' entry->pData = pData; // NOTE: xglFreeMemory will free this mem, so no malloc()')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]873 hf_body.append(' }')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]874 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]875 hf_body.append('}')
876 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]877 hf_body.append('static void add_data_to_mem_info(const XGL_GPU_MEMORY handle, void *pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]878 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]879 hf_body.append(' XGLAllocInfo *entry;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]880 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]881 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
882 hf_body.append(' entry = find_mem_info_entry(handle);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]883 hf_body.append(' if (entry)')
884 hf_body.append(' {')
885 hf_body.append(' entry->pData = pData;')
886 hf_body.append(' }')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]887 hf_body.append(' g_memInfo.pLastMapped = entry;')
888 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]889 hf_body.append('}')
890 hf_body.append('')
891 hf_body.append('static void rm_handle_from_mem_info(const XGL_GPU_MEMORY handle)')
892 hf_body.append('{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]893 hf_body.append(' XGLAllocInfo *entry;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]894 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]895 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
896 hf_body.append(' entry = find_mem_info_entry(handle);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]897 hf_body.append(' if (entry)')
898 hf_body.append(' {')
899 hf_body.append(' entry->valid = FALSE;')
900 hf_body.append(' entry->pData = NULL;')
901 hf_body.append(' entry->size = 0;')
902 hf_body.append(' entry->handle = NULL;')
903 hf_body.append('')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]904 hf_body.append(' if (entry == g_memInfo.pLastMapped)')
905 hf_body.append(' g_memInfo.pLastMapped = NULL;')
Jon Ashburn7c4d26f2015-02-26 11:45:28 -0700[diff] [blame]906 hf_body.append(' // adjust numEntrys to be last valid entry in list')
907 hf_body.append(' do {')
908 hf_body.append(' entry = g_memInfo.pEntrys + g_memInfo.numEntrys - 1;')
909 hf_body.append(' if (entry->valid == FALSE)')
910 hf_body.append(' g_memInfo.numEntrys--;')
911 hf_body.append(' } while ((entry->valid == FALSE) && (g_memInfo.numEntrys > 0));')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]912 hf_body.append(' if (g_memInfo.numEntrys == 0)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]913 hf_body.append(' delete_mem_info();')
914 hf_body.append(' }')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]915 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]916 hf_body.append('}')
917 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]918 hf_body.append('static void add_begin_cmdbuf_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]919 hf_body.append('{')
920 hf_body.append(' const XGL_CMD_BUFFER_BEGIN_INFO* pInNow = pIn;')
921 hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)ppOut;')
922 hf_body.append(' while (pInNow != NULL)')
923 hf_body.append(' {')
924 hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNow = ppOutNext;')
925 hf_body.append(' ppOutNext = NULL;')
926 hf_body.append('')
927 hf_body.append(' switch (pInNow->sType)')
928 hf_body.append(' {')
929 hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')
930 hf_body.append(' {')
931 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO), pInNow);')
932 hf_body.append(' ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)&(*ppOutNow)->pNext;')
933 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
934 hf_body.append(' break;')
935 hf_body.append(' }')
936 hf_body.append(' default:')
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]937 hf_body.append(' assert(!"Encountered an unexpected type in cmdbuffer_begin_info list");')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]938 hf_body.append(' }')
939 hf_body.append(' pInNow = (XGL_CMD_BUFFER_BEGIN_INFO*)pInNow->pNext;')
940 hf_body.append(' }')
941 hf_body.append(' return;')
942 hf_body.append('}')
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]943 hf_body.append('')
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]944 hf_body.append('static void add_alloc_memory_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
945 hf_body.append('{')
946 hf_body.append(' const XGL_MEMORY_ALLOC_INFO* pInNow = pIn;')
947 hf_body.append(' XGL_MEMORY_ALLOC_INFO** ppOutNext = (XGL_MEMORY_ALLOC_INFO**)ppOut;')
948 hf_body.append(' while (pInNow != NULL)')
949 hf_body.append(' {')
950 hf_body.append(' XGL_MEMORY_ALLOC_INFO** ppOutNow = ppOutNext;')
951 hf_body.append(' ppOutNext = NULL;')
952 hf_body.append('')
953 hf_body.append(' switch (pInNow->sType)')
954 hf_body.append(' {')
955 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:')
956 hf_body.append(' {')
957 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO), pInNow);')
958 hf_body.append(' ppOutNext = (XGL_MEMORY_ALLOC_INFO**)&(*ppOutNow)->pNext;')
959 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
960 hf_body.append(' break;')
961 hf_body.append(' }')
962 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:')
963 hf_body.append(' {')
964 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO), pInNow);')
965 hf_body.append(' ppOutNext = (XGL_MEMORY_ALLOC_INFO**)&(*ppOutNow)->pNext;')
966 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
967 hf_body.append(' break;')
968 hf_body.append(' }')
969 hf_body.append(' default:')
970 hf_body.append(' assert(!"Encountered an unexpected type in memory_alloc_info list");')
971 hf_body.append(' }')
972 hf_body.append(' pInNow = (XGL_MEMORY_ALLOC_INFO*)pInNow->pNext;')
973 hf_body.append(' }')
974 hf_body.append(' return;')
975 hf_body.append('}')
976 hf_body.append('')
Jon Ashburn1751d7a2015-02-10 13:49:30 -0700[diff] [blame]977 hf_body.append('static size_t calculate_memory_barrier_size(uint32_t mbCount, const void** ppMemBarriers)')
978 hf_body.append('{')
979 hf_body.append(' uint32_t i, siz=0;')
980 hf_body.append(' for (i = 0; i < mbCount; i++) {')
981 hf_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) ppMemBarriers[i];')
982 hf_body.append(' switch (pNext->sType) {')
983 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:')
984 hf_body.append(' siz += sizeof(XGL_MEMORY_BARRIER);')
985 hf_body.append(' break;')
986 hf_body.append(' case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:')
987 hf_body.append(' siz += sizeof(XGL_BUFFER_MEMORY_BARRIER);')
988 hf_body.append(' break;')
989 hf_body.append(' case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:')
990 hf_body.append(' siz += sizeof(XGL_IMAGE_MEMORY_BARRIER);')
991 hf_body.append(' break;')
992 hf_body.append(' default:')
993 hf_body.append(' assert(0);')
994 hf_body.append(' break;')
995 hf_body.append(' }')
996 hf_body.append(' }')
997 hf_body.append(' return siz;')
998 hf_body.append('}')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]999 hf_body.append('')
1000 hf_body.append('static void add_pipeline_shader_to_trace_packet(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* packetShader, const XGL_PIPELINE_SHADER* paramShader)')
1001 hf_body.append('{')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1002 hf_body.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1003 hf_body.append(' // constant buffers')
1004 hf_body.append(' if (paramShader->linkConstBufferCount > 0 && paramShader->pLinkConstBufferInfo != NULL)')
1005 hf_body.append(' {')
1006 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo), sizeof(XGL_LINK_CONST_BUFFER) * paramShader->linkConstBufferCount, paramShader->pLinkConstBufferInfo);')
1007 hf_body.append(' for (i = 0; i < paramShader->linkConstBufferCount; i++)')
1008 hf_body.append(' {')
1009 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData), packetShader->pLinkConstBufferInfo[i].bufferSize, paramShader->pLinkConstBufferInfo[i].pBufferData);')
1010 hf_body.append(' }')
1011 hf_body.append(' }')
1012 hf_body.append('}')
1013 hf_body.append('')
1014 hf_body.append('static void finalize_pipeline_shader_address(glv_trace_packet_header* pHeader, const XGL_PIPELINE_SHADER* packetShader)')
1015 hf_body.append('{')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1016 hf_body.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1017 hf_body.append(' // constant buffers')
1018 hf_body.append(' if (packetShader->linkConstBufferCount > 0 && packetShader->pLinkConstBufferInfo != NULL)')
1019 hf_body.append(' {')
1020 hf_body.append(' for (i = 0; i < packetShader->linkConstBufferCount; i++)')
1021 hf_body.append(' {')
1022 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData));')
1023 hf_body.append(' }')
1024 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo));')
1025 hf_body.append(' }')
1026 hf_body.append('}')
1027 hf_body.append('')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1028 hf_body.append('static void add_create_ds_layout_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
1029 hf_body.append('{')
1030 hf_body.append(' const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInNow = pIn;')
1031 hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO** ppOutNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO**)ppOut;')
1032 hf_body.append(' while (pInNow != NULL)')
1033 hf_body.append(' {')
1034 hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO** ppOutNow = ppOutNext;')
1035 hf_body.append(' ppOutNext = NULL;')
1036 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), pInNow);')
1037 hf_body.append(' ppOutNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO**)&(*ppOutNow)->pNext;')
1038 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1039 hf_body.append(' pInNow = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pInNow->pNext;')
1040 hf_body.append(' }')
1041 hf_body.append(' return;')
1042 hf_body.append('}')
1043 hf_body.append('')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1044 hf_body.append('static void add_update_descriptors_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
1045 hf_body.append('{')
1046 hf_body.append(' const XGL_UPDATE_SAMPLERS* pInNow = pIn;')
1047 hf_body.append(' XGL_UPDATE_SAMPLERS** ppOutNext = (XGL_UPDATE_SAMPLERS**)ppOut;')
1048 hf_body.append(' while (pInNow != NULL)')
1049 hf_body.append(' {')
1050 hf_body.append(' XGL_UPDATE_SAMPLERS** ppOutNow = ppOutNext;')
1051 hf_body.append(' ppOutNext = NULL;')
1052 hf_body.append(' switch (pInNow->sType)')
1053 hf_body.append(' {')
1054 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
1055 hf_body.append(' {')
1056 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_SAMPLERS), pInNow);')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1057 hf_body.append(' XGL_UPDATE_SAMPLERS* pPacket = (XGL_UPDATE_SAMPLERS*)*ppOutNow;')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1058 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplers, ((XGL_UPDATE_SAMPLERS*)pInNow)->count * sizeof(XGL_SAMPLER), ((XGL_UPDATE_SAMPLERS*)pInNow)->pSamplers);')
1059 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplers));')
1060 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1061 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1062 hf_body.append(' break;')
1063 hf_body.append(' }')
1064 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
1065 hf_body.append(' {')
1066 #hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_SAMPLER_TEXTURES) + ((XGL_UPDATE_SAMPLER_TEXTURES*)pNext)->count * (sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1067 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_SAMPLER_TEXTURES), pInNow);')
1068 hf_body.append(' XGL_UPDATE_SAMPLER_TEXTURES* pPacket = (XGL_UPDATE_SAMPLER_TEXTURES*)*ppOutNow;')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1069 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplerImageViews, ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->count * sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO), ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->pSamplerImageViews);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1070 # TODO : This is still broken. How to update the original XGL_SAMPLER_IMAGE_VIEW_INFO struct ptrs to have correct address for newly added XGL_IMAGE_VIEW_ATTACH_INFO blocks below?
1071 hf_body.append(' uint32_t i;')
1072 hf_body.append(' for (i = 0; i < ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->count; i++) {')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1073 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplerImageViews[i].pImageView, sizeof(XGL_IMAGE_VIEW_ATTACH_INFO), ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->pSamplerImageViews[i].pImageView);')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1074 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplerImageViews[i].pImageView));')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1075 hf_body.append(' }')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1076 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplerImageViews));')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1077 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1078 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1079 hf_body.append(' break;')
1080 hf_body.append(' }')
1081 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
1082 hf_body.append(' {')
1083 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_IMAGES), pInNow);')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1084 hf_body.append(' XGL_UPDATE_IMAGES* pPacket = (XGL_UPDATE_IMAGES*)*ppOutNow;')
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1085 hf_body.append(' uint32_t i;')
1086 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pImageViews, ((XGL_UPDATE_IMAGES*)pInNow)->count * sizeof(XGL_IMAGE_VIEW_ATTACH_INFO *), ((XGL_UPDATE_IMAGES*)pInNow)->pImageViews);')
1087 hf_body.append(' for (i = 0; i < ((XGL_UPDATE_IMAGES*)pInNow)->count; i++) {')
1088 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pImageViews[i], sizeof(XGL_IMAGE_VIEW_ATTACH_INFO), ((XGL_UPDATE_IMAGES*)pInNow)->pImageViews[i]);')
1089 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImageViews[i]));')
1090 hf_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1091 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImageViews));')
1092 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1093 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1094 hf_body.append(' break;')
1095 hf_body.append(' }')
1096 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
1097 hf_body.append(' {')
1098 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_BUFFERS), pInNow);')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1099 hf_body.append(' XGL_UPDATE_BUFFERS* pPacket = (XGL_UPDATE_BUFFERS*)*ppOutNow;')
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1100 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pBufferViews, ((XGL_UPDATE_BUFFERS*)pInNow)->count * sizeof(XGL_BUFFER_VIEW_ATTACH_INFO *), ((XGL_UPDATE_BUFFERS*)pInNow)->pBufferViews);')
1101 hf_body.append(' uint32_t i;')
1102 hf_body.append(' for (i = 0; i < ((XGL_UPDATE_BUFFERS*)pInNow)->count; i++) {')
1103 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pBufferViews[i], sizeof(XGL_BUFFER_VIEW_ATTACH_INFO), ((XGL_UPDATE_BUFFERS*)pInNow)->pBufferViews[i]);')
1104 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBufferViews[i]));')
1105 hf_body.append(' }')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1106 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBufferViews));')
1107 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1108 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1109 hf_body.append(' break;')
1110 hf_body.append(' }')
1111 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
1112 hf_body.append(' {')
1113 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_AS_COPY), pInNow);')
1114 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1115 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1116 hf_body.append(' break;')
1117 hf_body.append(' }')
1118 hf_body.append(' default:')
1119 hf_body.append(' assert(0);')
1120 hf_body.append(' }')
1121 hf_body.append(' pInNow = (XGL_UPDATE_SAMPLERS*)pInNow->pNext;')
1122 hf_body.append(' }')
1123 hf_body.append(' return;')
1124 hf_body.append('}')
1125 hf_body.append('')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1126 pipe_state_list = ['IA_STATE_CREATE_INFO',
1127 'TESS_STATE_CREATE_INFO',
1128 'RS_STATE_CREATE_INFO',
1129 'DS_STATE_CREATE_INFO',
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1130 'VP_STATE_CREATE_INFO',
1131 'MS_STATE_CREATE_INFO'
1132 ]
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1133 hf_body.append('static void add_pipeline_state_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1134 hf_body.append('{')
1135 hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInNow = pIn;')
1136 hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)ppOut;')
1137 hf_body.append(' while (pInNow != NULL)')
1138 hf_body.append(' {')
1139 hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNow = ppOutNext;')
1140 hf_body.append(' ppOutNext = NULL;')
1141 hf_body.append('')
1142 hf_body.append(' switch (pInNow->sType)')
1143 hf_body.append(' {')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1144 for pipe_state in pipe_state_list:
1145 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_%s:' % pipe_state)
1146 hf_body.append(' {')
1147 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_%s), pInNow);' % pipe_state)
1148 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1149 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1150 hf_body.append(' break;')
1151 hf_body.append(' }')
Jon Ashburncce524a2015-02-03 17:47:58 -0700[diff] [blame]1152 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')
1153 hf_body.append(' {')
1154 hf_body.append(' XGL_PIPELINE_CB_STATE_CREATE_INFO *pPacket = NULL;')
1155 hf_body.append(' XGL_PIPELINE_CB_STATE_CREATE_INFO *pIn = NULL;')
1156 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO), pInNow);')
1157 hf_body.append(' pPacket = (XGL_PIPELINE_CB_STATE_CREATE_INFO*) *ppOutNow;')
1158 hf_body.append(' pIn = (XGL_PIPELINE_CB_STATE_CREATE_INFO*) pInNow;')
1159 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pAttachments, pIn->attachmentCount * sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE), pIn->pAttachments);')
1160 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAttachments));')
1161 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1162 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1163 hf_body.append(' break;')
1164 hf_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1165 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')
1166 hf_body.append(' {')
1167 hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacket = NULL;')
1168 hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInPacket = NULL;')
1169 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO), pInNow);')
1170 hf_body.append(' pPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) *ppOutNow;')
1171 hf_body.append(' pInPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) pInNow;')
1172 hf_body.append(' add_pipeline_shader_to_trace_packet(pHeader, &pPacket->shader, &pInPacket->shader);')
1173 hf_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->shader);')
1174 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1175 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1176 hf_body.append(' break;')
1177 hf_body.append(' }')
1178 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')
1179 hf_body.append(' {')
1180 hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pPacket = NULL;')
1181 hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pIn = NULL;')
1182 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO), pInNow);')
1183 hf_body.append(' pPacket = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) *ppOutNow;')
1184 hf_body.append(' pIn = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) pInNow;')
1185 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexBindingDescriptions, pIn->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION), pIn->pVertexBindingDescriptions);')
1186 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexBindingDescriptions));')
1187 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexAttributeDescriptions, pIn->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION), pIn->pVertexAttributeDescriptions);')
1188 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexAttributeDescriptions));')
1189 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1190 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1191 hf_body.append(' break;')
1192 hf_body.append(' }')
1193 hf_body.append(' default:')
1194 hf_body.append(' assert(!"Encountered an unexpected type in pipeline state list");')
1195 hf_body.append(' }')
1196 hf_body.append(' pInNow = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pInNow->pNext;')
1197 hf_body.append(' }')
1198 hf_body.append(' return;')
1199 hf_body.append('}')
1200 return "\n".join(hf_body)
1201
1202 def _generate_packet_id_enum(self):
1203 pid_enum = []
1204 pid_enum.append('enum GLV_TRACE_PACKET_ID_XGL')
1205 pid_enum.append('{')
1206 first_func = True
1207 for proto in self.protos:
1208 if first_func:
1209 first_func = False
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1210 pid_enum.append(' GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,')
1211 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1212 else:
1213 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
1214 pid_enum.append('};\n')
1215 return "\n".join(pid_enum)
1216
1217 def _generate_stringify_func(self):
1218 func_body = []
1219 func_body.append('static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)')
1220 func_body.append('{')
1221 func_body.append(' static char str[1024];')
1222 func_body.append(' switch(id) {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1223 func_body.append(' case GLV_TPI_XGL_xglApiVersion:')
1224 func_body.append(' {')
1225 func_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);')
1226 func_body.append(' snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);')
1227 func_body.append(' return str;')
1228 func_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1229 for proto in self.protos:
1230 func_body.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
1231 func_body.append(' {')
1232 func_str = 'xgl%s(' % proto.name
1233 print_vals = ''
1234 create_func = False
1235 if 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
1236 create_func = True
1237 for p in proto.params:
1238 last_param = False
1239 if (p.name == proto.params[-1].name):
1240 last_param = True
1241 if last_param and create_func: # last param of create func
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]1242 (pft, pfi, ptr) = self._get_printf_params(p.ty,'pPacket->%s' % p.name, True)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1243 else:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]1244 (pft, pfi, ptr) = self._get_printf_params(p.ty, 'pPacket->%s' % p.name, False)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1245 if last_param == True:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]1246 func_str += '%s%s = %s)' % (ptr, p.name, pft)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1247 print_vals += ', %s' % (pfi)
1248 else:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]1249 func_str += '%s%s = %s, ' % (ptr, p.name, pft)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1250 print_vals += ', %s' % (pfi)
1251 func_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(pHeader->pBody);' % (proto.name, proto.name))
1252 func_body.append(' snprintf(str, 1024, "%s"%s);' % (func_str, print_vals))
1253 func_body.append(' return str;')
1254 func_body.append(' }')
1255 func_body.append(' default:')
1256 func_body.append(' return NULL;')
1257 func_body.append(' }')
1258 func_body.append('};\n')
1259 return "\n".join(func_body)
1260
1261 def _generate_interp_func(self):
1262 interp_func_body = []
1263 interp_func_body.append('static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)')
1264 interp_func_body.append('{')
1265 interp_func_body.append(' if (pHeader == NULL)')
1266 interp_func_body.append(' {')
1267 interp_func_body.append(' return NULL;')
1268 interp_func_body.append(' }')
1269 interp_func_body.append(' switch (pHeader->packet_id)')
1270 interp_func_body.append(' {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1271 interp_func_body.append(' case GLV_TPI_XGL_xglApiVersion:\n {')
1272 interp_func_body.append(' return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;\n }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1273 for proto in self.protos:
1274 interp_func_body.append(' case GLV_TPI_XGL_xgl%s:\n {' % proto.name)
1275 header_prefix = 'h'
1276 if 'Wsi' in proto.name or 'Dbg' in proto.name:
1277 header_prefix = 'pH'
1278 interp_func_body.append(' return interpret_body_as_xgl%s(pHeader)->%seader;\n }' % (proto.name, header_prefix))
1279 interp_func_body.append(' default:')
1280 interp_func_body.append(' return NULL;')
1281 interp_func_body.append(' }')
1282 interp_func_body.append(' return NULL;')
1283 interp_func_body.append('}')
1284 return "\n".join(interp_func_body)
1285
1286 def _generate_struct_util_funcs(self):
1287 pid_enum = []
1288 pid_enum.append('//=============================================================================')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1289 pid_enum.append('static void add_XGL_APPLICATION_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_APPLICATION_INFO** ppStruct, const XGL_APPLICATION_INFO *pInStruct)')
1290 pid_enum.append('{')
1291 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_APPLICATION_INFO), pInStruct);')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]1292 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen(pInStruct->pAppName) + 1, pInStruct->pAppName);')
1293 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]1294 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')
1295 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')
1296 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
1297 pid_enum.append('};\n')
1298 pid_enum.append('//=============================================================================\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1299 pid_enum.append('static void add_XGL_DEVICE_CREATE_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_DEVICE_CREATE_INFO** ppStruct, const XGL_DEVICE_CREATE_INFO *pInStruct)')
1300 pid_enum.append('{')
1301 pid_enum.append(' uint32_t i;')
1302 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_DEVICE_CREATE_INFO), pInStruct);')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]1303 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(XGL_DEVICE_QUEUE_CREATE_INFO), pInStruct->pRequestedQueues);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1304 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')
1305 pid_enum.append(' if (pInStruct->extensionCount > 0) ')
1306 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1307 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char *), pInStruct->ppEnabledExtensionNames);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1308 pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')
1309 pid_enum.append(' {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]1310 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen(pInStruct->ppEnabledExtensionNames[i]) + 1, pInStruct->ppEnabledExtensionNames[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1311 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')
1312 pid_enum.append(' }')
1313 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
1314 pid_enum.append(' }')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1315 pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) pInStruct->pNext;')
1316 pid_enum.append(' while (pNext != NULL)')
1317 pid_enum.append(' {')
1318 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1319 pid_enum.append(' {')
1320 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->pNext)), sizeof(XGL_LAYER_CREATE_INFO), pNext);')
1321 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->pNext)));')
1322 pid_enum.append(' XGL_LAYER_CREATE_INFO **ppOutStruct = (XGL_LAYER_CREATE_INFO **) &((*ppStruct)->pNext);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1323 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]1324 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1325 pid_enum.append(' {')
1326 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])), strlen(pNext->ppActiveLayerNames[i]) + 1, pNext->ppActiveLayerNames[i]);')
1327 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])));')
1328 pid_enum.append(' }')
1329 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppOutStruct)->ppActiveLayerNames);')
1330 pid_enum.append(' }')
1331 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) pNext->pNext;')
1332 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1333 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')
1334 pid_enum.append('}\n')
1335 pid_enum.append('static XGL_DEVICE_CREATE_INFO* interpret_XGL_DEVICE_CREATE_INFO(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')
1336 pid_enum.append('{')
1337 pid_enum.append(' XGL_DEVICE_CREATE_INFO* pXGL_DEVICE_CREATE_INFO = (XGL_DEVICE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')
1338 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO != NULL)')
1339 pid_enum.append(' {')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1340 pid_enum.append(' uint32_t i;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1341 pid_enum.append(' const char** pNames;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1342 pid_enum.append(' pXGL_DEVICE_CREATE_INFO->pRequestedQueues = (const XGL_DEVICE_QUEUE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->pRequestedQueues);\n')
1343 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO->extensionCount > 0)')
1344 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1345 pid_enum.append(' pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames = (const char *const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames);')
1346 pid_enum.append(' pNames = (const char**)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1347 pid_enum.append(' for (i = 0; i < pXGL_DEVICE_CREATE_INFO->extensionCount; i++)')
1348 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1349 pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames[i]));')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1350 pid_enum.append(' }')
1351 pid_enum.append(' }')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1352 pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->pNext);')
1353 pid_enum.append(' while (pNext != NULL)')
1354 pid_enum.append(' {')
1355 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1356 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1357 pid_enum.append(' pNext->ppActiveLayerNames = (const char**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames));')
1358 pid_enum.append(' pNames = (const char**)pNext->ppActiveLayerNames;')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1359 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1360 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1361 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]1362 pid_enum.append(' }')
1363 pid_enum.append(' }')
1364 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);')
1365 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1366 pid_enum.append(' }\n')
1367 pid_enum.append(' return pXGL_DEVICE_CREATE_INFO;')
1368 pid_enum.append('}\n')
1369 pid_enum.append('static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* pShader)')
1370 pid_enum.append('{')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1371 pid_enum.append(' if (pShader != NULL)')
1372 pid_enum.append(' {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1373 pid_enum.append(' // constant buffers')
1374 pid_enum.append(' if (pShader->linkConstBufferCount > 0)')
1375 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1376 pid_enum.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1377 pid_enum.append(' pShader->pLinkConstBufferInfo = (const XGL_LINK_CONST_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);')
1378 pid_enum.append(' for (i = 0; i < pShader->linkConstBufferCount; i++)')
1379 pid_enum.append(' {')
1380 pid_enum.append(' XGL_LINK_CONST_BUFFER* pBuffer = (XGL_LINK_CONST_BUFFER*)pShader->pLinkConstBufferInfo;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1381 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]1382 pid_enum.append(' }')
1383 pid_enum.append(' }')
1384 pid_enum.append(' }')
1385 pid_enum.append('}\n')
1386 pid_enum.append('//=============================================================================')
1387 return "\n".join(pid_enum)
1388
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1389 # Interpret functions used on replay to read in packets and interpret their contents
Peter Lohrmann56782cd2015-03-27 12:57:10 -0700[diff] [blame]1390 # This code gets generated into glv_vk_vk_structs.h file
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1391 def _generate_interp_funcs(self):
1392 # 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]1393 # 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
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1394 custom_case_dict = { 'CreateInstance' : {'param': 'pAppInfo', 'txt': ['XGL_APPLICATION_INFO* pInfo = (XGL_APPLICATION_INFO*)pPacket->pAppInfo;\n',
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1395 'pInfo->pAppName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);\n',
1396 'pInfo->pEngineName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pEngineName);']},
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1397 'CreateShader' : {'param': 'pCreateInfo', 'txt': ['XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;\n',
1398 'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
Jon Ashburn8e7dcd02015-02-04 08:50:35 -0700[diff] [blame]1399 'CreateDynamicViewportState' : {'param': 'pCreateInfo', 'txt': ['XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInfo = (XGL_DYNAMIC_VP_STATE_CREATE_INFO*)pPacket->pCreateInfo;\n',
1400 'pInfo->pViewports = (XGL_VIEWPORT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pViewports);\n',
1401 'pInfo->pScissors = (XGL_RECT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pScissors);']},
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1402 'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['XGL_FRAMEBUFFER_CREATE_INFO* pInfo = (XGL_FRAMEBUFFER_CREATE_INFO*)pPacket->pCreateInfo;\n',
1403 'pInfo->pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',
1404 'pInfo->pDepthStencilAttachment = (XGL_DEPTH_STENCIL_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},
1405 'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': ['XGL_RENDER_PASS_CREATE_INFO* pInfo = (XGL_RENDER_PASS_CREATE_INFO*)pPacket->pCreateInfo;\n',
1406 'pInfo->pColorLoadOps = (XGL_ATTACHMENT_LOAD_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadOps);\n',
1407 'pInfo->pColorStoreOps = (XGL_ATTACHMENT_STORE_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorStoreOps);\n',
1408 'pInfo->pColorLoadClearValues = (XGL_CLEAR_COLOR*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadClearValues);\n']},
Jon Ashburnfb3769a2015-02-04 09:32:59 -0700[diff] [blame]1409 'CreateDescriptorRegion' : {'param': 'pCreateInfo', 'txt': ['XGL_DESCRIPTOR_REGION_CREATE_INFO* pInfo = (XGL_DESCRIPTOR_REGION_CREATE_INFO*)pPacket->pCreateInfo;\n',
1410 'pInfo->pTypeCount = (XGL_DESCRIPTOR_TYPE_COUNT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pTypeCount);\n']},
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1411 'CmdWaitEvents' : {'param': 'pWaitInfo', 'txt': ['XGL_EVENT_WAIT_INFO* pInfo = (XGL_EVENT_WAIT_INFO*)pPacket->pWaitInfo;\n',
1412 'pInfo->pEvents = (XGL_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->pEvents);\n',
1413 'pInfo->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->ppMemBarriers);\n',
1414 'uint32_t i;\n',
1415 'for (i = 0; i < pInfo->memBarrierCount; i++) {\n',
1416 ' void** ppLocalMemBarriers = (void**)&pInfo->ppMemBarriers[i];\n',
1417 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->ppMemBarriers[i]);\n',
1418 '}']},
1419 'CmdPipelineBarrier' : {'param': 'pBarrier', 'txt': ['XGL_PIPELINE_BARRIER* pBarrier = (XGL_PIPELINE_BARRIER*)pPacket->pBarrier;\n',
1420 'pBarrier->pEvents = (XGL_SET_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->pEvents);\n',
1421 'pBarrier->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->ppMemBarriers);\n',
1422 'uint32_t i;\n',
1423 'for (i = 0; i < pBarrier->memBarrierCount; i++) {\n',
1424 ' void** ppLocalMemBarriers = (void**)&pBarrier->ppMemBarriers[i];\n',
1425 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pBarrier->ppMemBarriers[i]);\n',
1426 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1427 'CreateDescriptorSetLayout' : {'param': 'pSetLayoutInfoList', 'txt': ['if (pPacket->pSetLayoutInfoList->sType == XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) {\n',
1428 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1429 ' void** ppNextVoidPtr = (void**)&(pPacket->pSetLayoutInfoList->pNext);\n',
1430 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSetLayoutInfoList->pNext);\n',
1431 ' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pPacket->pSetLayoutInfoList->pNext;\n',
1432 ' while (NULL != pNext)\n', ' {\n',
1433 ' switch(pNext->sType)\n', ' {\n',
1434 ' case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:\n',
1435 ' {\n' ,
1436 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1437 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1438 ' break;\n',
1439 ' }\n',
1440 ' default:\n',
1441 ' {\n',
1442 ' glv_LogError("Encountered an unexpected type in descriptor set layout create list.\\n");\n',
1443 ' pPacket->header = NULL;\n',
1444 ' pNext->pNext = NULL;\n',
1445 ' }\n',
Jon Ashburn7fd7eff2015-02-04 10:55:47 -0700[diff] [blame]1446 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1447 ' pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pNext->pNext;\n',
1448 ' }\n',
1449 '} else {\n',
1450 ' // This is unexpected.\n',
1451 ' glv_LogError("CreateDescriptorSetLayout must have LayoutInfoList stype of XGL_STRCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO\\n");\n',
1452 ' pPacket->header = NULL;\n',
Jon Ashburn7fd7eff2015-02-04 10:55:47 -0700[diff] [blame]1453 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1454 'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['if (pPacket->pBeginInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO) {\n',
1455 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1456 ' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO** ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO**)&(pPacket->pBeginInfo->pNext);\n',
1457 ' *ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',
1458 ' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pNext = *ppNext;\n',
1459 ' while (NULL != pNext)\n', ' {\n',
1460 ' switch(pNext->sType)\n', ' {\n',
1461 ' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:\n',
1462 ' {\n',
1463 ' ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO**) &pNext->pNext;\n',
1464 ' *ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1465 ' break;\n',
1466 ' }\n',
1467 ' default:\n',
1468 ' {\n',
1469 ' glv_LogError("Encountered an unexpected type in begin command buffer list.\\n");\n',
1470 ' pPacket->header = NULL;\n',
1471 ' pNext->pNext = NULL;\n',
1472 ' }\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1473 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1474 ' pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pNext->pNext;\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1475 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1476 '} else {\n',
1477 ' // This is unexpected.\n',
1478 ' glv_LogError("BeginCommandBuffer must have BeginInfo stype of XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO.\\n");\n',
1479 ' pPacket->header = NULL;\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1480 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1481 'AllocMemory' : {'param': 'pAllocInfo', 'txt': ['if (pPacket->pAllocInfo->sType == XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO) {\n',
1482 ' XGL_MEMORY_ALLOC_INFO** ppNext = (XGL_MEMORY_ALLOC_INFO**) &(pPacket->pAllocInfo->pNext);\n',
1483 ' *ppNext = (XGL_MEMORY_ALLOC_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocInfo->pNext);\n',
1484 ' XGL_MEMORY_ALLOC_INFO* pNext = (XGL_MEMORY_ALLOC_INFO*) *ppNext;\n',
1485 ' while (NULL != pNext)\n', ' {\n',
1486 ' switch(pNext->sType)\n', ' {\n',
1487 ' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:\n',
1488 ' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:\n',
1489 ' {\n',
1490 ' ppNext = (XGL_MEMORY_ALLOC_INFO **) &(pNext->pNext);\n',
1491 ' *ppNext = (XGL_MEMORY_ALLOC_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1492 ' break;\n',
1493 ' }\n',
1494 ' default:\n',
1495 ' {\n',
1496 ' glv_LogError("Encountered an unexpected type alloc memory list.\\n");\n',
1497 ' pPacket->header = NULL;\n',
1498 ' pNext->pNext = NULL;\n',
1499 ' }\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]1500 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1501 ' pNext = (XGL_MEMORY_ALLOC_INFO*)pNext->pNext;\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]1502 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1503 '} else {\n',
1504 ' // This is unexpected.\n',
1505 ' glv_LogError("AllocMemory must have AllocInfo stype of XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO.\\n");\n',
1506 ' pPacket->header = NULL;\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]1507 '}']},
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1508 'UpdateDescriptors' : {'param': 'pUpdateChain', 'txt': ['XGL_UPDATE_SAMPLERS* pNext = (XGL_UPDATE_SAMPLERS*)pPacket->pUpdateChain;\n',
1509 'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
1510 ' switch(pNext->sType)\n', ' {\n',
1511 ' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:\n',
1512 ' {\n',
1513 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1514 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1515 ' break;\n',
1516 ' }\n',
1517 ' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:\n',
1518 ' {\n',
1519 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1520 ' XGL_UPDATE_SAMPLERS* pUS = (XGL_UPDATE_SAMPLERS*)pNext;\n',
1521 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1522 ' pUS->pSamplers = (XGL_SAMPLER*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUS->pSamplers);\n',
1523 ' break;\n',
1524 ' }\n',
1525 ' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:\n',
1526 ' {\n',
1527 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1528 ' XGL_UPDATE_SAMPLER_TEXTURES* pUST = (XGL_UPDATE_SAMPLER_TEXTURES*)pNext;\n',
1529 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1530 ' pUST->pSamplerImageViews = (XGL_SAMPLER_IMAGE_VIEW_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews);\n',
1531 ' uint32_t i;\n',
1532 ' for (i = 0; i < pUST->count; i++) {\n',
1533 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUST->pSamplerImageViews[i].pImageView;\n',
1534 ' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews[i].pImageView);\n',
1535 ' }\n',
1536 ' break;\n',
1537 ' }\n',
1538 ' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:\n',
1539 ' {\n',
1540 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1541 ' XGL_UPDATE_IMAGES* pUI = (XGL_UPDATE_IMAGES*)pNext;\n',
1542 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1543 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUI->pImageViews;\n',
1544 ' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews);\n',
1545 ' uint32_t i;\n',
1546 ' for (i = 0; i < pUI->count; i++) {\n',
1547 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUI->pImageViews[i];\n',
1548 ' *ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews[i]);\n',
1549 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1550 ' break;\n',
1551 ' }\n',
1552 ' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:\n',
1553 ' {\n',
1554 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1555 ' XGL_UPDATE_BUFFERS* pUB = (XGL_UPDATE_BUFFERS*)pNext;\n',
1556 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1557 ' XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO**)&pUB->pBufferViews;\n',
1558 ' *ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews);\n',
1559 ' uint32_t i;\n',
1560 ' for (i = 0; i < pUB->count; i++) {\n',
1561 ' XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO**)&pUB->pBufferViews[i];\n',
1562 ' *ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews[i]);\n',
1563 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1564 ' break;\n',
1565 ' }\n',
1566 ' default:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1567 ' {\n',
1568 ' glv_LogError("Encountered an unexpected type in update descriptors pUpdateChain.\\n");\n',
1569 ' pPacket->header = NULL;\n',
1570 ' pNext->pNext = NULL;\n',
1571 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1572 ' }\n',
1573 ' pNext = (XGL_UPDATE_SAMPLERS*)pNext->pNext;\n',
1574 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1575 'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['if (pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) {\n',
1576 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1577 ' void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',
1578 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',
1579 ' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n',
1580 ' while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
1581 ' switch(pNext->sType)\n', ' {\n',
1582 ' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',
1583 ' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',
1584 ' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',
1585 ' case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',
1586 ' case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',
1587 ' case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',
1588 ' {\n',
1589 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1590 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1591 ' break;\n',
1592 ' }\n',
1593 ' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',
1594 ' {\n',
1595 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1596 ' XGL_PIPELINE_CB_STATE_CREATE_INFO *pCb = (XGL_PIPELINE_CB_STATE_CREATE_INFO *) pNext;\n',
1597 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1598 ' pCb->pAttachments = (XGL_PIPELINE_CB_ATTACHMENT_STATE*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pCb->pAttachments);\n',
1599 ' break;\n',
1600 ' }\n',
1601 ' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',
1602 ' {\n',
1603 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1604 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1605 ' interpret_pipeline_shader(pHeader, &pNext->shader);\n',
1606 ' break;\n',
1607 ' }\n',
1608 ' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',
1609 ' {\n',
1610 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1611 ' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',
1612 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1613 ' pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',
1614 ' pVi->pVertexAttributeDescriptions = (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',
1615 ' break;\n',
1616 ' }\n',
1617 ' default:\n',
1618 ' {\n',
1619 ' glv_LogError("Encountered an unexpected type in pipeline state list.\\n");\n',
1620 ' pPacket->header = NULL;\n',
1621 ' pNext->pNext = NULL;\n',
1622 ' }\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1623 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1624 ' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1625 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1626 '} else {\n',
1627 ' // This is unexpected.\n',
1628 ' glv_LogError("CreateGraphicsPipeline must have CreateInfo stype of XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.\\n");\n',
1629 ' pPacket->header = NULL;\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1630 '}']},
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1631 'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));']}}
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1632 if_body = []
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1633 if_body.append('typedef struct struct_xglApiVersion {')
1634 if_body.append(' glv_trace_packet_header* header;')
1635 if_body.append(' uint32_t version;')
1636 if_body.append('} struct_xglApiVersion;\n')
1637 if_body.append('static struct_xglApiVersion* interpret_body_as_xglApiVersion(glv_trace_packet_header* pHeader, BOOL check_version)')
1638 if_body.append('{')
1639 if_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)pHeader->pBody;')
1640 if_body.append(' pPacket->header = pHeader;')
1641 if_body.append(' if (check_version && pPacket->version != XGL_API_VERSION)')
1642 if_body.append(' glv_LogError("Trace file from older XGL version 0x%x, xgl replayer built from version 0x%x, replayer may fail\\n", pPacket->version, XGL_API_VERSION);')
1643 if_body.append(' return pPacket;')
1644 if_body.append('}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1645 for proto in self.protos:
1646 if 'Wsi' not in proto.name and 'Dbg' not in proto.name:
1647 if 'UnmapMemory' == proto.name:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1648 proto.params.append(xgl.Param("void*", "pData"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1649 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1650 if_body.append(' glv_trace_packet_header* header;')
1651 for p in proto.params:
1652 if '[4]' in p.ty:
1653 if_body.append(' %s %s[4];' % (p.ty.strip('[4]'), p.name))
1654 else:
1655 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1656 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1657 if_body.append(' %s result;' % proto.ret)
1658 if_body.append('} struct_xgl%s;\n' % proto.name)
1659 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1660 if_body.append('{')
1661 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1662 if_body.append(' pPacket->header = pHeader;')
1663 for p in proto.params:
1664 if '*' in p.ty:
1665 if 'DEVICE_CREATE_INFO' in p.ty:
1666 if_body.append(' pPacket->%s = interpret_XGL_DEVICE_CREATE_INFO(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))
1667 else:
1668 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]1669 # TODO : Generalize this custom code to kill dict data struct above.
1670 # 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]1671 if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
1672 if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])
1673 if_body.append(' {')
1674 if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))
1675 if_body.append(' }')
1676 if_body.append(' return pPacket;')
1677 if_body.append('}\n')
1678 return "\n".join(if_body)
1679
1680 def _generate_interp_funcs_ext(self, func_class='Wsi'):
1681 if_body = []
1682 for proto in self.protos:
1683 if func_class in proto.name:
1684 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1685 if_body.append(' glv_trace_packet_header* pHeader;')
1686 for p in proto.params:
1687 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1688 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1689 if_body.append(' %s result;' % proto.ret)
1690 if_body.append('} struct_xgl%s;\n' % proto.name)
1691 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1692 if_body.append('{')
1693 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1694 if_body.append(' pPacket->pHeader = pHeader;')
1695 for p in proto.params:
1696 if '*' in p.ty:
1697 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
1698 if_body.append(' return pPacket;')
1699 if_body.append('}\n')
1700 return "\n".join(if_body)
1701
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1702 def _generate_replay_func_ptrs(self):
1703 xf_body = []
1704 xf_body.append('struct xglFuncs {')
1705 xf_body.append(' void init_funcs(void * libHandle);')
1706 xf_body.append(' void *m_libHandle;\n')
1707 for proto in self.protos:
1708 xf_body.append(' typedef %s( XGLAPI * type_xgl%s)(' % (proto.ret, proto.name))
1709 for p in proto.params:
1710 if '[4]' in p.ty:
1711 xf_body.append(' %s %s[4],' % (p.ty.strip('[4]'), p.name))
1712 else:
1713 xf_body.append(' %s %s,' % (p.ty, p.name))
1714 xf_body[-1] = xf_body[-1].replace(',', ');')
1715 xf_body.append(' type_xgl%s real_xgl%s;' % (proto.name, proto.name))
1716 xf_body.append('};')
1717 return "\n".join(xf_body)
1718
1719 def _map_decl(self, type1, type2, name):
1720 return ' std::map<%s, %s> %s;' % (type1, type2, name)
1721
1722 def _add_to_map_decl(self, type1, type2, name):
1723 txt = ' void add_to_map(%s* pTraceVal, %s* pReplayVal)\n {\n' % (type1, type2)
1724 txt += ' assert(pTraceVal != NULL);\n'
1725 txt += ' assert(pReplayVal != NULL);\n'
1726 txt += ' %s[*pTraceVal] = *pReplayVal;\n }' % name
1727 return txt
1728
1729 def _rm_from_map_decl(self, ty, name):
1730 txt = ' void rm_from_map(const %s& key)\n {\n' % (ty)
1731 txt += ' %s.erase(key);\n }' % name
1732 return txt
1733
1734 def _remap_decl(self, ty, name):
1735 txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)
1736 txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)
1737 txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }' % name
1738 return txt
1739
1740 def _generate_replay_class(self):
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1741 # Create dict mapping member var names to XGL type (i.e. 'm_imageViews' : 'XGL_IMAGE_VIEW')
1742 obj_map_dict = {}
1743 for ty in xgl.object_type_list:
1744 if ty in xgl.object_parent_list:
1745 continue
1746 mem_var = ty.replace('XGL_', '').lower()
1747 mem_var_list = mem_var.split('_')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1748 mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))
1749 obj_map_dict[mem_var] = ty
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1750 rc_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1751 rc_body.append('typedef struct _XGLAllocInfo {')
1752 rc_body.append(' XGL_GPU_SIZE size;')
1753 rc_body.append(' void *pData;')
1754 rc_body.append('} XGLAllocInfo;\n')
1755 rc_body.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')
Peter Lohrmannaf44b452015-03-30 18:29:22 -0700[diff] [blame]1756 rc_body.append('class xglReplay {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1757 rc_body.append('public:')
1758 rc_body.append(' ~xglReplay();')
Ian Elliott91e681e2015-02-18 15:35:00 -0700[diff] [blame]1759 rc_body.append(' xglReplay(glvreplay_settings *pReplaySettings);\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1760 rc_body.append(' int init(glv_replay::Display & disp);')
1761 rc_body.append(' xglDisplay * get_display() {return m_display;}')
1762 rc_body.append(' glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);')
1763 rc_body.append(' glv_replay::GLV_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn);\n')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1764 rc_body.append(' void push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg);')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1765 rc_body.append(' glv_replay::GLV_REPLAY_RESULT pop_validation_msgs();')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]1766 rc_body.append(' int dump_validation_data();')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1767 rc_body.append('private:')
1768 rc_body.append(' struct xglFuncs m_xglFuncs;')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]1769 rc_body.append(' DRAW_STATE_DUMP_DOT_FILE m_pDSDump;')
Jeremy Hayes7ec63022015-02-26 15:59:19 -0700[diff] [blame]1770 rc_body.append(' DRAW_STATE_DUMP_COMMAND_BUFFER_DOT_FILE m_pCBDump;')
Peter Lohrmanncaf39d52015-03-24 17:19:24 -0700[diff] [blame]1771 rc_body.append(' GLVSNAPSHOT_PRINT_OBJECTS m_pGlvSnapshotPrint;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1772 rc_body.append(' xglDisplay *m_display;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1773 rc_body.append(' struct shaderPair {')
1774 rc_body.append(' XGL_SHADER *addr;')
1775 rc_body.append(' XGL_SHADER val;')
1776 rc_body.append(' };')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1777 rc_body.append(' struct validationMsg {')
1778 rc_body.append(' XGL_VALIDATION_LEVEL validationLevel;')
1779 rc_body.append(' XGL_BASE_OBJECT srcObject;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1780 rc_body.append(' size_t location;')
1781 rc_body.append(' int32_t msgCode;')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1782 rc_body.append(' char msg[256];')
1783 rc_body.append(' };')
1784 rc_body.append(' std::vector<struct validationMsg> m_validationMsgs;')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]1785 rc_body.append(' std::vector<int> m_screenshotFrames;')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1786 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateDevice(struct_xglCreateDevice* pPacket);')
1787 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglEnumerateGpus(struct_xglEnumerateGpus* pPacket);')
1788 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetGpuInfo(struct_xglGetGpuInfo* pPacket);')
1789 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetExtensionSupport(struct_xglGetExtensionSupport* pPacket);')
1790 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglQueueSubmit(struct_xglQueueSubmit* pPacket);')
1791 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetObjectInfo(struct_xglGetObjectInfo* pPacket);')
1792 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetFormatInfo(struct_xglGetFormatInfo* pPacket);')
1793 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetImageSubresourceInfo(struct_xglGetImageSubresourceInfo* pPacket);')
1794 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglUpdateDescriptors(struct_xglUpdateDescriptors* pPacket);')
1795 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateDescriptorSetLayout(struct_xglCreateDescriptorSetLayout* pPacket);')
1796 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateGraphicsPipeline(struct_xglCreateGraphicsPipeline* pPacket);')
1797 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCmdWaitEvents(struct_xglCmdWaitEvents* pPacket);')
1798 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCmdPipelineBarrier(struct_xglCmdPipelineBarrier* pPacket);')
1799 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateFramebuffer(struct_xglCreateFramebuffer* pPacket);')
1800 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglCreateRenderPass(struct_xglCreateRenderPass* pPacket);')
1801 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglBeginCommandBuffer(struct_xglBeginCommandBuffer* pPacket);')
1802 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglStorePipeline(struct_xglStorePipeline* pPacket);')
1803 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglGetMultiGpuCompatibility(struct_xglGetMultiGpuCompatibility* pPacket);')
1804 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglDestroyObject(struct_xglDestroyObject* pPacket);')
1805 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglWaitForFences(struct_xglWaitForFences* pPacket);')
1806 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglFreeMemory(struct_xglFreeMemory* pPacket);')
1807 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglMapMemory(struct_xglMapMemory* pPacket);')
1808 rc_body.append(' glv_replay::GLV_REPLAY_RESULT manually_handle_xglUnmapMemory(struct_xglUnmapMemory* pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1809 rc_body.append(self._map_decl('XGL_GPU_MEMORY', 'XGLAllocInfo', 'm_mapData'))
1810 # Custom code for 1-off memory mapping functions
1811 rc_body.append(' void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)')
1812 rc_body.append(' {')
1813 rc_body.append(' XGLAllocInfo info;')
1814 rc_body.append(' info.pData = NULL;')
1815 rc_body.append(' info.size = size;')
1816 rc_body.append(' m_mapData.insert(std::pair<XGL_GPU_MEMORY, XGLAllocInfo>(handle, info));')
1817 rc_body.append(' }')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1818 rc_body.append(' void add_mapping_to_mapData(XGL_GPU_MEMORY handle, void *pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1819 rc_body.append(' {')
1820 rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
1821 rc_body.append(' if (it == m_mapData.end())')
1822 rc_body.append(' {')
1823 rc_body.append(' glv_LogWarn("add_mapping_to_mapData() could not find entry\\n");')
1824 rc_body.append(' return;')
1825 rc_body.append(' }')
1826 rc_body.append(' XGLAllocInfo &info = it->second;')
1827 rc_body.append(' if (info.pData != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1828 rc_body.append(' glv_LogWarn("add_mapping_to_mapData() data already mapped overwrite old mapping\\n");')
Jon Ashburnceb5ee52015-02-20 13:10:52 -0700[diff] [blame]1829 rc_body.append(' else if (pData == NULL)')
1830 rc_body.append(' glv_LogWarn("add_mapping_to_mapData() adding NULL pointer\\n");')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1831 rc_body.append(' info.pData = pData;')
1832 rc_body.append(' }')
1833 rc_body.append(' void rm_entry_from_mapData(XGL_GPU_MEMORY handle)')
1834 rc_body.append(' {')
1835 rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
1836 rc_body.append(' if (it == m_mapData.end())')
1837 rc_body.append(' return;')
1838 rc_body.append(' m_mapData.erase(it);')
1839 rc_body.append(' }')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]1840 rc_body.append(' void rm_mapping_from_mapData(XGL_GPU_MEMORY handle, void* pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1841 rc_body.append(' {')
1842 rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
1843 rc_body.append(' if (it == m_mapData.end())')
1844 rc_body.append(' return;\n')
1845 rc_body.append(' XGLAllocInfo &info = it->second;')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]1846 rc_body.append(' if (!pData || !info.pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1847 rc_body.append(' {')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]1848 rc_body.append(' if (!pData)')
1849 rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null src pointer\\n");')
1850 rc_body.append(' else')
1851 rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null dest pointer size=%u\\n", info.size);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1852 rc_body.append(' info.pData = NULL;')
1853 rc_body.append(' return;')
1854 rc_body.append(' }')
Jon Ashburnb99b4d72015-03-02 17:12:31 -0700[diff] [blame]1855 rc_body.append(' memcpy(info.pData, pData, info.size);')
1856 rc_body.append(' info.pData = NULL;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1857 rc_body.append(' }\n')
1858 rc_body.append(' /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;')
1859 rc_body.append(' void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)')
1860 rc_body.append(' {')
1861 rc_body.append(' assert(pTraceGpu != NULL);')
1862 rc_body.append(' assert(pReplayGpu != NULL);')
1863 rc_body.append(' m_gpus[*pTraceGpu] = *pReplayGpu;')
1864 rc_body.append(' }\n')
1865 rc_body.append(' XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)')
1866 rc_body.append(' {')
1867 rc_body.append(' std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);')
1868 rc_body.append(' return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;')
1869 rc_body.append(' }*/\n')
1870 rc_body.append(' void clear_all_map_handles()\n {')
1871 for var in sorted(obj_map_dict):
1872 rc_body.append(' %s.clear();' % var)
1873 rc_body.append(' }')
1874 for var in sorted(obj_map_dict):
1875 rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))
1876 rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))
1877 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1878 rc_body.append(self._remap_decl(obj_map_dict[var], var))
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1879 # XGL_DYNAMIC_STATE_OBJECT code
1880 state_obj_remap_types = xgl.object_dynamic_state_list
1881 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
1882 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT obj;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1883 for t in state_obj_remap_types:
1884 rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != XGL_NULL_HANDLE)' % t)
1885 rc_body.append(' return obj;')
1886 rc_body.append(' return XGL_NULL_HANDLE;\n }')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1887 rc_body.append(' void rm_from_map(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1888 for t in state_obj_remap_types:
1889 rc_body.append(' rm_from_map(static_cast <%s> (state));' % t)
1890 rc_body.append(' }')
1891 # OBJECT code
1892 rc_body.append(' XGL_OBJECT remap(const XGL_OBJECT& object)\n {')
1893 rc_body.append(' XGL_OBJECT obj;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1894 obj_remap_types = xgl.object_list
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1895 for var in obj_remap_types:
1896 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % (var))
1897 rc_body.append(' return obj;')
1898 rc_body.append(' return XGL_NULL_HANDLE;\n }')
1899 rc_body.append(' void rm_from_map(const XGL_OBJECT & objKey)\n {')
1900 for var in obj_remap_types:
1901 rc_body.append(' rm_from_map(static_cast <%s> (objKey));' % (var))
1902 rc_body.append(' }')
1903 rc_body.append(' XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)\n {')
1904 rc_body.append(' XGL_BASE_OBJECT obj;')
1905 base_obj_remap_types = ['XGL_DEVICE', 'XGL_QUEUE', 'XGL_GPU_MEMORY', 'XGL_OBJECT']
1906 for t in base_obj_remap_types:
1907 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % t)
1908 rc_body.append(' return obj;')
Peter Lohrmannaf44b452015-03-30 18:29:22 -0700[diff] [blame]1909 rc_body.append(' return XGL_NULL_HANDLE;\n }\n')
1910 rc_body.append(' void process_screenshot_list(const char *list)')
1911 rc_body.append(' {')
1912 rc_body.append(' std::string spec(list), word;')
1913 rc_body.append(' size_t start = 0, comma = 0;\n')
1914 rc_body.append(' while (start < spec.size()) {')
1915 rc_body.append(' comma = spec.find(\',\', start);\n')
1916 rc_body.append(' if (comma == std::string::npos)')
1917 rc_body.append(' word = std::string(spec, start);')
1918 rc_body.append(' else')
1919 rc_body.append(' word = std::string(spec, start, comma - start);\n')
1920 rc_body.append(' m_screenshotFrames.push_back(atoi(word.c_str()));')
1921 rc_body.append(' if (comma == std::string::npos)')
1922 rc_body.append(' break;\n')
1923 rc_body.append(' start = comma + 1;\n')
1924 rc_body.append(' }')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]1925 rc_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1926 rc_body.append('};')
1927 return "\n".join(rc_body)
1928
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1929
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1930 def _generate_replay_init_funcs(self):
1931 rif_body = []
1932 rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')
1933 for proto in self.protos:
1934 rif_body.append(' real_xgl%s = (type_xgl%s)(glv_platform_get_library_entrypoint(handle, "xgl%s"));' % (proto.name, proto.name, proto.name))
1935 rif_body.append('}')
1936 return "\n".join(rif_body)
1937
1938 def _get_packet_param(self, t, n):
1939 # list of types that require remapping
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1940 remap_list = xgl.object_type_list
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1941 param_exclude_list = ['p1', 'p2', 'pGpus', 'pDescriptorSets']
1942 if t.strip('*').replace('const ', '') in remap_list and n not in param_exclude_list:
1943 if '*' in t:
1944 if 'const ' not in t:
1945 return 'remap(*pPacket->%s)' % (n)
1946 else: # TODO : Don't remap array ptrs?
1947 return 'pPacket->%s' % (n)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1948 return 'remap(pPacket->%s)' % (n)
1949 return 'pPacket->%s' % (n)
1950
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1951 def _gen_replay_enum_gpus(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1952 ieg_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1953 ieg_body.append(' returnValue = manually_handle_xglEnumerateGpus(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1954 return "\n".join(ieg_body)
1955
1956 def _gen_replay_get_gpu_info(self):
1957 ggi_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1958 ggi_body.append(' returnValue = manually_handle_xglGetGpuInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1959 return "\n".join(ggi_body)
1960
1961 def _gen_replay_create_device(self):
1962 cd_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1963 cd_body.append(' returnValue = manually_handle_xglCreateDevice(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1964 return "\n".join(cd_body)
1965
1966 def _gen_replay_get_extension_support(self):
1967 ges_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1968 ges_body.append(' returnValue = manually_handle_xglGetExtensionSupport(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1969 return "\n".join(ges_body)
1970
1971 def _gen_replay_queue_submit(self):
1972 qs_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1973 qs_body.append(' returnValue = manually_handle_xglQueueSubmit(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1974 return "\n".join(qs_body)
1975
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1976 def _gen_replay_get_object_info(self):
1977 goi_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1978 goi_body.append(' returnValue = manually_handle_xglGetObjectInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1979 return "\n".join(goi_body)
1980
1981 def _gen_replay_get_format_info(self):
1982 gfi_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1983 gfi_body.append(' returnValue = manually_handle_xglGetFormatInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1984 return "\n".join(gfi_body)
1985
1986 def _gen_replay_get_image_subresource_info(self):
1987 isi_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1988 isi_body.append(' returnValue = manually_handle_xglGetImageSubresourceInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1989 return "\n".join(isi_body)
1990
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]1991 def _gen_replay_update_descriptors(self):
1992 ud_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1993 ud_body.append(' returnValue = manually_handle_xglUpdateDescriptors(pPacket);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1994 return "\n".join(ud_body)
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]1995
1996 def _gen_replay_create_descriptor_set_layout(self):
1997 cdsl_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]1998 cdsl_body.append(' returnValue = manually_handle_xglCreateDescriptorSetLayout(pPacket);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1999 return "\n".join(cdsl_body)
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2000
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2001 def _gen_replay_create_graphics_pipeline(self):
2002 cgp_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2003 cgp_body.append(' returnValue = manually_handle_xglCreateGraphicsPipeline(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2004 return "\n".join(cgp_body)
2005
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]2006 def _gen_replay_cmd_wait_events(self):
2007 cwe_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2008 cwe_body.append(' returnValue = manually_handle_xglCmdWaitEvents(pPacket);')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]2009 return "\n".join(cwe_body)
2010
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]2011 def _gen_replay_cmd_pipeline_barrier(self):
2012 cpb_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2013 cpb_body.append(' returnValue = manually_handle_xglCmdPipelineBarrier(pPacket);')
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]2014 return "\n".join(cpb_body)
2015
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]2016 def _gen_replay_create_framebuffer(self):
2017 cf_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2018 cf_body.append(' returnValue = manually_handle_xglCreateFramebuffer(pPacket);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]2019 return "\n".join(cf_body)
2020
2021 def _gen_replay_create_renderpass(self):
2022 cr_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2023 cr_body.append(' returnValue = manually_handle_xglCreateRenderPass(pPacket);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]2024 return "\n".join(cr_body)
2025
2026 def _gen_replay_begin_command_buffer(self):
2027 bcb_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2028 bcb_body.append(' returnValue = manually_handle_xglBeginCommandBuffer(pPacket);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]2029 return "\n".join(bcb_body)
2030
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2031 def _gen_replay_store_pipeline(self):
2032 sp_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2033 sp_body.append(' returnValue = manually_handle_xglStorePipeline(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2034 return "\n".join(sp_body)
2035
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2036 def _gen_replay_get_multi_gpu_compatibility(self):
2037 gmgc_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2038 gmgc_body.append(' returnValue = manually_handle_xglGetMultiGpuCompatibility(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2039 return "\n".join(gmgc_body)
2040
2041 def _gen_replay_destroy_object(self):
2042 do_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2043 do_body.append(' returnValue = manually_handle_xglDestroyObject(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2044 return "\n".join(do_body)
2045
2046 def _gen_replay_wait_for_fences(self):
2047 wf_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2048 wf_body.append(' returnValue = manually_handle_xglWaitForFences(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2049 return "\n".join(wf_body)
2050
2051 def _gen_replay_wsi_associate_connection(self):
2052 wac_body = []
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2053 wac_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2054 wac_body.append(' //associate with the replayers Wsi connection rather than tracers')
2055 wac_body.append(' replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2056 wac_body.append('#elif defined(WIN32)')
2057 wac_body.append(' //TBD')
2058 wac_body.append(' replayResult = XGL_SUCCESS;')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2059 wac_body.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2060 return "\n".join(wac_body)
2061
2062 def _gen_replay_wsi_get_msc(self):
2063 wgm_body = []
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2064 wgm_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
2065 wgm_body.append(' xcb_window_t window = m_display->m_XcbWindow;')
2066 wgm_body.append(' replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')
2067 wgm_body.append('#elif defined(WIN32)')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2068 wgm_body.append(' //TBD')
2069 wgm_body.append(' replayResult = XGL_SUCCESS;')
2070 wgm_body.append('#else')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2071
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2072 wgm_body.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2073 return "\n".join(wgm_body)
2074
2075 def _gen_replay_wsi_create_presentable_image(self):
2076 cpi_body = []
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2077 cpi_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2078 cpi_body.append(' XGL_IMAGE img;')
2079 cpi_body.append(' XGL_GPU_MEMORY mem;')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]2080 cpi_body.append(' m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height);')
2081 cpi_body.append(' m_display->imageWidth.push_back(pPacket->pCreateInfo->extent.width);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2082 cpi_body.append(' replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);')
2083 cpi_body.append(' if (replayResult == XGL_SUCCESS)')
2084 cpi_body.append(' {')
2085 cpi_body.append(' if (pPacket->pImage != NULL)')
2086 cpi_body.append(' add_to_map(pPacket->pImage, &img);')
2087 cpi_body.append(' if(pPacket->pMem != NULL)')
2088 cpi_body.append(' add_to_map(pPacket->pMem, &mem);')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]2089 cpi_body.append(' m_display->imageHandles.push_back(img);')
2090 cpi_body.append(' m_display->imageMemory.push_back(mem);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2091 cpi_body.append(' }')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2092 cpi_body.append('#elif defined(WIN32)')
2093 cpi_body.append(' //TBD')
2094 cpi_body.append(' replayResult = XGL_SUCCESS;')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2095 cpi_body.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2096 return "\n".join(cpi_body)
2097
2098 def _gen_replay_wsi_queue_present(self):
2099 wqp_body = []
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2100 wqp_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2101 wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]2102 wqp_body.append(' std::vector<int>::iterator it;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2103 wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')
2104 wqp_body.append(' pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);')
2105 wqp_body.append(' // use replayers Xcb window')
2106 wqp_body.append(' pInfo.destWindow = m_display->m_XcbWindow;')
2107 wqp_body.append(' replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]2108 wqp_body.append(' it = std::find(m_screenshotFrames.begin(), m_screenshotFrames.end(), m_display->m_frameNumber);')
2109 wqp_body.append(' if (it != m_screenshotFrames.end())')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]2110 wqp_body.append(' {')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]2111 wqp_body.append(' for(unsigned int i=0; i<m_display->imageHandles.size(); i++)')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]2112 wqp_body.append(' {')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]2113 wqp_body.append(' if (m_display->imageHandles[i] == pInfo.srcImage)')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]2114 wqp_body.append(' {')
2115 wqp_body.append(' char frameName[32];')
2116 wqp_body.append(' sprintf(frameName, "%d",m_display->m_frameNumber);')
Tony Barbour66a4cc22015-02-05 09:46:17 -0700[diff] [blame]2117 wqp_body.append(' glvWritePPM(frameName, m_display->imageWidth[i], m_display->imageHeight[i],')
2118 wqp_body.append(' m_display->imageHandles[i], m_display->imageMemory[i], &m_xglFuncs);')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]2119 wqp_body.append(' break;')
2120 wqp_body.append(' }')
2121 wqp_body.append(' }')
2122 wqp_body.append(' }')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2123 wqp_body.append('#elif defined(WIN32)')
2124 wqp_body.append(' //TBD')
2125 wqp_body.append(' replayResult = XGL_SUCCESS;')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2126 wqp_body.append('#endif')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]2127 wqp_body.append(' m_display->m_frameNumber++;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2128 return "\n".join(wqp_body)
2129
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2130 def _gen_replay_free_memory(self):
2131 fm_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2132 fm_body.append(' returnValue = manually_handle_xglFreeMemory(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2133 return "\n".join(fm_body)
2134
2135 def _gen_replay_map_memory(self):
2136 mm_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2137 mm_body.append(' returnValue = manually_handle_xglMapMemory(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2138 return "\n".join(mm_body)
2139
2140 def _gen_replay_unmap_memory(self):
2141 um_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2142 um_body.append(' returnValue = manually_handle_xglUnmapMemory(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2143 return "\n".join(um_body)
2144
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2145 # I don't think this function is being generated anymore (ie, it may have been removed from XGL)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2146 def _gen_replay_bind_dynamic_memory_view(self):
2147 bdmv_body = []
2148 bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')
2149 bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));')
2150 bdmv_body.append(' memView.mem = remap(pPacket->pMemView->mem);')
2151 bdmv_body.append(' m_xglFuncs.real_xglCmdBindDynamicMemoryView(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')
2152 return "\n".join(bdmv_body)
2153
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]2154 # 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]2155 def _generate_replay(self):
2156 # map protos to custom functions if body is fully custom
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]2157 custom_body_dict = {'EnumerateGpus': self._gen_replay_enum_gpus,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2158 'GetGpuInfo': self._gen_replay_get_gpu_info,
2159 'CreateDevice': self._gen_replay_create_device,
2160 'GetExtensionSupport': self._gen_replay_get_extension_support,
2161 'QueueSubmit': self._gen_replay_queue_submit,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2162 'GetObjectInfo': self._gen_replay_get_object_info,
2163 'GetFormatInfo': self._gen_replay_get_format_info,
2164 'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,
2165 'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]2166 'CreateFramebuffer': self._gen_replay_create_framebuffer,
2167 'CreateRenderPass': self._gen_replay_create_renderpass,
2168 'BeginCommandBuffer': self._gen_replay_begin_command_buffer,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2169 'StorePipeline': self._gen_replay_store_pipeline,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2170 'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,
2171 'DestroyObject': self._gen_replay_destroy_object,
2172 'WaitForFences': self._gen_replay_wait_for_fences,
2173 'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,
2174 'WsiX11GetMSC': self._gen_replay_wsi_get_msc,
2175 'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,
2176 'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,
2177 'FreeMemory': self._gen_replay_free_memory,
2178 'MapMemory': self._gen_replay_map_memory,
2179 'UnmapMemory': self._gen_replay_unmap_memory,
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]2180 'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view,
2181 'UpdateDescriptors': self._gen_replay_update_descriptors,
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]2182 'CreateDescriptorSetLayout': self._gen_replay_create_descriptor_set_layout,
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]2183 'CmdWaitEvents': self._gen_replay_cmd_wait_events,
2184 'CmdPipelineBarrier': self._gen_replay_cmd_pipeline_barrier}
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2185 # TODO : Need to guard CreateInstance with "if (!m_display->m_initedXGL)" check
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2186 # 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^]2187 custom_check_ret_val = ['EnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport', 'QueueSubmit', 'GetObjectInfo',
2188 'GetFormatInfo', 'GetImageSubresourceInfo', 'CreateDescriptorSetLayout', 'CreateGraphicsPipeline',
2189 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'StorePipeline', 'GetMultiGpuCompatibility',
2190 'DestroyObject', 'WaitForFences', 'FreeMemory', 'MapMemory', 'UnmapMemory']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2191 # multi-gpu Open funcs w/ list of local params to create
2192 custom_open_params = {'OpenSharedMemory': (-1,),
2193 'OpenSharedQueueSemaphore': (-1,),
2194 'OpenPeerMemory': (-1,),
2195 'OpenPeerImage': (-1, -2,)}
2196 # Functions that create views are unique from other create functions
Jon Ashburnb1b63ed2015-02-03 11:24:08 -0700[diff] [blame]2197 create_view_list = ['CreateBufferView', 'CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2198 # Functions to treat as "Create' that don't have 'Create' in the name
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2199 special_create_list = ['LoadPipeline', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2200 # A couple funcs use do while loops
2201 do_while_dict = {'GetFenceStatus': 'replayResult != pPacket->result && pPacket->result == XGL_SUCCESS', 'GetEventStatus': '(pPacket->result == XGL_EVENT_SET || pPacket->result == XGL_EVENT_RESET) && replayResult != pPacket->result'}
2202 rbody = []
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2203 rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')
2204 rbody.append('{')
2205 rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')
2206 rbody.append(' XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;')
2207 rbody.append(' switch (packet->packet_id)')
2208 rbody.append(' {')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]2209 rbody.append(' case GLV_TPI_XGL_xglApiVersion:')
2210 rbody.append(' break; // nothing to replay on the version packet')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2211 for proto in self.protos:
2212 ret_value = False
2213 create_view = False
2214 create_func = False
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2215 # TODO : How to handle void* return of GetProcAddr?
2216 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]2217 ret_value = True
2218 if proto.name in create_view_list:
2219 create_view = True
2220 elif 'Create' in proto.name or proto.name in special_create_list:
2221 create_func = True
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2222 rbody.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
2223 rbody.append(' {')
2224 rbody.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(packet->pBody);' % (proto.name, proto.name))
2225 if proto.name in custom_body_dict:
2226 rbody.append(custom_body_dict[proto.name]())
2227 else:
2228 if proto.name in custom_open_params:
2229 rbody.append(' XGL_DEVICE handle;')
2230 for pidx in custom_open_params[proto.name]:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2231 rbody.append(' %s local_%s;' % (proto.params[pidx].ty.replace('const ', '').strip('*'), proto.params[pidx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2232 rbody.append(' handle = remap(pPacket->device);')
2233 elif create_view:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2234 rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').replace('const ', '')))
2235 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]2236 if 'CreateComputePipeline' == proto.name:
2237 rbody.append(' createInfo.cs.shader = remap(pPacket->pCreateInfo->cs.shader);')
Jon Ashburnb1b63ed2015-02-03 11:24:08 -0700[diff] [blame]2238 elif 'CreateBufferView' == proto.name:
2239 rbody.append(' createInfo.buffer = remap(pPacket->pCreateInfo->buffer);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2240 else:
2241 rbody.append(' createInfo.image = remap(pPacket->pCreateInfo->image);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2242 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]2243 elif create_func: # Declare local var to store created handle into
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2244 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]2245 if 'AllocDescriptorSets' == proto.name:
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]2246 rbody.append(' %s local_%s[100];' % (proto.params[-2].ty.strip('*').replace('const ', ''), proto.params[-2].name))
2247 rbody.append(' XGL_DESCRIPTOR_SET_LAYOUT localDescSets[100];')
2248 rbody.append(' assert(pPacket->count <= 100);')
2249 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
2250 rbody.append(' {')
2251 rbody.append(' localDescSets[i] = remap(pPacket->%s[i]);' % (proto.params[-3].name))
2252 rbody.append(' }')
2253 elif proto.name == 'ClearDescriptorSets':
2254 rbody.append(' XGL_DESCRIPTOR_SET localDescSets[100];')
2255 rbody.append(' assert(pPacket->count <= 100);')
2256 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2257 rbody.append(' {')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]2258 rbody.append(' localDescSets[i] = remap(pPacket->%s[i]);' % (proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2259 rbody.append(' }')
2260 elif proto.name in do_while_dict:
2261 rbody.append(' do {')
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]2262 elif proto.name == 'EnumerateLayers':
2263 rbody.append(' char **bufptr = GLV_NEW_ARRAY(char *, pPacket->maxLayerCount);')
2264 rbody.append(' char **ptrLayers = (pPacket->pOutLayers == NULL) ? bufptr : (char **) pPacket->pOutLayers;')
2265 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
2266 rbody.append(' bufptr[i] = GLV_NEW_ARRAY(char, pPacket->maxStringSize);')
Jon Ashburnd698ca22015-02-12 12:37:46 -0700[diff] [blame]2267 elif proto.name == 'DestroyInstance':
2268 rbody.append(' xglDbgUnregisterMsgCallback(g_fpDbgMsgCallback);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2269 rr_string = ' '
2270 if ret_value:
2271 rr_string = ' replayResult = '
2272 rr_string += 'm_xglFuncs.real_xgl%s(' % proto.name
2273 for p in proto.params:
2274 # For last param of Create funcs, pass address of param
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2275 if create_func:
2276 if p.name == proto.params[-1].name:
2277 rr_string += '&local_%s, ' % p.name
2278 elif proto.name == 'AllocDescriptorSets' and p.name == proto.params[-2].name:
2279 rr_string += 'local_%s, ' % p.name
2280 else:
2281 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2282 else:
2283 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
2284 rr_string = '%s);' % rr_string[:-2]
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]2285 if proto.name in custom_open_params:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2286 rr_list = rr_string.split(', ')
2287 rr_list[0] = rr_list[0].replace('remap(pPacket->device)', 'handle')
2288 for pidx in custom_open_params[proto.name]:
2289 rr_list[pidx] = '&local_%s' % proto.params[pidx].name
2290 rr_string = ', '.join(rr_list)
2291 rr_string += ');'
2292 elif create_view:
2293 rr_list = rr_string.split(', ')
2294 rr_list[-2] = '&createInfo'
2295 rr_list[-1] = '&local_%s);' % proto.params[-1].name
2296 rr_string = ', '.join(rr_list)
2297 # this is a sneaky shortcut to use generic create code below to add_to_map
2298 create_func = True
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]2299 elif proto.name == 'EnumerateLayers':
2300 rr_string = rr_string.replace('pPacket->pOutLayers', 'ptrLayers')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]2301 elif proto.name == 'ClearDescriptorSets':
2302 rr_string = rr_string.replace('pPacket->pDescriptorSets', 'localDescSets')
2303 elif proto.name == 'AllocDescriptorSets':
2304 rr_string = rr_string.replace('pPacket->pSetLayouts', 'localDescSets')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2305 rbody.append(rr_string)
2306 if 'DestroyDevice' in proto.name:
2307 rbody.append(' if (replayResult == XGL_SUCCESS)')
2308 rbody.append(' {')
Peter Lohrmann53e89242015-02-27 15:35:15 -0800[diff] [blame]2309 rbody.append(' m_pCBDump = NULL;')
2310 rbody.append(' m_pDSDump = NULL;')
Peter Lohrmanncaf39d52015-03-24 17:19:24 -0700[diff] [blame]2311 rbody.append(' m_pGlvSnapshotPrint = NULL;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2312 rbody.append(' rm_from_map(pPacket->device);')
2313 rbody.append(' m_display->m_initedXGL = false;')
2314 rbody.append(' }')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]2315 if 'DestroyInstance' in proto.name:
2316 rbody.append(' if (replayResult == XGL_SUCCESS)')
2317 rbody.append(' {')
Jon Ashburn6f58a162015-02-03 09:17:12 -0700[diff] [blame]2318 rbody.append(' // TODO need to handle multiple instances and only clearing maps within an instance.')
2319 rbody.append(' // TODO this only works with a single instance used at any given time.')
2320 rbody.append(' clear_all_map_handles();')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]2321 rbody.append(' }')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2322 elif 'AllocDescriptorSets' in proto.name:
2323 rbody.append(' if (replayResult == XGL_SUCCESS)')
2324 rbody.append(' {')
2325 rbody.append(' for (uint32_t i = 0; i < local_pCount; i++) {')
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2326 rbody.append(' 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]2327 rbody.append(' }')
2328 rbody.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2329 elif create_func: # save handle mapping if create successful
2330 rbody.append(' if (replayResult == XGL_SUCCESS)')
2331 rbody.append(' {')
2332 rbody.append(' add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))
2333 if 'AllocMemory' == proto.name:
2334 rbody.append(' add_entry_to_mapData(local_%s, pPacket->pAllocInfo->allocationSize);' % (proto.params[-1].name))
2335 rbody.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2336 elif proto.name in do_while_dict:
2337 rbody[-1] = ' %s' % rbody[-1]
2338 rbody.append(' } while (%s);' % do_while_dict[proto.name])
Jon Ashburn8bead7a2015-02-23 11:07:30 -0700[diff] [blame]2339 rbody.append(' if (pPacket->result != XGL_NOT_READY || replayResult != XGL_SUCCESS)')
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]2340 elif proto.name == 'EnumerateLayers':
2341 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
2342 rbody.append(' GLV_DELETE(bufptr[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2343 if ret_value:
2344 rbody.append(' CHECK_RETURN_VALUE(xgl%s);' % proto.name)
2345 if 'MsgCallback' in proto.name:
2346 rbody.pop()
2347 rbody.pop()
2348 rbody.pop()
2349 rbody.append(' // Just eating these calls as no way to restore dbg func ptr.')
2350 rbody.append(' break;')
2351 rbody.append(' }')
2352 rbody.append(' default:')
2353 rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')
2354 rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')
2355 rbody.append(' break;')
2356 rbody.append(' }')
2357 rbody.append(' return returnValue;')
2358 rbody.append('}')
2359 return "\n".join(rbody)
2360
2361class GlaveTraceHeader(Subcommand):
2362 def generate_header(self):
2363 header_txt = []
Peter Lohrmann56782cd2015-03-27 12:57:10 -0700[diff] [blame]2364 header_txt.append('#include "glv_vk_vk_structs.h"')
2365 header_txt.append('#include "glv_vk_packet_id.h"\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2366 header_txt.append('void AttachHooks();')
2367 header_txt.append('void DetachHooks();')
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]2368 header_txt.append('void InitTracer(void);\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2369 return "\n".join(header_txt)
2370
2371 def generate_body(self):
2372 body = [self._generate_trace_func_ptrs(),
2373 self._generate_trace_func_protos()]
2374
2375 return "\n".join(body)
2376
2377class GlaveTraceC(Subcommand):
2378 def generate_header(self):
2379 header_txt = []
2380 header_txt.append('#include "glv_platform.h"')
2381 header_txt.append('#include "glv_common.h"')
2382 header_txt.append('#include "glvtrace_xgl_xgl.h"')
2383 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
2384 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
2385 header_txt.append('#include "glv_interconnect.h"')
2386 header_txt.append('#include "glv_filelike.h"')
Tobin Ehlisff765b02015-03-12 14:50:40 -0600[diff] [blame]2387 header_txt.append('#include "xgl_struct_size_helper.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2388 header_txt.append('#ifdef WIN32')
2389 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2390 header_txt.append('#endif')
2391 header_txt.append('#include "glv_trace_packet_utils.h"')
2392 header_txt.append('#include <stdio.h>\n')
2393 return "\n".join(header_txt)
2394
2395 def generate_body(self):
2396 body = [self._generate_func_ptr_assignments(),
2397 self._generate_attach_hooks(),
2398 self._generate_detach_hooks(),
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]2399 self._generate_init_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2400 self._generate_helper_funcs(),
2401 self._generate_trace_funcs()]
2402
2403 return "\n".join(body)
2404
2405class GlavePacketID(Subcommand):
2406 def generate_header(self):
2407 header_txt = []
2408 header_txt.append('#pragma once\n')
2409 header_txt.append('#include "glv_trace_packet_utils.h"')
2410 header_txt.append('#include "glv_trace_packet_identifiers.h"')
2411 header_txt.append('#include "glv_interconnect.h"')
Peter Lohrmann56782cd2015-03-27 12:57:10 -0700[diff] [blame]2412 header_txt.append('#include "glv_vk_vk_structs.h"')
2413 header_txt.append('#include "glv_vk_vkdbg_structs.h"')
2414 header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2415 header_txt.append('#include "xgl_enum_string_helper.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2416 header_txt.append('#if defined(WIN32)')
2417 header_txt.append('#define snprintf _snprintf')
2418 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2419 header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')
2420 header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\\n");\n')
2421 header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')
2422 header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')
2423 header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')
2424 header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);\n')
2425 header_txt.append('#define FINISH_TRACE_PACKET() \\')
2426 header_txt.append(' glv_finalize_trace_packet(pHeader); \\')
2427 header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')
2428 header_txt.append(' glv_delete_trace_packet(&pHeader);')
2429 return "\n".join(header_txt)
2430
2431 def generate_body(self):
2432 body = [self._generate_packet_id_enum(),
2433 self._generate_stringify_func(),
2434 self._generate_interp_func()]
2435
2436 return "\n".join(body)
2437
2438class GlaveCoreStructs(Subcommand):
2439 def generate_header(self):
2440 header_txt = []
2441 header_txt.append('#pragma once\n')
2442 header_txt.append('#include "xgl.h"')
2443 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2444 return "\n".join(header_txt)
2445
2446 def generate_body(self):
2447 body = [self._generate_struct_util_funcs(),
2448 self._generate_interp_funcs()]
2449
2450 return "\n".join(body)
2451
2452class GlaveWsiHeader(Subcommand):
2453 def generate_header(self):
2454 header_txt = []
2455 header_txt.append('#pragma once\n')
2456 header_txt.append('#include "xgl.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2457 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2458 header_txt.append('#include "xglWsiX11Ext.h"\n')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2459 header_txt.append('#else')
2460 header_txt.append('#include "xglWsiWinExt.h"')
2461 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2462 header_txt.append('void AttachHooks_xglwsix11ext();')
2463 header_txt.append('void DetachHooks_xglwsix11ext();')
2464 return "\n".join(header_txt)
2465
2466 def generate_body(self):
2467 body = [self._generate_trace_func_ptrs_ext(),
2468 self._generate_trace_func_protos_ext()]
2469
2470 return "\n".join(body)
2471
2472class GlaveWsiC(Subcommand):
2473 def generate_header(self):
2474 header_txt = []
2475 header_txt.append('#include "glv_platform.h"')
2476 header_txt.append('#include "glv_common.h"')
2477 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
Peter Lohrmann56782cd2015-03-27 12:57:10 -0700[diff] [blame]2478 header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
2479 header_txt.append('#include "glv_vk_packet_id.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2480 header_txt.append('#ifdef WIN32')
2481 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2482 header_txt.append('#endif')
2483 return "\n".join(header_txt)
2484
2485 def generate_body(self):
2486 body = [self._generate_func_ptr_assignments_ext(),
2487 self._generate_attach_hooks_ext(),
2488 self._generate_detach_hooks_ext(),
2489 self._generate_trace_funcs_ext()]
2490
2491 return "\n".join(body)
2492
2493class GlaveWsiStructs(Subcommand):
2494 def generate_header(self):
2495 header_txt = []
2496 header_txt.append('#pragma once\n')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2497 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2498 header_txt.append('#include "xglWsiX11Ext.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2499 header_txt.append('#else')
2500 header_txt.append('#include "xglWsiWinExt.h"')
2501 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2502 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2503 return "\n".join(header_txt)
2504
2505 def generate_body(self):
2506 body = [self._generate_interp_funcs_ext()]
2507
2508 return "\n".join(body)
2509
2510class GlaveDbgHeader(Subcommand):
2511 def generate_header(self):
2512 header_txt = []
2513 header_txt.append('#pragma once\n')
2514 header_txt.append('#include "xgl.h"')
2515 header_txt.append('#include "xglDbg.h"\n')
2516 header_txt.append('void AttachHooks_xgldbg();')
2517 header_txt.append('void DetachHooks_xgldbg();')
2518 return "\n".join(header_txt)
2519
2520 def generate_body(self):
2521 body = [self._generate_trace_func_ptrs_ext('Dbg'),
2522 self._generate_trace_func_protos_ext('Dbg')]
2523
2524 return "\n".join(body)
2525
2526class GlaveDbgC(Subcommand):
2527 def generate_header(self):
2528 header_txt = []
2529 header_txt.append('#include "glv_platform.h"')
2530 header_txt.append('#include "glv_common.h"')
2531 header_txt.append('#include "glvtrace_xgl_xgl.h"')
2532 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
Peter Lohrmann56782cd2015-03-27 12:57:10 -0700[diff] [blame]2533 header_txt.append('#include "glv_vk_vkdbg_structs.h"')
2534 header_txt.append('#include "glv_vk_packet_id.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2535 header_txt.append('#ifdef WIN32')
2536 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2537 header_txt.append('#endif')
2538 return "\n".join(header_txt)
2539
2540 def generate_body(self):
2541 body = [self._generate_func_ptr_assignments_ext('Dbg'),
2542 self._generate_attach_hooks_ext('Dbg'),
2543 self._generate_detach_hooks_ext('Dbg'),
2544 self._generate_trace_funcs_ext('Dbg')]
2545
2546 return "\n".join(body)
2547
2548class GlaveDbgStructs(Subcommand):
2549 def generate_header(self):
2550 header_txt = []
2551 header_txt.append('#pragma once\n')
2552 header_txt.append('#include "xglDbg.h"')
2553 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2554 return "\n".join(header_txt)
2555
2556 def generate_body(self):
2557 body = [self._generate_interp_funcs_ext('Dbg')]
2558
2559 return "\n".join(body)
2560
Peter Lohrmannaf44b452015-03-30 18:29:22 -0700[diff] [blame]2561class GlaveReplayXglFuncPtrs(Subcommand):
2562 def generate_header(self):
2563 header_txt = []
2564 header_txt.append('#pragma once\n')
2565 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
2566 header_txt.append('#include <xcb/xcb.h>\n')
2567 header_txt.append('#endif')
2568 header_txt.append('#include "xgl.h"')
2569 header_txt.append('#include "xglDbg.h"')
2570 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
2571 header_txt.append('#include "xglWsiX11Ext.h"')
2572 header_txt.append('#else')
2573 header_txt.append('#include "xglWsiWinExt.h"')
2574 header_txt.append('#endif')
2575
2576 def generate_body(self):
2577 body = [self._generate_replay_func_ptrs()]
2578 return "\n".join(body)
2579
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2580class GlaveReplayHeader(Subcommand):
2581 def generate_header(self):
2582 header_txt = []
2583 header_txt.append('#pragma once\n')
2584 header_txt.append('#include <set>')
2585 header_txt.append('#include <map>')
2586 header_txt.append('#include <vector>')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]2587 header_txt.append('#include <string>')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2588 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2589 header_txt.append('#include <xcb/xcb.h>\n')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2590 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2591 header_txt.append('#include "glvreplay_window.h"')
2592 header_txt.append('#include "glvreplay_factory.h"')
2593 header_txt.append('#include "glv_trace_packet_identifiers.h"\n')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2594 header_txt.append('extern "C" {\n')
2595 header_txt.append('#include "glv_vk_vk_structs.h"\n')
2596 header_txt.append('}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2597 header_txt.append('#include "xgl.h"')
2598 header_txt.append('#include "xglDbg.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2599 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2600 header_txt.append('#include "xglWsiX11Ext.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2601 header_txt.append('#else')
2602 header_txt.append('#include "xglWsiWinExt.h"')
2603 header_txt.append('#endif')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]2604 header_txt.append('#include "draw_state.h"')
Peter Lohrmanncaf39d52015-03-24 17:19:24 -0700[diff] [blame]2605 header_txt.append('#include "glave_snapshot.h"')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2606 header_txt.append('#include "glvreplay_xgl_xgldisplay.h"')
Peter Lohrmannaf44b452015-03-30 18:29:22 -0700[diff] [blame]2607 header_txt.append('#include "glvreplay_xgl_func_ptrs.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2608 return "\n".join(header_txt)
2609
2610 def generate_body(self):
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2611 body = [self._generate_replay_class()]
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2612
2613 return "\n".join(body)
2614
2615class GlaveReplayC(Subcommand):
2616 def generate_header(self):
2617 header_txt = []
2618 header_txt.append('#include "glvreplay_xgl_replay.h"\n')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2619 header_txt.append('#include "glvreplay_xgl.h"\n')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]2620 header_txt.append('#include "glvreplay_xgl_write_ppm.h"\n')
2621 header_txt.append('#include "glvreplay_main.h"\n')
2622 header_txt.append('#include <algorithm>')
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2623 header_txt.append('#include <queue>')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2624 header_txt.append('\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2625 header_txt.append('extern "C" {')
Peter Lohrmann56782cd2015-03-27 12:57:10 -0700[diff] [blame]2626 header_txt.append('#include "glv_vk_vk_structs.h"')
2627 header_txt.append('#include "glv_vk_vkdbg_structs.h"')
2628 header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
2629 header_txt.append('#include "glv_vk_packet_id.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2630 header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')
2631 header_txt.append('#define APP_NAME "glvreplay_xgl"')
2632 header_txt.append('#define IDI_ICON 101\n')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2633
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2634 return "\n".join(header_txt)
2635
2636 def generate_body(self):
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame^]2637 body = [self._generate_replay_init_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2638 self._generate_replay()]
2639
2640 return "\n".join(body)
2641
2642def main():
2643 subcommands = {
2644 "glave-trace-h" : GlaveTraceHeader,
2645 "glave-trace-c" : GlaveTraceC,
2646 "glave-packet-id" : GlavePacketID,
2647 "glave-core-structs" : GlaveCoreStructs,
2648 "glave-wsi-trace-h" : GlaveWsiHeader,
2649 "glave-wsi-trace-c" : GlaveWsiC,
2650 "glave-wsi-trace-structs" : GlaveWsiStructs,
2651 "glave-dbg-trace-h" : GlaveDbgHeader,
2652 "glave-dbg-trace-c" : GlaveDbgC,
2653 "glave-dbg-trace-structs" : GlaveDbgStructs,
Peter Lohrmannaf44b452015-03-30 18:29:22 -0700[diff] [blame]2654 "glave-replay-xgl-funcs" : GlaveReplayXglFuncPtrs,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2655 "glave-replay-h" : GlaveReplayHeader,
2656 "glave-replay-c" : GlaveReplayC,
2657 }
2658
2659 if len(sys.argv) < 2 or sys.argv[1] not in subcommands:
2660 print("Usage: %s <subcommand> [options]" % sys.argv[0])
2661 print
2662 print("Available sucommands are: %s" % " ".join(subcommands))
2663 exit(1)
2664
2665 subcmd = subcommands[sys.argv[1]](sys.argv[2:])
2666 subcmd.run()
2667
2668if __name__ == "__main__":
2669 main()