Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / cbf13815f1d7edc77f94c63f6707ec7667ff1bc1 / . / tools / glave / scripts / vk_generate.py
blob: 570a2039505b216de0e2ea4a960fdf0d71a3219b [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 Lohrmannd221ea12015-03-25 21:35:32 -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
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]182 def _generate_trace_real_func_ptr_protos(self):
183 func_ptr_assign = []
184 func_ptr_assign.append('')
185 for proto in self.protos:
186 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
187 func_ptr_assign.append('extern %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
188 for p in proto.params:
Courtney Goeltzenleuchter3ffda652015-04-13 14:33:40 -0600[diff] [blame]189 if 'color' == p.name and 'XGL_CLEAR_COLOR' != p.ty:
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]190 func_ptr_assign.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))
191 else:
192 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
193 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ');\n')
194 return "\n".join(func_ptr_assign)
195
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]196 def _generate_func_ptr_assignments(self):
197 func_ptr_assign = []
198 for proto in self.protos:
199 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]200 func_ptr_assign.append('%s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]201 for p in proto.params:
Courtney Goeltzenleuchter9a1ded82015-04-03 16:35:32 -0600[diff] [blame]202 if 'color' == p.name and 'XGL_CLEAR_COLOR' != p.ty:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]203 func_ptr_assign.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))
204 else:
205 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
206 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]207 return "\n".join(func_ptr_assign)
208
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]209
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]210 def _generate_func_ptr_assignments_ext(self, func_class='Wsi'):
211 func_ptr_assign = []
212 for proto in self.protos:
213 if func_class in proto.name:
214 func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
215 for p in proto.params:
216 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
217 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
218 return "\n".join(func_ptr_assign)
219
220 def _generate_attach_hooks(self):
221 hooks_txt = []
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]222 hooks_txt.append('// declared as extern in glvtrace_xgl_helpers.h')
223 hooks_txt.append('BOOL isHooked = FALSE;\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]224 hooks_txt.append('void AttachHooks()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)')
225 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]226 # TODO : Verify if CreateInstance is appropriate to key off of here
227 hooks_txt.append(' if (real_xglCreateInstance != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]228 hooks_txt.append(' {\n isHooked = TRUE;')
229 hook_operator = '='
230 for proto in self.protos:
231 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
232 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
233 hook_operator = '&='
234 hooks_txt.append(' }\n')
235 hooks_txt.append(' if (!hookSuccess)\n {')
236 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
237 hooks_txt.append(' Mhook_EndMultiOperation();\n')
238 hooks_txt.append('#elif defined(__linux__)')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]239 hooks_txt.append(' if (real_xglCreateInstance == xglCreateInstance)')
240 hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateInstance,"xglCreateInstance");')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]241 hooks_txt.append(' isHooked = TRUE;')
242 for proto in self.protos:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]243 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]244 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
245 hooks_txt.append(' if (!hookSuccess)\n {')
246 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
247 hooks_txt.append('#endif\n}\n')
248 return "\n".join(hooks_txt)
249
250 def _generate_attach_hooks_ext(self, func_class='Wsi'):
251 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
252 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
253 hooks_txt = []
254 hooks_txt.append('void AttachHooks%s()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)' % func_ext_dict[func_class])
255 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
256 hooks_txt.append(' if (real_xgl%s != NULL)' % first_proto_dict[func_class])
257 hooks_txt.append(' {')
258 hook_operator = '='
259 for proto in self.protos:
260 if func_class in proto.name:
261 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
262 hook_operator = '&='
263 hooks_txt.append(' }\n')
264 hooks_txt.append(' if (!hookSuccess)\n {')
265 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
266 hooks_txt.append(' Mhook_EndMultiOperation();\n')
267 hooks_txt.append('#elif defined(__linux__)')
268 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]))
269 for proto in self.protos:
270 if func_class in proto.name and first_proto_dict[func_class] not in proto.name:
271 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
272 hooks_txt.append(' if (!hookSuccess)\n {')
273 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
274 hooks_txt.append('#endif\n}\n')
275 return "\n".join(hooks_txt)
276
277 def _generate_detach_hooks(self):
278 hooks_txt = []
279 hooks_txt.append('void DetachHooks()\n{\n#ifdef __linux__\n return;\n#elif defined(WIN32)')
280 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xglGetGpuInfo != NULL)\n {')
281 hook_operator = '='
282 for proto in self.protos:
283 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
284 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
285 hook_operator = '&='
286 hooks_txt.append(' }\n isHooked = FALSE;')
287 hooks_txt.append(' if (!unhookSuccess)\n {')
288 hooks_txt.append(' glv_LogError("Failed to unhook XGL.");\n }')
289 hooks_txt.append('#endif\n}')
290 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')
291 return "\n".join(hooks_txt)
292
293 def _generate_detach_hooks_ext(self, func_class='Wsi'):
294 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
295 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
296 hooks_txt = []
297 hooks_txt.append('void DetachHooks%s()\n{\n#ifdef WIN32' % func_ext_dict[func_class])
298 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xgl%s != NULL)\n {' % first_proto_dict[func_class])
299 hook_operator = '='
300 for proto in self.protos:
301 if func_class in proto.name:
302 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
303 hook_operator = '&='
304 hooks_txt.append(' }')
305 hooks_txt.append(' if (!unhookSuccess)\n {')
306 hooks_txt.append(' glv_LogError("Failed to unhook XGL ext %s.");\n }' % func_class)
307 hooks_txt.append('#elif defined(__linux__)\n return;\n#endif\n}\n')
308 return "\n".join(hooks_txt)
309
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]310 def _generate_init_funcs(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]311 init_tracer = []
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]312 init_tracer.append('void send_xgl_api_version_packet()\n{')
313 init_tracer.append(' struct_xglApiVersion* pPacket;')
314 init_tracer.append(' glv_trace_packet_header* pHeader;')
315 init_tracer.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_xglApiVersion, sizeof(struct_xglApiVersion), 0);')
316 init_tracer.append(' pPacket = interpret_body_as_xglApiVersion(pHeader, FALSE);')
317 init_tracer.append(' pPacket->version = XGL_API_VERSION;')
318 init_tracer.append(' FINISH_TRACE_PACKET();\n}\n')
319
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]320 init_tracer.append('extern GLV_CRITICAL_SECTION g_memInfoLock;')
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]321 init_tracer.append('void InitTracer(void)\n{')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]322 init_tracer.append(' char *ipAddr = glv_get_global_var("GLVLIB_TRACE_IPADDR");')
323 init_tracer.append(' if (ipAddr == NULL)')
324 init_tracer.append(' ipAddr = "127.0.0.1";')
Jon Ashburn0fed6752015-01-09 17:36:10 -0700[diff] [blame]325 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]326 init_tracer.append(' glv_trace_set_trace_file(glv_FileLike_create_msg(gMessageStream));')
327 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]328 init_tracer.append(' glv_tracelog_set_tracer_id(GLV_TID_XGL);')
Jon Ashburn1ba771d2015-02-19 17:04:06 -0700[diff] [blame]329 init_tracer.append(' glv_create_critical_section(&g_memInfoLock);')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]330 init_tracer.append(' send_xgl_api_version_packet();\n}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]331 return "\n".join(init_tracer)
332
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]333 # Take a list of params and return a list of dicts w/ ptr param details
334 def _get_packet_ptr_param_list(self, params):
335 ptr_param_list = []
336 # TODO : This is a slightly nicer way to handle custom cases than initial code, however
337 # this can still be further generalized to eliminate more custom code
338 # big case to handle is when ptrs to structs have embedded data that needs to be accounted for in packet
339 custom_ptr_dict = {'XGL_DEVICE_CREATE_INFO': {'add_txt': 'add_XGL_DEVICE_CREATE_INFO_to_packet(pHeader, (XGL_DEVICE_CREATE_INFO**) &(pPacket->pCreateInfo), pCreateInfo)',
340 'finalize_txt': ''},
Jon Ashburn29669a42015-04-04 14:52:07 -0600[diff] [blame]341 'XGL_INSTANCE_CREATE_INFO': {'add_txt': 'add_XGL_INSTANCE_CREATE_INFO_to_packet(pHeader, (XGL_INSTANCE_CREATE_INFO**)&(pPacket->pCreateInfo), pCreateInfo)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]342 'finalize_txt': ''},
343 'XGL_PHYSICAL_GPU': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), *pGpuCount*sizeof(XGL_PHYSICAL_GPU), pGpus)',
344 'finalize_txt': 'default'},
345 'pDataSize': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(size_t), &_dataSize)',
346 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize))'},
347 'pData': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), _dataSize, pData)',
348 'finalize_txt': 'default'},
349 'pName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pName), ((pName != NULL) ? strlen(pName) + 1 : 0), pName)',
350 'finalize_txt': 'default'},
351 'pExtName': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pExtName), ((pExtName != NULL) ? strlen(pExtName) + 1 : 0), pExtName)',
352 'finalize_txt': 'default'},
353 'pDescriptorSets': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets)',
354 'finalize_txt': 'default'},
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]355 '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)',
356 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
357 '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)',
358 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
359 '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)',
360 '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))'},
361 '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)',
362 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBeginInfo))'},
363 '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)',
364 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pViewports));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pScissors));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
365 '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)',
366 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo))'},
367 '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)',
368 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
Jon Ashburnba8ccb62015-04-01 13:30:06 -0600[diff] [blame]369 'XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO': {'add_txt': 'if (pCreateInfo)\n add_create_ds_layout_to_trace_packet(pHeader, &(pPacket->pCreateInfo), pCreateInfo)',
Jon Ashburnce82f362015-03-30 15:21:10 -0600[diff] [blame]370 'finalize_txt': '// pCreateInfo finalized in add_create_ds_layout_to_trace_packet'},
Jon Ashburn8f831ab2015-03-30 09:11:02 -0600[diff] [blame]371 'XGL_DESCRIPTOR_POOL_CREATE_INFO': {'add_txt': 'glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_DESCRIPTOR_POOL_CREATE_INFO), pCreateInfo);\n glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), rgCount * sizeof(XGL_DESCRIPTOR_TYPE_COUNT), pCreateInfo->pTypeCount)',
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]372 'finalize_txt': 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
373 '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)',
374 'finalize_txt': 'finalize_pipeline_shader_address(pHeader, &pPacket->pCreateInfo->cs);\n glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo))'},
375 }
376 for p in params:
377 pp_dict = {}
378 if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
379 if 'const' in p.ty.lower() and 'count' in params[params.index(p)-1].name.lower():
380 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)
381 elif p.ty.strip('*').replace('const ', '') in custom_ptr_dict:
382 pp_dict['add_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['add_txt']
383 pp_dict['finalize_txt'] = custom_ptr_dict[p.ty.strip('*').replace('const ', '')]['finalize_txt']
384 elif p.name in custom_ptr_dict:
385 pp_dict['add_txt'] = custom_ptr_dict[p.name]['add_txt']
386 pp_dict['finalize_txt'] = custom_ptr_dict[p.name]['finalize_txt']
387 # TODO : This is custom hack to account for 2 pData items with dataSize param for sizing
388 if 'pData' == p.name and 'dataSize' == params[params.index(p)-1].name:
389 pp_dict['add_txt'] = pp_dict['add_txt'].replace('_dataSize', 'dataSize')
390 else:
391 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)
392 if 'finalize_txt' not in pp_dict or 'default' == pp_dict['finalize_txt']:
393 pp_dict['finalize_txt'] = 'glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s))' % (p.name)
394 pp_dict['index'] = params.index(p)
395 ptr_param_list.append(pp_dict)
396 return ptr_param_list
397
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]398 # Take a list of params and return a list of packet size elements
399 def _get_packet_size(self, params):
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]400 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]401 skip_list = [] # store params that are already accounted for so we don't count them twice
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]402 for p in params:
403 #First handle custom cases
Jon Ashburnce82f362015-03-30 15:21:10 -0600[diff] [blame]404 if p.name in ['pCreateInfo', 'pBeginInfo', 'pAllocInfo']:
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]405 ps.append('get_struct_chain_size((void*)%s)' % p.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]406 skip_list.append(p.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]407 # Skip any params already handled
408 if p.name in skip_list:
409 continue
410 # Now check to identify dynamic arrays which depend on two params
411 if 'count' in p.name.lower():
412 next_idx = params.index(p)+1
413 # If next element is a const *, then multiply count and array type
414 if next_idx < len(params) and '*' in params[next_idx].ty and 'const' in params[next_idx].ty.lower():
415 if '*' in p.ty:
416 ps.append('*%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
417 else:
418 ps.append('%s*sizeof(%s)' % (p.name, params[next_idx].ty.strip('*').replace('const ', '')))
419 skip_list.append(params[next_idx].name)
420 elif '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
421 if 'pData' == p.name:
422 if 'dataSize' == params[params.index(p)-1].name:
423 ps.append('dataSize')
424 elif 'counterCount' == params[params.index(p)-1].name:
425 ps.append('sizeof(%s)' % p.ty.strip('*').replace('const ', ''))
426 else:
427 ps.append('((pDataSize != NULL && pData != NULL) ? *pDataSize : 0)')
428 elif '**' in p.ty and 'void' in p.ty:
429 ps.append('sizeof(void*)')
430 elif 'void' in p.ty:
431 ps.append('sizeof(%s)' % p.name)
432 elif 'char' in p.ty:
433 ps.append('((%s != NULL) ? strlen(%s) + 1 : 0)' % (p.name, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]434 elif 'pDataSize' in p.name:
435 ps.append('((pDataSize != NULL) ? sizeof(size_t) : 0)')
436 elif 'IMAGE_SUBRESOURCE' in p.ty and 'pSubresource' == p.name:
437 ps.append('((pSubresource != NULL) ? sizeof(XGL_IMAGE_SUBRESOURCE) : 0)')
438 else:
439 ps.append('sizeof(%s)' % (p.ty.strip('*').replace('const ', '')))
440 return ps
441
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]442 # 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]443 # Here's the general flow of code insertion w/ option items flagged w/ "?"
444 # Result decl?
445 # Packet struct decl
446 # ?Special case : setup call to function first and do custom API call time tracking
447 # CREATE_PACKET
448 # Call (w/ result?)
449 # Assign packet values
450 # FINISH packet
451 # return result?
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]452 def _generate_trace_funcs(self):
453 func_body = []
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]454 manually_written_hooked_funcs = ['CreateInstance', 'EnumerateLayers', 'EnumerateGpus',
455 'AllocDescriptorSets', 'MapMemory', 'UnmapMemory',
456 'CmdPipelineBarrier', 'CmdWaitEvents']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]457 for proto in self.protos:
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]458 if proto.name in manually_written_hooked_funcs:
459 func_body.append( '// __HOOKED_xgl%s is manually written. Look in glvtrace_xgl_trace.c\n' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]460 elif 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]461 raw_packet_update_list = [] # non-ptr elements placed directly into packet
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]462 ptr_packet_update_list = [] # ptr elements to be updated into packet
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]463 return_txt = ''
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]464 packet_size = []
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]465 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]466 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]467 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 if NULL
468 if '[' in p.ty: # Correctly declare static arrays in function parameters
469 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]470 else:
471 func_body.append(' %s %s,' % (p.ty, p.name))
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]472 if '*' in p.ty and p.name not in ['pSysMem', 'pReserved']:
473 if 'pDataSize' in p.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]474 in_data_size = True;
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]475 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]476 if '[' in p.ty:
Tobin Ehlis8a5a85b2015-02-25 11:30:27 -0700[diff] [blame]477 array_str = p.ty[p.ty.find('[')+1:p.ty.find(']')]
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]478 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]479 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]480 raw_packet_update_list.append(' pPacket->%s = %s;' % (p.name, p.name))
481 # Get list of packet size modifiers due to ptr params
482 packet_size = self._get_packet_size(proto.params)
Tobin Ehlis1d3dd2b2015-03-11 17:19:54 -0600[diff] [blame]483 ptr_packet_update_list = self._get_packet_ptr_param_list(proto.params)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]484 func_body[-1] = func_body[-1].replace(',', ')')
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]485 # End of function declaration portion, begin function body
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]486 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]487 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]488 func_body.append(' %s result;' % proto.ret)
489 return_txt = 'result = '
490 if in_data_size:
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]491 func_body.append(' size_t _dataSize;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]492 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
Jon Ashburn8cb39a32015-02-02 12:39:24 -0700[diff] [blame]493 # functions that have non-standard sequence of packet creation and calling real function
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]494 # NOTE: Anytime we call the function before CREATE_TRACE_PACKET, need to add custom code for correctly tracking API call time
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]495 if proto.name in ['CreateFramebuffer', 'CreateRenderPass', 'CreateDynamicViewportState',
Jon Ashburnce82f362015-03-30 15:21:10 -0600[diff] [blame]496 'CreateDescriptorPool', 'UpdateDescriptors']:
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]497 # 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]498 if 'CreateFramebuffer' == proto.name:
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]499 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]500 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && pCreateInfo->pColorAttachments != NULL) ? pCreateInfo->colorAttachmentCount : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]501 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]502 elif 'CreateRenderPass' == proto.name:
Jon Ashburnec7dcb42015-02-20 10:30:32 -0700[diff] [blame]503 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && (pCreateInfo->pColorLoadOps != NULL || pCreateInfo->pColorStoreOps != NULL || pCreateInfo->pColorLoadClearValues != NULL)) ? pCreateInfo->colorAttachmentCount : 0;')
Jon Ashburn615b6ce2015-03-09 12:39:26 -0600[diff] [blame]504 func_body.append(' size_t customSize;')
505 func_body.append(' customSize = colorCount * ((pCreateInfo->pColorFormats != NULL) ? sizeof(XGL_FORMAT) : 0);')
506 func_body.append(' customSize += colorCount * ((pCreateInfo->pColorLayouts != NULL) ? sizeof(XGL_IMAGE_LAYOUT) : 0);')
507 func_body.append(' customSize += colorCount * ((pCreateInfo->pColorLoadOps != NULL) ? sizeof(XGL_ATTACHMENT_LOAD_OP) : 0);')
508 func_body.append(' customSize += colorCount * ((pCreateInfo->pColorStoreOps != NULL) ? sizeof(XGL_ATTACHMENT_STORE_OP) : 0);')
509 func_body.append(' customSize += colorCount * ((pCreateInfo->pColorLoadClearValues != NULL) ? sizeof(XGL_CLEAR_COLOR) : 0);')
510 func_body.append(' CREATE_TRACE_PACKET(xglCreateRenderPass, sizeof(XGL_RENDER_PASS_CREATE_INFO) + sizeof(XGL_RENDER_PASS) + customSize);')
511 elif 'BeginCommandBuffer' == proto.name:
512 func_body.append(' customSize = calculate_begin_cmdbuf_size(pBeginInfo->pNext);')
513 func_body.append(' CREATE_TRACE_PACKET(xglBeginCommandBuffer, sizeof(XGL_CMD_BUFFER_BEGIN_INFO) + customSize);')
Jon Ashburn8e7dcd02015-02-04 08:50:35 -0700[diff] [blame]514 elif 'CreateDynamicViewportState' == proto.name:
Courtney Goeltzenleuchterc6e32f92015-02-11 14:13:34 -0700[diff] [blame]515 func_body.append(' uint32_t vpsCount = (pCreateInfo != NULL && pCreateInfo->pViewports != NULL) ? pCreateInfo->viewportAndScissorCount : 0;')
Tobin Ehlisf57562c2015-03-13 07:18:05 -0600[diff] [blame]516 func_body.append(' CREATE_TRACE_PACKET(xglCreateDynamicViewportState, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_DYNAMIC_VP_STATE_OBJECT));')
Jon Ashburn8f831ab2015-03-30 09:11:02 -0600[diff] [blame]517 elif 'CreateDescriptorPool' == proto.name:
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]518 func_body.append(' uint32_t rgCount = (pCreateInfo != NULL && pCreateInfo->pTypeCount != NULL) ? pCreateInfo->count : 0;')
Jon Ashburn8f831ab2015-03-30 09:11:02 -0600[diff] [blame]519 func_body.append(' CREATE_TRACE_PACKET(xglCreateDescriptorPool, get_struct_chain_size((void*)pCreateInfo) + sizeof(XGL_DESCRIPTOR_POOL));')
Jon Ashburnce82f362015-03-30 15:21:10 -0600[diff] [blame]520 elif 'UpdateDescriptors' == proto.name:
521 func_body.append(' uint32_t i;')
522 func_body.append(' size_t customSize=0;')
523 func_body.append(' for (i = 0; i < updateCount; i++)')
524 func_body.append(' {')
525 func_body.append(' customSize += get_struct_chain_size(ppUpdateArray[i]);')
526 func_body.append(' customSize += sizeof(intptr_t);')
527 func_body.append(' }')
528 func_body.append(' CREATE_TRACE_PACKET(xglUpdateDescriptors, customSize);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]529 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
530 else:
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]531 if (0 == len(packet_size)):
532 func_body.append(' CREATE_TRACE_PACKET(xgl%s, 0);' % (proto.name))
533 else:
534 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, ' + '.join(packet_size)))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]535 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Jon Ashburn53f54a32015-02-11 09:32:29 -0700[diff] [blame]536 if in_data_size:
537 func_body.append(' _dataSize = (pDataSize == NULL || pData == NULL) ? 0 : *pDataSize;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]538 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
Tobin Ehlis81b1b3d2015-03-10 11:04:17 -0600[diff] [blame]539 func_body.append('\n'.join(raw_packet_update_list))
Jon Ashburnce82f362015-03-30 15:21:10 -0600[diff] [blame]540 if 'UpdateDescriptors' == proto.name:
541 func_body.append(' // add buffer which is an array of pointers')
542 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppUpdateArray), updateCount * sizeof(intptr_t), ppUpdateArray);')
543 func_body.append(' // add all the sub buffers with descriptor updates')
544 func_body.append(' add_update_descriptors_to_trace_packet(pHeader, updateCount, (void ***) &pPacket->ppUpdateArray, ppUpdateArray);')
545 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppUpdateArray));')
546 func_body.append(' FINISH_TRACE_PACKET();')
547 else:
548 for pp_dict in ptr_packet_update_list: #buff_ptr_indices:
549 func_body.append(' %s;' % (pp_dict['add_txt']))
550 if 'void' not in proto.ret or '*' in proto.ret:
551 func_body.append(' pPacket->result = result;')
552 for pp_dict in ptr_packet_update_list:
Jon Ashburn29669a42015-04-04 14:52:07 -0600[diff] [blame]553 if ('DEVICE_CREATE_INFO' not in proto.params[pp_dict['index']].ty) and ('INSTANCE_CREATE_INFO' not in proto.params[pp_dict['index']].ty) and ('ppUpdateArray' != proto.params[pp_dict['index']].name):
Jon Ashburnce82f362015-03-30 15:21:10 -0600[diff] [blame]554 func_body.append(' %s;' % (pp_dict['finalize_txt']))
555 func_body.append(' FINISH_TRACE_PACKET();')
556 if 'AllocMemory' in proto.name:
557 func_body.append(' add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);')
558 elif 'FreeMemory' in proto.name:
559 func_body.append(' rm_handle_from_mem_info(mem);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]560 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]561 func_body.append(' return result;')
562 func_body.append('}\n')
563 return "\n".join(func_body)
564
565 def _generate_trace_funcs_ext(self, func_class='Wsi'):
566 thread_once_funcs = ['DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback', 'DbgSetGlobalOption']
567 func_body = []
568 for proto in self.protos:
569 if func_class in proto.name:
570 packet_update_txt = ''
571 return_txt = ''
572 packet_size = ''
573 buff_ptr_indices = []
574 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
575 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL
576 func_body.append(' %s %s,' % (p.ty, p.name))
577 if 'Size' in p.name:
578 packet_size += p.name
579 if '*' in p.ty and 'pSysMem' != p.name:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]580 if 'char' in p.ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]581 packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]582 elif 'Size' not in packet_size:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]583 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]584 buff_ptr_indices.append(proto.params.index(p))
585 if 'pConnectionInfo' in p.name:
586 packet_size += '((pConnectionInfo->pConnection != NULL) ? sizeof(void *) : 0)'
587 else:
588 packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)
589 if '' == packet_size:
590 packet_size = '0'
591 else:
592 packet_size = packet_size.strip(' + ')
593 func_body[-1] = func_body[-1].replace(',', ')')
594 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]595 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]596 func_body.append(' %s result;' % proto.ret)
597 return_txt = 'result = '
598 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
599 if proto.name in thread_once_funcs:
600 func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')
601 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]602 if 'DbgRegisterMsgCallback' in proto.name:
603 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(char));' % proto.name)
604 else:
605 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]606 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
607 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
608 func_body.append(packet_update_txt.strip('\n'))
609 for idx in buff_ptr_indices:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]610 if 'char' in proto.params[idx].ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]611 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]612 elif 'Size' in proto.params[idx-1].name:
613 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]614 elif 'DbgRegisterMsgCallback' in proto.name:
615 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]616 else:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]617 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]618 if 'WsiX11AssociateConnection' in proto.name:
619 func_body.append(' if (pConnectionInfo->pConnection != NULL) {')
620 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection), sizeof(void *), pConnectionInfo->pConnection);')
621 func_body.append(' glv_finalize_buffer_address(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection));')
622 func_body.append(' }')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]623 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]624 func_body.append(' pPacket->result = result;')
625 for idx in buff_ptr_indices:
626 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))
627 func_body.append(' FINISH_TRACE_PACKET();')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]628 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]629 func_body.append(' return result;')
630 func_body.append('}\n')
631 return "\n".join(func_body)
632
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]633 def _generate_packet_id_enum(self):
634 pid_enum = []
635 pid_enum.append('enum GLV_TRACE_PACKET_ID_XGL')
636 pid_enum.append('{')
637 first_func = True
638 for proto in self.protos:
639 if first_func:
640 first_func = False
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]641 pid_enum.append(' GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,')
642 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]643 else:
644 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
645 pid_enum.append('};\n')
646 return "\n".join(pid_enum)
647
648 def _generate_stringify_func(self):
649 func_body = []
650 func_body.append('static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)')
651 func_body.append('{')
652 func_body.append(' static char str[1024];')
653 func_body.append(' switch(id) {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]654 func_body.append(' case GLV_TPI_XGL_xglApiVersion:')
655 func_body.append(' {')
656 func_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);')
657 func_body.append(' snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);')
658 func_body.append(' return str;')
659 func_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]660 for proto in self.protos:
661 func_body.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
662 func_body.append(' {')
663 func_str = 'xgl%s(' % proto.name
664 print_vals = ''
665 create_func = False
666 if 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
667 create_func = True
668 for p in proto.params:
669 last_param = False
670 if (p.name == proto.params[-1].name):
671 last_param = True
672 if last_param and create_func: # last param of create func
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]673 (pft, pfi, ptr) = self._get_printf_params(p.ty,'pPacket->%s' % p.name, True)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]674 else:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]675 (pft, pfi, ptr) = self._get_printf_params(p.ty, 'pPacket->%s' % p.name, False)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]676 if last_param == True:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]677 func_str += '%s%s = %s)' % (ptr, p.name, pft)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]678 print_vals += ', %s' % (pfi)
Courtney Goeltzenleuchter9a1ded82015-04-03 16:35:32 -0600[diff] [blame]679 elif 'XGL_CLEAR_COLOR' == p.ty:
680 func_str += '%s%s = %s, ' % (ptr, p.name, pft)
681 print_vals += ', (void *) &pPacket->%s' % (p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]682 else:
Jon Ashburn8f445632015-02-12 10:38:36 -0700[diff] [blame]683 func_str += '%s%s = %s, ' % (ptr, p.name, pft)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]684 print_vals += ', %s' % (pfi)
685 func_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(pHeader->pBody);' % (proto.name, proto.name))
686 func_body.append(' snprintf(str, 1024, "%s"%s);' % (func_str, print_vals))
687 func_body.append(' return str;')
688 func_body.append(' }')
689 func_body.append(' default:')
690 func_body.append(' return NULL;')
691 func_body.append(' }')
692 func_body.append('};\n')
693 return "\n".join(func_body)
694
695 def _generate_interp_func(self):
696 interp_func_body = []
697 interp_func_body.append('static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)')
698 interp_func_body.append('{')
699 interp_func_body.append(' if (pHeader == NULL)')
700 interp_func_body.append(' {')
701 interp_func_body.append(' return NULL;')
702 interp_func_body.append(' }')
703 interp_func_body.append(' switch (pHeader->packet_id)')
704 interp_func_body.append(' {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]705 interp_func_body.append(' case GLV_TPI_XGL_xglApiVersion:\n {')
706 interp_func_body.append(' return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;\n }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]707 for proto in self.protos:
708 interp_func_body.append(' case GLV_TPI_XGL_xgl%s:\n {' % proto.name)
709 header_prefix = 'h'
710 if 'Wsi' in proto.name or 'Dbg' in proto.name:
711 header_prefix = 'pH'
712 interp_func_body.append(' return interpret_body_as_xgl%s(pHeader)->%seader;\n }' % (proto.name, header_prefix))
713 interp_func_body.append(' default:')
714 interp_func_body.append(' return NULL;')
715 interp_func_body.append(' }')
716 interp_func_body.append(' return NULL;')
717 interp_func_body.append('}')
718 return "\n".join(interp_func_body)
719
720 def _generate_struct_util_funcs(self):
721 pid_enum = []
722 pid_enum.append('//=============================================================================')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]723 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)')
724 pid_enum.append('{')
725 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]726 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen(pInStruct->pAppName) + 1, pInStruct->pAppName);')
727 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]728 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')
729 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')
730 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
731 pid_enum.append('};\n')
Jon Ashburn29669a42015-04-04 14:52:07 -0600[diff] [blame]732 pid_enum.append('static void add_XGL_INSTANCE_CREATE_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_INSTANCE_CREATE_INFO** ppStruct, const XGL_INSTANCE_CREATE_INFO *pInStruct)')
733 pid_enum.append('{')
734 pid_enum.append(' uint32_t i = 0;')
735 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_INSTANCE_CREATE_INFO), pInStruct);')
736 pid_enum.append(' add_XGL_APPLICATION_INFO_to_packet(pHeader, (XGL_APPLICATION_INFO**) &((*ppStruct)->pAppInfo), pInStruct->pAppInfo);')
737 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAllocCb), sizeof(XGL_ALLOC_CALLBACKS), pInStruct->pAllocCb);')
738 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAllocCb));')
739 pid_enum.append(' if (pInStruct->extensionCount > 0) ')
740 pid_enum.append(' {')
741 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char *), pInStruct->ppEnabledExtensionNames);')
742 pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')
743 pid_enum.append(' {')
744 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen(pInStruct->ppEnabledExtensionNames[i]) + 1, pInStruct->ppEnabledExtensionNames[i]);')
745 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')
746 pid_enum.append(' }')
747 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
748 pid_enum.append(' }')
749 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
750 pid_enum.append('};\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]751 pid_enum.append('//=============================================================================\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]752 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)')
753 pid_enum.append('{')
754 pid_enum.append(' uint32_t i;')
755 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]756 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]757 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')
Jon Ashburn29669a42015-04-04 14:52:07 -0600[diff] [blame]758 pid_enum.append(' if (pInStruct->extensionCount > 0)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]759 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]760 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]761 pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')
762 pid_enum.append(' {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]763 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]764 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')
765 pid_enum.append(' }')
766 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
767 pid_enum.append(' }')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]768 pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) pInStruct->pNext;')
769 pid_enum.append(' while (pNext != NULL)')
770 pid_enum.append(' {')
771 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
772 pid_enum.append(' {')
773 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->pNext)), sizeof(XGL_LAYER_CREATE_INFO), pNext);')
774 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->pNext)));')
775 pid_enum.append(' XGL_LAYER_CREATE_INFO **ppOutStruct = (XGL_LAYER_CREATE_INFO **) &((*ppStruct)->pNext);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]776 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]777 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
778 pid_enum.append(' {')
779 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])), strlen(pNext->ppActiveLayerNames[i]) + 1, pNext->ppActiveLayerNames[i]);')
780 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])));')
781 pid_enum.append(' }')
782 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppOutStruct)->ppActiveLayerNames);')
783 pid_enum.append(' }')
784 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) pNext->pNext;')
785 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]786 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')
787 pid_enum.append('}\n')
788 pid_enum.append('static XGL_DEVICE_CREATE_INFO* interpret_XGL_DEVICE_CREATE_INFO(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')
789 pid_enum.append('{')
790 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')
791 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO != NULL)')
792 pid_enum.append(' {')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]793 pid_enum.append(' uint32_t i;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]794 pid_enum.append(' const char** pNames;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]795 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')
796 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO->extensionCount > 0)')
797 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]798 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);')
799 pid_enum.append(' pNames = (const char**)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]800 pid_enum.append(' for (i = 0; i < pXGL_DEVICE_CREATE_INFO->extensionCount; i++)')
801 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]802 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]803 pid_enum.append(' }')
804 pid_enum.append(' }')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]805 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);')
806 pid_enum.append(' while (pNext != NULL)')
807 pid_enum.append(' {')
808 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
809 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]810 pid_enum.append(' pNext->ppActiveLayerNames = (const char**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames));')
811 pid_enum.append(' pNames = (const char**)pNext->ppActiveLayerNames;')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]812 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
813 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]814 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]815 pid_enum.append(' }')
816 pid_enum.append(' }')
817 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);')
818 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]819 pid_enum.append(' }\n')
820 pid_enum.append(' return pXGL_DEVICE_CREATE_INFO;')
821 pid_enum.append('}\n')
822 pid_enum.append('static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* pShader)')
823 pid_enum.append('{')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]824 pid_enum.append(' if (pShader != NULL)')
825 pid_enum.append(' {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]826 pid_enum.append(' // constant buffers')
827 pid_enum.append(' if (pShader->linkConstBufferCount > 0)')
828 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]829 pid_enum.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]830 pid_enum.append(' pShader->pLinkConstBufferInfo = (const XGL_LINK_CONST_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);')
831 pid_enum.append(' for (i = 0; i < pShader->linkConstBufferCount; i++)')
832 pid_enum.append(' {')
833 pid_enum.append(' XGL_LINK_CONST_BUFFER* pBuffer = (XGL_LINK_CONST_BUFFER*)pShader->pLinkConstBufferInfo;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]834 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]835 pid_enum.append(' }')
836 pid_enum.append(' }')
837 pid_enum.append(' }')
838 pid_enum.append('}\n')
839 pid_enum.append('//=============================================================================')
840 return "\n".join(pid_enum)
841
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]842 # Interpret functions used on replay to read in packets and interpret their contents
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]843 # This code gets generated into glv_vk_vk_structs.h file
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]844 def _generate_interp_funcs(self):
845 # 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]846 # 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
Jon Ashburn29669a42015-04-04 14:52:07 -0600[diff] [blame]847 custom_case_dict = { 'CreateInstance' : {'param': 'pCreateInfo', 'txt': ['XGL_INSTANCE_CREATE_INFO *pInfo = (XGL_INSTANCE_CREATE_INFO *) pPacket->pCreateInfo;\n',
848 'XGL_APPLICATION_INFO **ppAppInfo = (XGL_APPLICATION_INFO**) &pInfo->pAppInfo;\n',
849 '*ppAppInfo = (XGL_APPLICATION_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t) pInfo->pAppInfo);\n',
850 '(*ppAppInfo)->pAppName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(*ppAppInfo)->pAppName);\n',
851 '(*ppAppInfo)->pEngineName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(*ppAppInfo)->pEngineName);',
852 'if (pInfo->extensionCount > 0)\n',
853 '{',
854 ' pInfo->ppEnabledExtensionNames = (const char *const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->ppEnabledExtensionNames);\n',
855 ' const char **pNames = (const char**)pInfo->ppEnabledExtensionNames;\n',
856 ' uint32_t i;\n'
857 ' for (i = 0; i < pInfo->extensionCount; i++)\n',
858 ' {\n',
859 ' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pInfo->ppEnabledExtensionNames[i]));\n',
860 ' }\n',
861 '}']},
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]862 'CreateShader' : {'param': 'pCreateInfo', 'txt': ['XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;\n',
863 'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
Jon Ashburn8e7dcd02015-02-04 08:50:35 -0700[diff] [blame]864 'CreateDynamicViewportState' : {'param': 'pCreateInfo', 'txt': ['XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInfo = (XGL_DYNAMIC_VP_STATE_CREATE_INFO*)pPacket->pCreateInfo;\n',
865 'pInfo->pViewports = (XGL_VIEWPORT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pViewports);\n',
866 '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]867 'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['XGL_FRAMEBUFFER_CREATE_INFO* pInfo = (XGL_FRAMEBUFFER_CREATE_INFO*)pPacket->pCreateInfo;\n',
868 'pInfo->pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',
869 'pInfo->pDepthStencilAttachment = (XGL_DEPTH_STENCIL_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},
870 'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': ['XGL_RENDER_PASS_CREATE_INFO* pInfo = (XGL_RENDER_PASS_CREATE_INFO*)pPacket->pCreateInfo;\n',
Jon Ashburn615b6ce2015-03-09 12:39:26 -0600[diff] [blame]871 'pInfo->pColorFormats = (XGL_FORMAT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorFormats);\n',
872 'pInfo->pColorLayouts = (XGL_IMAGE_LAYOUT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLayouts);\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]873 'pInfo->pColorLoadOps = (XGL_ATTACHMENT_LOAD_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadOps);\n',
874 'pInfo->pColorStoreOps = (XGL_ATTACHMENT_STORE_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorStoreOps);\n',
875 'pInfo->pColorLoadClearValues = (XGL_CLEAR_COLOR*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadClearValues);\n']},
Jon Ashburn8f831ab2015-03-30 09:11:02 -0600[diff] [blame]876 'CreateDescriptorPool' : {'param': 'pCreateInfo', 'txt': ['XGL_DESCRIPTOR_POOL_CREATE_INFO* pInfo = (XGL_DESCRIPTOR_POOL_CREATE_INFO*)pPacket->pCreateInfo;\n',
Jon Ashburnfb3769a2015-02-04 09:32:59 -0700[diff] [blame]877 '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]878 'CmdWaitEvents' : {'param': 'pWaitInfo', 'txt': ['XGL_EVENT_WAIT_INFO* pInfo = (XGL_EVENT_WAIT_INFO*)pPacket->pWaitInfo;\n',
879 'pInfo->pEvents = (XGL_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->pEvents);\n',
880 'pInfo->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->ppMemBarriers);\n',
881 'uint32_t i;\n',
882 'for (i = 0; i < pInfo->memBarrierCount; i++) {\n',
883 ' void** ppLocalMemBarriers = (void**)&pInfo->ppMemBarriers[i];\n',
884 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->ppMemBarriers[i]);\n',
885 '}']},
886 'CmdPipelineBarrier' : {'param': 'pBarrier', 'txt': ['XGL_PIPELINE_BARRIER* pBarrier = (XGL_PIPELINE_BARRIER*)pPacket->pBarrier;\n',
Courtney Goeltzenleuchteraa86e0e2015-03-24 18:02:34 -0600[diff] [blame]887 'pBarrier->pEvents = (XGL_PIPE_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->pEvents);\n',
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]888 'pBarrier->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->ppMemBarriers);\n',
889 'uint32_t i;\n',
890 'for (i = 0; i < pBarrier->memBarrierCount; i++) {\n',
891 ' void** ppLocalMemBarriers = (void**)&pBarrier->ppMemBarriers[i];\n',
892 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pBarrier->ppMemBarriers[i]);\n',
893 '}']},
Jon Ashburnce82f362015-03-30 15:21:10 -0600[diff] [blame]894 'CreateDescriptorSetLayout' : {'param': 'pCreateInfo', 'txt': ['if (pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) {\n',
895 ' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pPacket->pCreateInfo;\n',
896 ' do\n', ' {\n',
897 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
898 ' void** ppNextVoidPtr = (void**)&(pNext->pNext);\n',
899 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]900 ' switch(pNext->sType)\n', ' {\n',
901 ' case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:\n',
902 ' {\n' ,
Jon Ashburnce82f362015-03-30 15:21:10 -0600[diff] [blame]903 ' XGL_DESCRIPTOR_SET_LAYOUT_BINDING** ppBinding = (XGL_DESCRIPTOR_SET_LAYOUT_BINDING**)&pNext->pBinding;\n',
904 ' *ppBinding = (XGL_DESCRIPTOR_SET_LAYOUT_BINDING*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pBinding);\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]905 ' break;\n',
906 ' }\n',
907 ' default:\n',
908 ' {\n',
909 ' glv_LogError("Encountered an unexpected type in descriptor set layout create list.\\n");\n',
910 ' pPacket->header = NULL;\n',
911 ' pNext->pNext = NULL;\n',
912 ' }\n',
Jon Ashburn7fd7eff2015-02-04 10:55:47 -0700[diff] [blame]913 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]914 ' pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pNext->pNext;\n',
Jon Ashburnce82f362015-03-30 15:21:10 -0600[diff] [blame]915 ' } while (NULL != pNext);\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]916 '} else {\n',
917 ' // This is unexpected.\n',
918 ' glv_LogError("CreateDescriptorSetLayout must have LayoutInfoList stype of XGL_STRCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO\\n");\n',
919 ' pPacket->header = NULL;\n',
Jon Ashburn7fd7eff2015-02-04 10:55:47 -0700[diff] [blame]920 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]921 'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['if (pPacket->pBeginInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO) {\n',
922 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
923 ' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO** ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO**)&(pPacket->pBeginInfo->pNext);\n',
924 ' *ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',
925 ' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pNext = *ppNext;\n',
926 ' while (NULL != pNext)\n', ' {\n',
927 ' switch(pNext->sType)\n', ' {\n',
928 ' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:\n',
929 ' {\n',
930 ' ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO**) &pNext->pNext;\n',
931 ' *ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
932 ' break;\n',
933 ' }\n',
934 ' default:\n',
935 ' {\n',
936 ' glv_LogError("Encountered an unexpected type in begin command buffer list.\\n");\n',
937 ' pPacket->header = NULL;\n',
938 ' pNext->pNext = NULL;\n',
939 ' }\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]940 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]941 ' pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pNext->pNext;\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]942 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]943 '} else {\n',
944 ' // This is unexpected.\n',
945 ' glv_LogError("BeginCommandBuffer must have BeginInfo stype of XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO.\\n");\n',
946 ' pPacket->header = NULL;\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]947 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]948 'AllocMemory' : {'param': 'pAllocInfo', 'txt': ['if (pPacket->pAllocInfo->sType == XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO) {\n',
949 ' XGL_MEMORY_ALLOC_INFO** ppNext = (XGL_MEMORY_ALLOC_INFO**) &(pPacket->pAllocInfo->pNext);\n',
950 ' *ppNext = (XGL_MEMORY_ALLOC_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocInfo->pNext);\n',
951 ' XGL_MEMORY_ALLOC_INFO* pNext = (XGL_MEMORY_ALLOC_INFO*) *ppNext;\n',
952 ' while (NULL != pNext)\n', ' {\n',
953 ' switch(pNext->sType)\n', ' {\n',
954 ' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:\n',
955 ' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:\n',
956 ' {\n',
957 ' ppNext = (XGL_MEMORY_ALLOC_INFO **) &(pNext->pNext);\n',
958 ' *ppNext = (XGL_MEMORY_ALLOC_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
959 ' break;\n',
960 ' }\n',
961 ' default:\n',
962 ' {\n',
963 ' glv_LogError("Encountered an unexpected type alloc memory list.\\n");\n',
964 ' pPacket->header = NULL;\n',
965 ' pNext->pNext = NULL;\n',
966 ' }\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]967 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]968 ' pNext = (XGL_MEMORY_ALLOC_INFO*)pNext->pNext;\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]969 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]970 '} else {\n',
971 ' // This is unexpected.\n',
972 ' glv_LogError("AllocMemory must have AllocInfo stype of XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO.\\n");\n',
973 ' pPacket->header = NULL;\n',
Jon Ashburn3039e9c2015-02-03 07:33:48 -0700[diff] [blame]974 '}']},
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]975 'UpdateDescriptors' : {'param': 'ppUpdateArray', 'txt': ['size_t i;\n',
976 'for (i = 0; i < pPacket->updateCount; i++)\n', '{\n',
977 ' XGL_UPDATE_SAMPLERS** ppUpItem = (XGL_UPDATE_SAMPLERS**) &pPacket->ppUpdateArray[i];\n',
978 ' *ppUpItem = (XGL_UPDATE_SAMPLERS *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t) pPacket->ppUpdateArray[i]);\n',
979 ' XGL_UPDATE_SAMPLERS* pNext = *ppUpItem;\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]980 ' switch(pNext->sType)\n', ' {\n',
981 ' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:\n',
982 ' {\n',
983 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
984 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
985 ' break;\n',
986 ' }\n',
987 ' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:\n',
988 ' {\n',
989 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
990 ' XGL_UPDATE_SAMPLERS* pUS = (XGL_UPDATE_SAMPLERS*)pNext;\n',
991 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
992 ' pUS->pSamplers = (XGL_SAMPLER*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUS->pSamplers);\n',
993 ' break;\n',
994 ' }\n',
995 ' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:\n',
996 ' {\n',
997 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
998 ' XGL_UPDATE_SAMPLER_TEXTURES* pUST = (XGL_UPDATE_SAMPLER_TEXTURES*)pNext;\n',
999 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1000 ' pUST->pSamplerImageViews = (XGL_SAMPLER_IMAGE_VIEW_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews);\n',
1001 ' uint32_t i;\n',
1002 ' for (i = 0; i < pUST->count; i++) {\n',
1003 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUST->pSamplerImageViews[i].pImageView;\n',
1004 ' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews[i].pImageView);\n',
1005 ' }\n',
1006 ' break;\n',
1007 ' }\n',
1008 ' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:\n',
1009 ' {\n',
1010 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1011 ' XGL_UPDATE_IMAGES* pUI = (XGL_UPDATE_IMAGES*)pNext;\n',
1012 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1013 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUI->pImageViews;\n',
1014 ' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews);\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1015 ' break;\n',
1016 ' }\n',
1017 ' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:\n',
1018 ' {\n',
1019 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1020 ' XGL_UPDATE_BUFFERS* pUB = (XGL_UPDATE_BUFFERS*)pNext;\n',
1021 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburn755ad032015-02-04 16:26:30 -0700[diff] [blame]1022 ' XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO**)&pUB->pBufferViews;\n',
1023 ' *ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews);\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1024 ' break;\n',
1025 ' }\n',
1026 ' default:\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1027 ' {\n',
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1028 ' glv_LogError("Encountered an unexpected type in update descriptors ppUpdateArray.\\n");\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1029 ' pPacket->header = NULL;\n',
1030 ' pNext->pNext = NULL;\n',
1031 ' }\n',
Tobin Ehlis9570fc42015-02-04 10:53:31 -0700[diff] [blame]1032 ' }\n',
1033 ' pNext = (XGL_UPDATE_SAMPLERS*)pNext->pNext;\n',
1034 '}']},
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1035 'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['if (pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) {\n',
1036 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1037 ' void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',
1038 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',
1039 ' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n',
1040 ' while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
1041 ' switch(pNext->sType)\n', ' {\n',
1042 ' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',
1043 ' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',
1044 ' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',
1045 ' case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',
1046 ' case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',
1047 ' case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',
1048 ' {\n',
1049 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1050 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1051 ' break;\n',
1052 ' }\n',
1053 ' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',
1054 ' {\n',
1055 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1056 ' XGL_PIPELINE_CB_STATE_CREATE_INFO *pCb = (XGL_PIPELINE_CB_STATE_CREATE_INFO *) pNext;\n',
1057 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1058 ' pCb->pAttachments = (XGL_PIPELINE_CB_ATTACHMENT_STATE*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pCb->pAttachments);\n',
1059 ' break;\n',
1060 ' }\n',
1061 ' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',
1062 ' {\n',
1063 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1064 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1065 ' interpret_pipeline_shader(pHeader, &pNext->shader);\n',
1066 ' break;\n',
1067 ' }\n',
1068 ' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',
1069 ' {\n',
1070 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1071 ' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',
1072 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1073 ' pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',
1074 ' pVi->pVertexAttributeDescriptions = (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',
1075 ' break;\n',
1076 ' }\n',
1077 ' default:\n',
1078 ' {\n',
1079 ' glv_LogError("Encountered an unexpected type in pipeline state list.\\n");\n',
1080 ' pPacket->header = NULL;\n',
1081 ' pNext->pNext = NULL;\n',
1082 ' }\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1083 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1084 ' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1085 ' }\n',
Peter Lohrmann78109572015-03-10 15:30:36 -0700[diff] [blame]1086 '} else {\n',
1087 ' // This is unexpected.\n',
1088 ' glv_LogError("CreateGraphicsPipeline must have CreateInfo stype of XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.\\n");\n',
1089 ' pPacket->header = NULL;\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1090 '}']},
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -0600[diff] [blame]1091 'CreateGraphicsPipelineDerivative' : {'param': 'pCreateInfo', 'txt': ['if (pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) {\n',
1092 ' // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1093 ' void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',
1094 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',
1095 ' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n',
1096 ' while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
1097 ' switch(pNext->sType)\n', ' {\n',
1098 ' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',
1099 ' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',
1100 ' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',
1101 ' case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',
1102 ' case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',
1103 ' case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',
1104 ' {\n',
1105 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1106 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1107 ' break;\n',
1108 ' }\n',
1109 ' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',
1110 ' {\n',
1111 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1112 ' XGL_PIPELINE_CB_STATE_CREATE_INFO *pCb = (XGL_PIPELINE_CB_STATE_CREATE_INFO *) pNext;\n',
1113 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1114 ' pCb->pAttachments = (XGL_PIPELINE_CB_ATTACHMENT_STATE*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pCb->pAttachments);\n',
1115 ' break;\n',
1116 ' }\n',
1117 ' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',
1118 ' {\n',
1119 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1120 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1121 ' interpret_pipeline_shader(pHeader, &pNext->shader);\n',
1122 ' break;\n',
1123 ' }\n',
1124 ' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',
1125 ' {\n',
1126 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1127 ' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',
1128 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1129 ' pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',
1130 ' pVi->pVertexAttributeDescriptions = (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',
1131 ' break;\n',
1132 ' }\n',
1133 ' default:\n',
1134 ' {\n',
1135 ' glv_LogError("Encountered an unexpected type in pipeline state list.\\n");\n',
1136 ' pPacket->header = NULL;\n',
1137 ' pNext->pNext = NULL;\n',
1138 ' }\n',
1139 ' }\n',
1140 ' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',
1141 ' }\n',
1142 '} else {\n',
1143 ' // This is unexpected.\n',
1144 ' glv_LogError("CreateGraphicsPipelineDerivative must have CreateInfo stype of XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.\\n");\n',
1145 ' pPacket->header = NULL;\n',
1146 '}']},
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1147 'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));']}}
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1148 if_body = []
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1149 if_body.append('typedef struct struct_xglApiVersion {')
1150 if_body.append(' glv_trace_packet_header* header;')
1151 if_body.append(' uint32_t version;')
1152 if_body.append('} struct_xglApiVersion;\n')
1153 if_body.append('static struct_xglApiVersion* interpret_body_as_xglApiVersion(glv_trace_packet_header* pHeader, BOOL check_version)')
1154 if_body.append('{')
1155 if_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)pHeader->pBody;')
1156 if_body.append(' pPacket->header = pHeader;')
1157 if_body.append(' if (check_version && pPacket->version != XGL_API_VERSION)')
1158 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);')
1159 if_body.append(' return pPacket;')
1160 if_body.append('}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1161 for proto in self.protos:
1162 if 'Wsi' not in proto.name and 'Dbg' not in proto.name:
1163 if 'UnmapMemory' == proto.name:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1164 proto.params.append(xgl.Param("void*", "pData"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1165 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1166 if_body.append(' glv_trace_packet_header* header;')
1167 for p in proto.params:
1168 if '[4]' in p.ty:
1169 if_body.append(' %s %s[4];' % (p.ty.strip('[4]'), p.name))
1170 else:
1171 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1172 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1173 if_body.append(' %s result;' % proto.ret)
1174 if_body.append('} struct_xgl%s;\n' % proto.name)
1175 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1176 if_body.append('{')
1177 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1178 if_body.append(' pPacket->header = pHeader;')
1179 for p in proto.params:
1180 if '*' in p.ty:
1181 if 'DEVICE_CREATE_INFO' in p.ty:
1182 if_body.append(' pPacket->%s = interpret_XGL_DEVICE_CREATE_INFO(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))
1183 else:
1184 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]1185 # TODO : Generalize this custom code to kill dict data struct above.
1186 # 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]1187 if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
1188 if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])
1189 if_body.append(' {')
1190 if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))
1191 if_body.append(' }')
1192 if_body.append(' return pPacket;')
1193 if_body.append('}\n')
1194 return "\n".join(if_body)
1195
1196 def _generate_interp_funcs_ext(self, func_class='Wsi'):
1197 if_body = []
1198 for proto in self.protos:
1199 if func_class in proto.name:
1200 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1201 if_body.append(' glv_trace_packet_header* pHeader;')
1202 for p in proto.params:
1203 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1204 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1205 if_body.append(' %s result;' % proto.ret)
1206 if_body.append('} struct_xgl%s;\n' % proto.name)
1207 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1208 if_body.append('{')
1209 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1210 if_body.append(' pPacket->pHeader = pHeader;')
1211 for p in proto.params:
1212 if '*' in p.ty:
1213 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
1214 if_body.append(' return pPacket;')
1215 if_body.append('}\n')
1216 return "\n".join(if_body)
1217
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1218 def _generate_replay_func_ptrs(self):
1219 xf_body = []
1220 xf_body.append('struct xglFuncs {')
1221 xf_body.append(' void init_funcs(void * libHandle);')
1222 xf_body.append(' void *m_libHandle;\n')
1223 for proto in self.protos:
1224 xf_body.append(' typedef %s( XGLAPI * type_xgl%s)(' % (proto.ret, proto.name))
1225 for p in proto.params:
1226 if '[4]' in p.ty:
1227 xf_body.append(' %s %s[4],' % (p.ty.strip('[4]'), p.name))
1228 else:
1229 xf_body.append(' %s %s,' % (p.ty, p.name))
1230 xf_body[-1] = xf_body[-1].replace(',', ');')
1231 xf_body.append(' type_xgl%s real_xgl%s;' % (proto.name, proto.name))
1232 xf_body.append('};')
1233 return "\n".join(xf_body)
1234
1235 def _map_decl(self, type1, type2, name):
1236 return ' std::map<%s, %s> %s;' % (type1, type2, name)
1237
1238 def _add_to_map_decl(self, type1, type2, name):
1239 txt = ' void add_to_map(%s* pTraceVal, %s* pReplayVal)\n {\n' % (type1, type2)
1240 txt += ' assert(pTraceVal != NULL);\n'
1241 txt += ' assert(pReplayVal != NULL);\n'
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1242 txt += ' %s[*pTraceVal] = *pReplayVal;\n }\n' % name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1243 return txt
1244
1245 def _rm_from_map_decl(self, ty, name):
1246 txt = ' void rm_from_map(const %s& key)\n {\n' % (ty)
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1247 txt += ' %s.erase(key);\n }\n' % name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1248 return txt
1249
1250 def _remap_decl(self, ty, name):
1251 txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)
1252 txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1253 txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }\n' % name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1254 return txt
1255
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1256 def _generate_replay_objMemory_funcs(self):
1257 rof_body = []
1258 # Custom code for memory mapping functions for app writes into mapped memory
1259 rof_body.append('// memory mapping functions for app writes into mapped memory')
1260 rof_body.append(' bool isPendingAlloc()')
1261 rof_body.append(' {')
1262 rof_body.append(' return m_pendingAlloc;')
1263 rof_body.append(' }')
1264 rof_body.append('')
1265 rof_body.append(' void setAllocInfo(const XGL_MEMORY_ALLOC_INFO *info, const bool pending)')
1266 rof_body.append(' {')
1267 rof_body.append(' m_pendingAlloc = pending;')
1268 rof_body.append(' m_allocInfo = *info;')
1269 rof_body.append(' }')
1270 rof_body.append('')
1271 rof_body.append(' void setMemoryDataAddr(void *pBuf)')
1272 rof_body.append(' {')
1273 rof_body.append(' if (m_mapRange.empty())')
1274 rof_body.append(' {')
1275 rof_body.append(' glv_LogError("gpuMemory::setMemoryDataAddr() m_mapRange is empty\\n");')
1276 rof_body.append(' return;')
1277 rof_body.append(' }')
1278 rof_body.append(' MapRange mr = m_mapRange.back();')
1279 rof_body.append(' if (mr.pData != NULL)')
1280 rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() data already mapped overwrite old mapping\\n");')
1281 rof_body.append(' else if (pBuf == NULL)')
1282 rof_body.append(' glv_LogWarn("gpuMemory::setMemoryDataAddr() adding NULL pointer\\n");')
1283 rof_body.append(' mr.pData = pBuf;')
1284 rof_body.append(' }')
1285 rof_body.append('')
1286 rof_body.append(' void setMemoryMapRange(void *pBuf, const size_t size, const size_t offset, const bool pending)')
1287 rof_body.append(' {')
1288 rof_body.append(' MapRange mr;')
1289 rof_body.append(' mr.pData = pBuf;')
1290 rof_body.append(' mr.size = size;')
1291 rof_body.append(' mr.offset = offset;')
1292 rof_body.append(' mr.pending = pending;')
1293 rof_body.append(' m_mapRange.push_back(mr);')
1294 rof_body.append(' }')
1295 rof_body.append('')
1296 rof_body.append(' void copyMappingData(const void* pSrcData)')
1297 rof_body.append(' {')
1298 rof_body.append(' if (m_mapRange.empty())')
1299 rof_body.append(' {')
1300 rof_body.append(' glv_LogError("gpuMemory::copyMappingData() m_mapRange is empty\\n");')
1301 rof_body.append(' return;')
1302 rof_body.append(' }')
1303 rof_body.append(' MapRange mr = m_mapRange.back();')
1304 rof_body.append(' if (!pSrcData || !mr.pData)')
1305 rof_body.append(' {')
1306 rof_body.append(' if (!pSrcData)')
1307 rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null src pointer\\n");')
1308 rof_body.append(' else')
1309 rof_body.append(' glv_LogError("gpuMemory::copyMappingData() null dest pointer size=%u\\n", m_allocInfo.allocationSize);')
1310 rof_body.append(' m_mapRange.pop_back();')
1311 rof_body.append(' return;')
1312 rof_body.append(' }')
1313 rof_body.append(' memcpy(mr.pData, pSrcData, m_allocInfo.allocationSize);')
1314 rof_body.append(' if (!mr.pending)')
1315 rof_body.append(' m_mapRange.pop_back();')
1316 rof_body.append(' }')
1317 rof_body.append('')
1318 rof_body.append(' size_t getMemoryMapSize()')
1319 rof_body.append(' {')
1320 rof_body.append(' return (!m_mapRange.empty()) ? m_mapRange.back().size : 0;')
1321 rof_body.append(' }\n')
1322 return "\n".join(rof_body)
1323
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1324 def _generate_replay_objmapper_class(self):
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1325 # Create dict mapping member var names to XGL type (i.e. 'm_imageViews' : 'XGL_IMAGE_VIEW')
1326 obj_map_dict = {}
1327 for ty in xgl.object_type_list:
1328 if ty in xgl.object_parent_list:
1329 continue
1330 mem_var = ty.replace('XGL_', '').lower()
1331 mem_var_list = mem_var.split('_')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1332 mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))
1333 obj_map_dict[mem_var] = ty
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1334 rc_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1335 rc_body.append('typedef struct _XGLAllocInfo {')
1336 rc_body.append(' XGL_GPU_SIZE size;')
1337 rc_body.append(' void *pData;')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1338 rc_body.append('} XGLAllocInfo;')
1339 rc_body.append('')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1340 rc_body.append('class objMemory {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1341 rc_body.append('public:')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1342 rc_body.append(' objMemory() : m_numAllocations(0), m_pMemReqs(NULL) {}')
1343 rc_body.append(' ~objMemory() { free(m_pMemReqs);}')
1344 rc_body.append(' void setCount(const uint32_t num)')
1345 rc_body.append(' {')
1346 rc_body.append(' m_numAllocations = num;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1347 rc_body.append(' }\n')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1348 rc_body.append(' void setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num)')
1349 rc_body.append(' {')
1350 rc_body.append(' if (m_numAllocations != num && m_numAllocations != 0)')
1351 rc_body.append(' glv_LogError("objMemory::setReqs, internal mismatch on number of allocations");')
1352 rc_body.append(' if (m_pMemReqs == NULL && pReqs != NULL)')
1353 rc_body.append(' {')
1354 rc_body.append(' m_pMemReqs = (XGL_MEMORY_REQUIREMENTS *) glv_malloc(num * sizeof(XGL_MEMORY_REQUIREMENTS));')
1355 rc_body.append(' if (m_pMemReqs == NULL)')
1356 rc_body.append(' {')
1357 rc_body.append(' glv_LogError("objMemory::setReqs out of memory");')
1358 rc_body.append(' return;')
1359 rc_body.append(' }')
1360 rc_body.append(' memcpy(m_pMemReqs, pReqs, num);')
1361 rc_body.append(' }')
1362 rc_body.append(' }\n')
1363 rc_body.append('private:')
1364 rc_body.append(' uint32_t m_numAllocations;')
1365 rc_body.append(' XGL_MEMORY_REQUIREMENTS *m_pMemReqs;')
1366 rc_body.append('};')
1367 rc_body.append('')
1368 rc_body.append('class gpuMemory {')
1369 rc_body.append('public:')
1370 rc_body.append(' gpuMemory() : m_pendingAlloc(false) {m_allocInfo.allocationSize = 0;}')
1371 rc_body.append(' ~gpuMemory() {}')
1372 rc_body.append(self._generate_replay_objMemory_funcs())
1373# rc_body.append(' bool isPendingAlloc();')
1374# rc_body.append(' void setAllocInfo(const XGL_MEMORY_ALLOC_INFO *info, const bool pending);')
1375# rc_body.append(' void setMemoryDataAddr(void* pBuf);')
1376# rc_body.append(' void setMemoryMapRange(void* pBuf, const size_t size, const size_t offset, const bool pending);')
1377# rc_body.append(' void copyMappingData(const void *pSrcData);')
1378# rc_body.append(' size_t getMemoryMapSize();')
1379 rc_body.append('private:')
1380 rc_body.append(' bool m_pendingAlloc;')
1381 rc_body.append(' struct MapRange {')
1382 rc_body.append(' bool pending;')
1383 rc_body.append(' size_t size;')
1384 rc_body.append(' size_t offset;')
1385 rc_body.append(' void* pData;')
1386 rc_body.append(' };')
1387 rc_body.append(' std::vector<MapRange> m_mapRange;')
1388 rc_body.append(' XGL_MEMORY_ALLOC_INFO m_allocInfo;')
1389 rc_body.append('};')
1390 rc_body.append('')
1391 rc_body.append('typedef struct _imageObj {')
1392 rc_body.append(' objMemory imageMem;')
1393 rc_body.append(' XGL_IMAGE replayImage;')
1394 rc_body.append(' } imageObj;')
1395 rc_body.append('')
1396 rc_body.append('typedef struct _bufferObj {')
1397 rc_body.append(' objMemory bufferMem;')
1398 rc_body.append(' XGL_BUFFER replayBuffer;')
1399 rc_body.append(' } bufferObj;')
1400 rc_body.append('')
1401 rc_body.append('typedef struct _gpuMemObj {')
1402 rc_body.append(' gpuMemory *pGpuMem;')
1403 rc_body.append(' XGL_GPU_MEMORY replayGpuMem;')
1404 rc_body.append(' } gpuMemObj;')
1405 rc_body.append('')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1406 rc_body.append('class xglReplayObjMapper {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1407 rc_body.append('public:')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1408 rc_body.append(' xglReplayObjMapper() {}')
1409 rc_body.append(' ~xglReplayObjMapper() {}')
1410 rc_body.append('')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1411 rc_body.append(' bool m_adjustForGPU; // true if replay adjusts behavior based on GPU')
1412 # Code for memory objects for handling replay GPU != trace GPU object memory requirements
1413 rc_body.append(' void init_objMemCount(const XGL_BASE_OBJECT& object, const uint32_t &num)\n {')
1414 rc_body.append(' XGL_IMAGE img = static_cast <XGL_IMAGE> (object);')
1415 rc_body.append(' std::map<XGL_IMAGE, imageObj>::const_iterator it = m_images.find(img);')
1416 rc_body.append(' if (it != m_images.end())')
1417 rc_body.append(' {')
1418 rc_body.append(' objMemory obj = it->second.imageMem;')
1419 rc_body.append(' obj.setCount(num);')
1420 rc_body.append(' return;')
1421 rc_body.append(' }')
1422 rc_body.append(' XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);')
1423 rc_body.append(' std::map<XGL_BUFFER, bufferObj>::const_iterator itb = m_buffers.find(buf);')
1424 rc_body.append(' if (itb != m_buffers.end())')
1425 rc_body.append(' {')
1426 rc_body.append(' objMemory obj = itb->second.bufferMem;')
1427 rc_body.append(' obj.setCount(num);')
1428 rc_body.append(' return;')
1429 rc_body.append(' }')
1430 rc_body.append(' return;')
1431 rc_body.append(' }\n')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1432 rc_body.append(' void init_objMemReqs(const XGL_BASE_OBJECT& object, const XGL_MEMORY_REQUIREMENTS *pMemReqs, const unsigned int num)\n {')
1433 rc_body.append(' XGL_IMAGE img = static_cast <XGL_IMAGE> (object);')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1434 rc_body.append(' std::map<XGL_IMAGE, imageObj>::const_iterator it = m_images.find(img);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1435 rc_body.append(' if (it != m_images.end())')
1436 rc_body.append(' {')
1437 rc_body.append(' objMemory obj = it->second.imageMem;')
1438 rc_body.append(' obj.setReqs(pMemReqs, num);')
1439 rc_body.append(' return;')
1440 rc_body.append(' }')
1441 rc_body.append(' XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1442 rc_body.append(' std::map<XGL_BUFFER, bufferObj>::const_iterator itb = m_buffers.find(buf);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1443 rc_body.append(' if (itb != m_buffers.end())')
1444 rc_body.append(' {')
1445 rc_body.append(' objMemory obj = itb->second.bufferMem;')
1446 rc_body.append(' obj.setReqs(pMemReqs, num);')
1447 rc_body.append(' return;')
1448 rc_body.append(' }')
1449 rc_body.append(' return;')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1450 rc_body.append(' }')
1451 rc_body.append('')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1452 rc_body.append(' void clear_all_map_handles()\n {')
1453 for var in sorted(obj_map_dict):
1454 rc_body.append(' %s.clear();' % var)
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1455 rc_body.append(' }\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1456 for var in sorted(obj_map_dict):
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1457 if obj_map_dict[var] == 'XGL_IMAGE':
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1458 rc_body.append(self._map_decl(obj_map_dict[var], 'imageObj', var))
1459 rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'imageObj', var))
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1460 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1461 rc_body.append(' XGL_IMAGE remap(const XGL_IMAGE& value)')
1462 rc_body.append(' {')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1463 rc_body.append(' std::map<XGL_IMAGE, imageObj>::const_iterator q = m_images.find(value);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1464 rc_body.append(' return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second.replayImage;')
1465 rc_body.append(' }\n')
1466 elif obj_map_dict[var] == 'XGL_BUFFER':
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1467 rc_body.append(self._map_decl(obj_map_dict[var], 'bufferObj', var))
1468 rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'bufferObj', var))
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1469 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1470 rc_body.append(' XGL_BUFFER remap(const XGL_BUFFER& value)')
1471 rc_body.append(' {')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1472 rc_body.append(' std::map<XGL_BUFFER, bufferObj>::const_iterator q = m_buffers.find(value);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1473 rc_body.append(' return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second.replayBuffer;')
1474 rc_body.append(' }\n')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1475 elif obj_map_dict[var] == 'XGL_GPU_MEMORY':
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1476 rc_body.append(self._map_decl(obj_map_dict[var], 'gpuMemObj', var))
1477 rc_body.append(self._add_to_map_decl(obj_map_dict[var], 'gpuMemObj', var))
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1478 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1479 rc_body.append(' XGL_GPU_MEMORY remap(const XGL_GPU_MEMORY& value)')
1480 rc_body.append(' {')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1481 rc_body.append(' std::map<XGL_GPU_MEMORY, gpuMemObj>::const_iterator q = m_gpuMemorys.find(value);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1482 rc_body.append(' return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second.replayGpuMem;')
1483 rc_body.append(' }\n')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1484 else:
1485 rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))
1486 rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))
1487 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1488 rc_body.append(self._remap_decl(obj_map_dict[var], var))
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1489 # XGL_DYNAMIC_STATE_OBJECT code
1490 state_obj_remap_types = xgl.object_dynamic_state_list
1491 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
1492 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT obj;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1493 for t in state_obj_remap_types:
1494 rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != XGL_NULL_HANDLE)' % t)
1495 rc_body.append(' return obj;')
1496 rc_body.append(' return XGL_NULL_HANDLE;\n }')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1497 rc_body.append(' void rm_from_map(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1498 for t in state_obj_remap_types:
1499 rc_body.append(' rm_from_map(static_cast <%s> (state));' % t)
1500 rc_body.append(' }')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1501 rc_body.append('')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1502 # OBJECT code
1503 rc_body.append(' XGL_OBJECT remap(const XGL_OBJECT& object)\n {')
1504 rc_body.append(' XGL_OBJECT obj;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1505 obj_remap_types = xgl.object_list
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1506 for var in obj_remap_types:
1507 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % (var))
1508 rc_body.append(' return obj;')
1509 rc_body.append(' return XGL_NULL_HANDLE;\n }')
1510 rc_body.append(' void rm_from_map(const XGL_OBJECT & objKey)\n {')
1511 for var in obj_remap_types:
1512 rc_body.append(' rm_from_map(static_cast <%s> (objKey));' % (var))
1513 rc_body.append(' }')
1514 rc_body.append(' XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)\n {')
1515 rc_body.append(' XGL_BASE_OBJECT obj;')
1516 base_obj_remap_types = ['XGL_DEVICE', 'XGL_QUEUE', 'XGL_GPU_MEMORY', 'XGL_OBJECT']
1517 for t in base_obj_remap_types:
1518 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % t)
1519 rc_body.append(' return obj;')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1520 rc_body.append(' return XGL_NULL_HANDLE;')
Tony Barbourb30dcd42015-02-02 13:21:18 -0700[diff] [blame]1521 rc_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1522 rc_body.append('};')
1523 return "\n".join(rc_body)
1524
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1525 def _generate_replay_init_funcs(self):
1526 rif_body = []
1527 rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')
1528 for proto in self.protos:
1529 rif_body.append(' real_xgl%s = (type_xgl%s)(glv_platform_get_library_entrypoint(handle, "xgl%s"));' % (proto.name, proto.name, proto.name))
1530 rif_body.append('}')
1531 return "\n".join(rif_body)
1532
1533 def _get_packet_param(self, t, n):
1534 # list of types that require remapping
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1535 remap_list = xgl.object_type_list
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1536 param_exclude_list = ['p1', 'p2', 'pGpus', 'pDescriptorSets']
1537 if t.strip('*').replace('const ', '') in remap_list and n not in param_exclude_list:
1538 if '*' in t:
1539 if 'const ' not in t:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1540 return 'm_objMapper.remap(*pPacket->%s)' % (n)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1541 else: # TODO : Don't remap array ptrs?
1542 return 'pPacket->%s' % (n)
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1543 return 'm_objMapper.remap(pPacket->%s)' % (n)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1544 return 'pPacket->%s' % (n)
1545
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1546 def _gen_replay_enum_gpus(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1547 ieg_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1548 ieg_body.append(' returnValue = manually_handle_xglEnumerateGpus(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1549 return "\n".join(ieg_body)
1550
1551 def _gen_replay_get_gpu_info(self):
1552 ggi_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1553 ggi_body.append(' returnValue = manually_handle_xglGetGpuInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1554 return "\n".join(ggi_body)
1555
1556 def _gen_replay_create_device(self):
1557 cd_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1558 cd_body.append(' returnValue = manually_handle_xglCreateDevice(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1559 return "\n".join(cd_body)
1560
1561 def _gen_replay_get_extension_support(self):
1562 ges_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1563 ges_body.append(' returnValue = manually_handle_xglGetExtensionSupport(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1564 return "\n".join(ges_body)
1565
1566 def _gen_replay_queue_submit(self):
1567 qs_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1568 qs_body.append(' returnValue = manually_handle_xglQueueSubmit(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1569 return "\n".join(qs_body)
1570
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1571 def _gen_replay_get_object_info(self):
1572 goi_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1573 goi_body.append(' returnValue = manually_handle_xglGetObjectInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1574 return "\n".join(goi_body)
1575
1576 def _gen_replay_get_format_info(self):
1577 gfi_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1578 gfi_body.append(' returnValue = manually_handle_xglGetFormatInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1579 return "\n".join(gfi_body)
1580
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1581 def _gen_replay_create_image(self):
1582 ci_body = []
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1583 ci_body.append(' imageObj local_imageObj;')
1584 ci_body.append(' replayResult = m_xglFuncs.real_xglCreateImage(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_imageObj.replayImage);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1585 ci_body.append(' if (replayResult == XGL_SUCCESS)')
1586 ci_body.append(' {')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1587 ci_body.append(' m_objMapper.add_to_map(pPacket->pImage, &local_imageObj);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1588 ci_body.append(' }')
1589 return "\n".join(ci_body)
1590
1591 def _gen_replay_create_buffer(self):
1592 cb_body = []
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1593 cb_body.append(' bufferObj local_bufferObj;')
1594 cb_body.append(' replayResult = m_xglFuncs.real_xglCreateBuffer(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_bufferObj.replayBuffer);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1595 cb_body.append(' if (replayResult == XGL_SUCCESS)')
1596 cb_body.append(' {')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1597 cb_body.append(' m_objMapper.add_to_map(pPacket->pBuffer, &local_bufferObj);')
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1598 cb_body.append(' }')
1599 return "\n".join(cb_body)
1600
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1601 def _gen_replay_get_image_subresource_info(self):
1602 isi_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1603 isi_body.append(' returnValue = manually_handle_xglGetImageSubresourceInfo(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1604 return "\n".join(isi_body)
1605
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]1606 def _gen_replay_update_descriptors(self):
1607 ud_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1608 ud_body.append(' returnValue = manually_handle_xglUpdateDescriptors(pPacket);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1609 return "\n".join(ud_body)
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]1610
1611 def _gen_replay_create_descriptor_set_layout(self):
1612 cdsl_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1613 cdsl_body.append(' returnValue = manually_handle_xglCreateDescriptorSetLayout(pPacket);')
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1614 return "\n".join(cdsl_body)
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]1615
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1616 def _gen_replay_create_descriptor_set_layout_chain(self):
1617 cdslc_body = []
1618 cdslc_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CHAIN local_pLayoutChain;')
1619 cdslc_body.append(' XGL_DESCRIPTOR_SET_LAYOUT *saveSetLayoutArray = (XGL_DESCRIPTOR_SET_LAYOUT *) glv_malloc(pPacket->setLayoutArrayCount * sizeof(XGL_DESCRIPTOR_SET_LAYOUT));')
1620 cdslc_body.append(' XGL_DESCRIPTOR_SET_LAYOUT *pSetLayoutOrig = (XGL_DESCRIPTOR_SET_LAYOUT *) pPacket->pSetLayoutArray;')
1621 cdslc_body.append(' uint32_t i;')
1622 cdslc_body.append(' for (i = 0; i < pPacket->setLayoutArrayCount && pPacket->pSetLayoutArray != NULL; i++)')
1623 cdslc_body.append(' {')
1624 cdslc_body.append(' saveSetLayoutArray[i] = pPacket->pSetLayoutArray[i];')
Jon Ashburnba8ccb62015-04-01 13:30:06 -0600[diff] [blame]1625 cdslc_body.append(' *pSetLayoutOrig++ = m_objMapper.remap(pPacket->pSetLayoutArray[i]);')
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1626 cdslc_body.append(' }')
Jon Ashburnba8ccb62015-04-01 13:30:06 -0600[diff] [blame]1627 cdslc_body.append(' replayResult = m_xglFuncs.real_xglCreateDescriptorSetLayoutChain(m_objMapper.remap(pPacket->device), pPacket->setLayoutArrayCount, pPacket->pSetLayoutArray, &local_pLayoutChain);')
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1628 cdslc_body.append(' pSetLayoutOrig = (XGL_DESCRIPTOR_SET_LAYOUT *) pPacket->pSetLayoutArray;')
1629 cdslc_body.append(' for (i = 0; i < pPacket->setLayoutArrayCount && pPacket->pSetLayoutArray != NULL; i++)')
1630 cdslc_body.append(' {')
1631 cdslc_body.append(' *pSetLayoutOrig++ = saveSetLayoutArray[i];')
1632 cdslc_body.append(' }')
1633 cdslc_body.append(' if (replayResult == XGL_SUCCESS)')
1634 cdslc_body.append(' {')
Jon Ashburnba8ccb62015-04-01 13:30:06 -0600[diff] [blame]1635 cdslc_body.append(' m_objMapper.add_to_map(pPacket->pLayoutChain, &local_pLayoutChain);')
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1636 cdslc_body.append(' }')
1637 cdslc_body.append(' free(saveSetLayoutArray);')
1638 return "\n".join(cdslc_body)
1639
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1640 def _gen_replay_create_graphics_pipeline(self):
1641 cgp_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1642 cgp_body.append(' returnValue = manually_handle_xglCreateGraphicsPipeline(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1643 return "\n".join(cgp_body)
1644
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -0600[diff] [blame]1645 def _gen_replay_create_graphics_pipeline_derivative(self):
1646 cgp_body = []
1647 cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')
1648 cgp_body.append(' struct shaderPair saveShader[10];')
1649 cgp_body.append(' unsigned int idx = 0;')
1650 cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')
Jon Ashburnba8ccb62015-04-01 13:30:06 -0600[diff] [blame]1651 cgp_body.append(' createInfo.pSetLayoutChain = m_objMapper.remap(createInfo.pSetLayoutChain);')
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -0600[diff] [blame]1652 cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')
1653 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')
1654 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')
1655 cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')
1656 cgp_body.append(' {')
1657 cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')
1658 cgp_body.append(' {')
1659 cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')
1660 cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -0600[diff] [blame]1661 cgp_body.append(' pNext->shader.shader = m_objMapper.remap(pPacketNext->shader.shader);')
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -0600[diff] [blame]1662 cgp_body.append(' }')
1663 cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')
1664 cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')
1665 cgp_body.append(' }')
1666 cgp_body.append(' XGL_PIPELINE pipeline;')
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -0600[diff] [blame]1667 cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipelineDerivative(m_objMapper.remap(pPacket->device), &createInfo, m_objMapper.remap(pPacket->basePipeline), &pipeline);')
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -0600[diff] [blame]1668 cgp_body.append(' if (replayResult == XGL_SUCCESS)')
1669 cgp_body.append(' {')
Courtney Goeltzenleuchter9452ac22015-04-13 16:16:04 -0600[diff] [blame]1670 cgp_body.append(' m_objMapper.add_to_map(pPacket->pPipeline, &pipeline);')
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -0600[diff] [blame]1671 cgp_body.append(' }')
1672 cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')
1673 cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')
1674 return "\n".join(cgp_body)
1675
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1676 def _gen_replay_cmd_wait_events(self):
1677 cwe_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1678 cwe_body.append(' returnValue = manually_handle_xglCmdWaitEvents(pPacket);')
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1679 return "\n".join(cwe_body)
1680
Courtney Goeltzenleuchter29fb1502015-04-03 08:50:47 -0600[diff] [blame]1681 def _gen_replay_create_graphics_pipeline_derivative(self):
1682 cgp_body = []
1683 cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')
1684 cgp_body.append(' struct shaderPair saveShader[10];')
1685 cgp_body.append(' unsigned int idx = 0;')
1686 cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')
1687 cgp_body.append(' createInfo.pSetLayoutChain = m_objMapper.remap(createInfo.pSetLayoutChain);')
1688 cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')
1689 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')
1690 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')
1691 cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')
1692 cgp_body.append(' {')
1693 cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')
1694 cgp_body.append(' {')
1695 cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')
1696 cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')
1697 cgp_body.append(' pNext->shader.shader = m_objMapper.remap(pPacketNext->shader.shader);')
1698 cgp_body.append(' }')
1699 cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')
1700 cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')
1701 cgp_body.append(' }')
1702 cgp_body.append(' XGL_PIPELINE pipeline;')
1703 cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipelineDerivative(m_objMapper.remap(pPacket->device), &createInfo, m_objMapper.remap(pPacket->basePipeline), &pipeline);')
1704 cgp_body.append(' if (replayResult == XGL_SUCCESS)')
1705 cgp_body.append(' {')
1706 cgp_body.append(' m_objMapper.add_to_map(pPacket->pPipeline, &pipeline);')
1707 cgp_body.append(' }')
1708 cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')
1709 cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')
1710 return "\n".join(cgp_body)
1711
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1712 def _gen_replay_cmd_bind_descriptor_sets(self):
1713 cbds_body = []
1714 cbds_body.append(' XGL_DESCRIPTOR_SET *pSaveSets = (XGL_DESCRIPTOR_SET *) glv_malloc(sizeof(XGL_DESCRIPTOR_SET) * pPacket->count);')
1715 cbds_body.append(' if (pSaveSets == NULL)')
1716 cbds_body.append(' {')
1717 cbds_body.append(' glv_LogError("replay of CmdBindDescriptorSets out of memory\\n");')
1718 cbds_body.append(' }')
1719 cbds_body.append(' for (uint32_t idx = 0; idx < pPacket->count && pPacket->pDescriptorSets != NULL; idx++)')
1720 cbds_body.append(' {')
1721 cbds_body.append(' XGL_DESCRIPTOR_SET *pSet = (XGL_DESCRIPTOR_SET *) &(pPacket->pDescriptorSets[idx]);')
1722 cbds_body.append(' pSaveSets[idx] = pPacket->pDescriptorSets[idx];')
Jon Ashburnba8ccb62015-04-01 13:30:06 -0600[diff] [blame]1723 cbds_body.append(' *pSet = m_objMapper.remap(pPacket->pDescriptorSets[idx]);')
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1724 cbds_body.append(' }')
Jon Ashburnba8ccb62015-04-01 13:30:06 -0600[diff] [blame]1725 cbds_body.append(' m_xglFuncs.real_xglCmdBindDescriptorSets(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, m_objMapper.remap(pPacket->layoutChain), pPacket->layoutChainSlot, pPacket->count, pPacket->pDescriptorSets, pPacket->pUserData);')
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1726 cbds_body.append(' for (uint32_t idx = 0; idx < pPacket->count && pPacket->pDescriptorSets != NULL; idx++)')
1727 cbds_body.append(' {')
1728 cbds_body.append(' XGL_DESCRIPTOR_SET *pSet = (XGL_DESCRIPTOR_SET *) &(pPacket->pDescriptorSets[idx]);')
1729 cbds_body.append(' *pSet = pSaveSets[idx];')
1730 cbds_body.append(' }')
1731 cbds_body.append(' glv_free(pSaveSets);')
1732 return "\n".join(cbds_body)
1733
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]1734 def _gen_replay_cmd_pipeline_barrier(self):
1735 cpb_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1736 cpb_body.append(' returnValue = manually_handle_xglCmdPipelineBarrier(pPacket);')
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]1737 return "\n".join(cpb_body)
1738
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1739 def _gen_replay_create_framebuffer(self):
1740 cf_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1741 cf_body.append(' returnValue = manually_handle_xglCreateFramebuffer(pPacket);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1742 return "\n".join(cf_body)
1743
1744 def _gen_replay_create_renderpass(self):
1745 cr_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1746 cr_body.append(' returnValue = manually_handle_xglCreateRenderPass(pPacket);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1747 return "\n".join(cr_body)
1748
1749 def _gen_replay_begin_command_buffer(self):
1750 bcb_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1751 bcb_body.append(' returnValue = manually_handle_xglBeginCommandBuffer(pPacket);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1752 return "\n".join(bcb_body)
1753
Jon Ashburn615b6ce2015-03-09 12:39:26 -0600[diff] [blame]1754 def _gen_replay_begin_render_pass(self):
1755 cbrp_body = []
1756 cbrp_body.append(' XGL_RENDER_PASS_BEGIN savedRPB, *pRPB = (XGL_RENDER_PASS_BEGIN *) pPacket->pRenderPassBegin;')
1757 cbrp_body.append(' savedRPB = *(pPacket->pRenderPassBegin);')
Courtney Goeltzenleuchteraa86e0e2015-03-24 18:02:34 -0600[diff] [blame]1758 cbrp_body.append(' pRPB->renderPass = m_objMapper.remap(savedRPB.renderPass);')
1759 cbrp_body.append(' pRPB->framebuffer = m_objMapper.remap(savedRPB.framebuffer);')
1760 cbrp_body.append(' m_xglFuncs.real_xglCmdBeginRenderPass(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pRenderPassBegin);')
Jon Ashburn615b6ce2015-03-09 12:39:26 -0600[diff] [blame]1761 cbrp_body.append(' *pRPB = savedRPB;')
1762 return "\n".join(cbrp_body)
1763
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1764 def _gen_replay_store_pipeline(self):
1765 sp_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1766 sp_body.append(' returnValue = manually_handle_xglStorePipeline(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1767 return "\n".join(sp_body)
1768
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1769 def _gen_replay_get_multi_gpu_compatibility(self):
1770 gmgc_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1771 gmgc_body.append(' returnValue = manually_handle_xglGetMultiGpuCompatibility(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1772 return "\n".join(gmgc_body)
1773
1774 def _gen_replay_destroy_object(self):
1775 do_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1776 do_body.append(' returnValue = manually_handle_xglDestroyObject(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1777 return "\n".join(do_body)
1778
1779 def _gen_replay_wait_for_fences(self):
1780 wf_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1781 wf_body.append(' returnValue = manually_handle_xglWaitForFences(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1782 return "\n".join(wf_body)
1783
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500[diff] [blame]1784 def _gen_replay_reset_fences(self):
1785 wf_body = []
1786 wf_body.append(' XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);')
1787 wf_body.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')
1788 wf_body.append(' {')
1789 wf_body.append(' *(pFence + i) = m_objMapper.remap(*(pPacket->pFences + i));')
1790 wf_body.append(' }')
1791 wf_body.append(' replayResult = m_xglFuncs.real_xglResetFences(m_objMapper.remap(pPacket->device), pPacket->fenceCount, pFence);')
1792 wf_body.append(' GLV_DELETE(pFence);')
1793 return "\n".join(wf_body)
1794
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1795 def _gen_replay_wsi_associate_connection(self):
1796 wac_body = []
Peter Lohrmann95c369a2015-04-02 10:06:19 -0700[diff] [blame]1797 wac_body.append(' returnValue = manually_handle_xglWsiX11AssociateConnection(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1798 return "\n".join(wac_body)
1799
1800 def _gen_replay_wsi_get_msc(self):
1801 wgm_body = []
Peter Lohrmann95c369a2015-04-02 10:06:19 -0700[diff] [blame]1802 wgm_body.append(' returnValue = manually_handle_xglWsiX11GetMSC(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1803 return "\n".join(wgm_body)
1804
1805 def _gen_replay_wsi_create_presentable_image(self):
1806 cpi_body = []
Peter Lohrmann95c369a2015-04-02 10:06:19 -0700[diff] [blame]1807 cpi_body.append(' returnValue = manually_handle_xglWsiX11CreatePresentableImage(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1808 return "\n".join(cpi_body)
1809
1810 def _gen_replay_wsi_queue_present(self):
1811 wqp_body = []
Peter Lohrmann95c369a2015-04-02 10:06:19 -0700[diff] [blame]1812 wqp_body.append(' returnValue = manually_handle_xglWsiX11QueuePresent(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1813 return "\n".join(wqp_body)
1814
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1815 def _gen_replay_alloc_memory(self):
1816 am_body = []
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1817 am_body.append(' gpuMemObj local_mem;')
1818 am_body.append(' if (!m_objMapper.m_adjustForGPU)')
1819 am_body.append(' replayResult = m_xglFuncs.real_xglAllocMemory(m_objMapper.remap(pPacket->device), pPacket->pAllocInfo, &local_mem.replayGpuMem);')
1820 am_body.append(' if (replayResult == XGL_SUCCESS || m_objMapper.m_adjustForGPU)')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1821 am_body.append(' {')
Jon Ashburncce1cb52015-03-26 16:15:18 -0600[diff] [blame]1822 am_body.append(' local_mem.pGpuMem = new (gpuMemory);')
1823 am_body.append(' if (local_mem.pGpuMem)')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1824 am_body.append(' local_mem.pGpuMem->setAllocInfo(pPacket->pAllocInfo, m_objMapper.m_adjustForGPU);')
1825 am_body.append(' m_objMapper.add_to_map(pPacket->pMem, &local_mem);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1826 am_body.append(' }')
1827 return "\n".join(am_body)
1828
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1829 def _gen_replay_free_memory(self):
1830 fm_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1831 fm_body.append(' returnValue = manually_handle_xglFreeMemory(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1832 return "\n".join(fm_body)
1833
1834 def _gen_replay_map_memory(self):
1835 mm_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1836 mm_body.append(' returnValue = manually_handle_xglMapMemory(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1837 return "\n".join(mm_body)
1838
1839 def _gen_replay_unmap_memory(self):
1840 um_body = []
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1841 um_body.append(' returnValue = manually_handle_xglUnmapMemory(pPacket);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1842 return "\n".join(um_body)
1843
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1844 def _gen_replay_pin_system_memory(self):
1845 psm_body = []
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1846 psm_body.append(' gpuMemObj local_mem;')
Jon Ashburnd4daf592015-03-27 16:23:47 -0600[diff] [blame]1847 psm_body.append(' /* TODO do we need to skip (make pending) this call for m_adjustForGPU */')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1848 psm_body.append(' replayResult = m_xglFuncs.real_xglPinSystemMemory(m_objMapper.remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_mem.replayGpuMem);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1849 psm_body.append(' if (replayResult == XGL_SUCCESS)')
Peter Lohrmanne59ba282015-04-06 14:14:44 -0700[diff] [blame]1850 psm_body.append(' m_objMapper.add_to_map(pPacket->pMem, &local_mem);')
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1851 return "\n".join(psm_body)
1852
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]1853 # 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]1854 def _gen_replay_bind_dynamic_memory_view(self):
1855 bdmv_body = []
1856 bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')
1857 bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1858 bdmv_body.append(' memView.mem = m_objMapper.remap(pPacket->pMemView->mem);')
1859 bdmv_body.append(' m_xglFuncs.real_xglCmdBindDynamicMemoryView(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1860 return "\n".join(bdmv_body)
1861
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1862 # 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]1863 def _generate_replay(self):
1864 # map protos to custom functions if body is fully custom
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1865 custom_body_dict = {'EnumerateGpus': self._gen_replay_enum_gpus,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1866 'GetGpuInfo': self._gen_replay_get_gpu_info,
1867 'CreateDevice': self._gen_replay_create_device,
1868 'GetExtensionSupport': self._gen_replay_get_extension_support,
1869 'QueueSubmit': self._gen_replay_queue_submit,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1870 'GetObjectInfo': self._gen_replay_get_object_info,
1871 'GetFormatInfo': self._gen_replay_get_format_info,
Jon Ashburn7f8acc72015-03-23 09:27:33 -0600[diff] [blame]1872 'CreateImage': self._gen_replay_create_image,
1873 'CreateBuffer': self._gen_replay_create_buffer,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1874 'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,
1875 'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -0600[diff] [blame]1876 'CreateGraphicsPipelineDerivative': self._gen_replay_create_graphics_pipeline_derivative,
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1877 'CreateFramebuffer': self._gen_replay_create_framebuffer,
1878 'CreateRenderPass': self._gen_replay_create_renderpass,
1879 'BeginCommandBuffer': self._gen_replay_begin_command_buffer,
Jon Ashburn615b6ce2015-03-09 12:39:26 -0600[diff] [blame]1880 'CmdBeginRenderPass': self._gen_replay_begin_render_pass,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1881 'StorePipeline': self._gen_replay_store_pipeline,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1882 'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,
1883 'DestroyObject': self._gen_replay_destroy_object,
1884 'WaitForFences': self._gen_replay_wait_for_fences,
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500[diff] [blame]1885 'ResetFences': self._gen_replay_reset_fences,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1886 'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,
1887 'WsiX11GetMSC': self._gen_replay_wsi_get_msc,
1888 'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,
1889 'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1890 'AllocMemory': self._gen_replay_alloc_memory,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1891 'FreeMemory': self._gen_replay_free_memory,
1892 'MapMemory': self._gen_replay_map_memory,
1893 'UnmapMemory': self._gen_replay_unmap_memory,
Jon Ashburn16239cd2015-03-24 11:05:02 -0600[diff] [blame]1894 'PinSystemMemory': self._gen_replay_pin_system_memory,
Tobin Ehlis8361b562015-02-03 14:41:26 -0700[diff] [blame]1895 'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view,
1896 'UpdateDescriptors': self._gen_replay_update_descriptors,
Tobin Ehlis50990512015-02-05 11:29:45 -0700[diff] [blame]1897 'CreateDescriptorSetLayout': self._gen_replay_create_descriptor_set_layout,
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1898 'CreateDescriptorSetLayoutChain': self._gen_replay_create_descriptor_set_layout_chain,
1899 'CmdBindDescriptorSets': self._gen_replay_cmd_bind_descriptor_sets,
Jon Ashburnc46fc502015-02-10 10:36:22 -0700[diff] [blame]1900 'CmdWaitEvents': self._gen_replay_cmd_wait_events,
1901 'CmdPipelineBarrier': self._gen_replay_cmd_pipeline_barrier}
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]1902 # TODO : Need to guard CreateInstance with "if (!m_display->m_initedXGL)" check
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1903 # 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]1904 custom_check_ret_val = ['EnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport', 'QueueSubmit', 'GetObjectInfo',
1905 'GetFormatInfo', 'GetImageSubresourceInfo', 'CreateDescriptorSetLayout', 'CreateGraphicsPipeline',
1906 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'StorePipeline', 'GetMultiGpuCompatibility',
Peter Lohrmann95c369a2015-04-02 10:06:19 -0700[diff] [blame]1907 'DestroyObject', 'WaitForFences', 'FreeMemory', 'MapMemory', 'UnmapMemory',
1908 'WsiX11AssociateConnection', 'WsiX11GetMSC', 'WsiX11CreatePresentableImage', 'WsiX11QueuePresent']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1909 # multi-gpu Open funcs w/ list of local params to create
1910 custom_open_params = {'OpenSharedMemory': (-1,),
Courtney Goeltzenleuchter0d2efef2015-03-25 17:14:29 -0600[diff] [blame]1911 'OpenSharedSemaphore': (-1,),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1912 'OpenPeerMemory': (-1,),
1913 'OpenPeerImage': (-1, -2,)}
1914 # Functions that create views are unique from other create functions
Jon Ashburnb1b63ed2015-02-03 11:24:08 -0700[diff] [blame]1915 create_view_list = ['CreateBufferView', 'CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1916 # Functions to treat as "Create' that don't have 'Create' in the name
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -0600[diff] [blame]1917 special_create_list = ['LoadPipeline', 'LoadPipelineDerivative', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1918 # A couple funcs use do while loops
1919 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'}
1920 rbody = []
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1921 rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')
1922 rbody.append('{')
1923 rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')
1924 rbody.append(' XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;')
1925 rbody.append(' switch (packet->packet_id)')
1926 rbody.append(' {')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]1927 rbody.append(' case GLV_TPI_XGL_xglApiVersion:')
1928 rbody.append(' break; // nothing to replay on the version packet')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1929 for proto in self.protos:
1930 ret_value = False
1931 create_view = False
1932 create_func = False
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1933 # TODO : How to handle void* return of GetProcAddr?
1934 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]1935 ret_value = True
1936 if proto.name in create_view_list:
1937 create_view = True
1938 elif 'Create' in proto.name or proto.name in special_create_list:
1939 create_func = True
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1940 rbody.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
1941 rbody.append(' {')
1942 rbody.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(packet->pBody);' % (proto.name, proto.name))
1943 if proto.name in custom_body_dict:
1944 rbody.append(custom_body_dict[proto.name]())
1945 else:
1946 if proto.name in custom_open_params:
1947 rbody.append(' XGL_DEVICE handle;')
1948 for pidx in custom_open_params[proto.name]:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1949 rbody.append(' %s local_%s;' % (proto.params[pidx].ty.replace('const ', '').strip('*'), proto.params[pidx].name))
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1950 rbody.append(' handle = m_objMapper.remap(pPacket->device);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1951 elif create_view:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1952 rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').replace('const ', '')))
1953 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]1954 if 'CreateComputePipeline' == proto.name:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1955 rbody.append(' createInfo.cs.shader = m_objMapper.remap(pPacket->pCreateInfo->cs.shader);')
Jon Ashburnb1b63ed2015-02-03 11:24:08 -0700[diff] [blame]1956 elif 'CreateBufferView' == proto.name:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1957 rbody.append(' createInfo.buffer = m_objMapper.remap(pPacket->pCreateInfo->buffer);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1958 else:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1959 rbody.append(' createInfo.image = m_objMapper.remap(pPacket->pCreateInfo->image);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1960 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]1961 elif create_func: # Declare local var to store created handle into
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1962 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]1963 if 'AllocDescriptorSets' == proto.name:
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1964 # TODO should malloc and free here rather than fixed size array
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1965 rbody.append(' %s local_%s[100];' % (proto.params[-2].ty.strip('*').replace('const ', ''), proto.params[-2].name))
1966 rbody.append(' XGL_DESCRIPTOR_SET_LAYOUT localDescSets[100];')
1967 rbody.append(' assert(pPacket->count <= 100);')
1968 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
1969 rbody.append(' {')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1970 rbody.append(' localDescSets[i] = m_objMapper.remap(pPacket->%s[i]);' % (proto.params[-3].name))
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1971 rbody.append(' }')
1972 elif proto.name == 'ClearDescriptorSets':
Jon Ashburna6eef2c2015-04-01 12:25:04 -0600[diff] [blame]1973 # TODO should malloc and free here rather than fixed size array
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]1974 rbody.append(' XGL_DESCRIPTOR_SET localDescSets[100];')
1975 rbody.append(' assert(pPacket->count <= 100);')
1976 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1977 rbody.append(' {')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]1978 rbody.append(' localDescSets[i] = m_objMapper.remap(pPacket->%s[i]);' % (proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1979 rbody.append(' }')
1980 elif proto.name in do_while_dict:
1981 rbody.append(' do {')
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]1982 elif proto.name == 'EnumerateLayers':
1983 rbody.append(' char **bufptr = GLV_NEW_ARRAY(char *, pPacket->maxLayerCount);')
1984 rbody.append(' char **ptrLayers = (pPacket->pOutLayers == NULL) ? bufptr : (char **) pPacket->pOutLayers;')
1985 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
1986 rbody.append(' bufptr[i] = GLV_NEW_ARRAY(char, pPacket->maxStringSize);')
Jon Ashburnd698ca22015-02-12 12:37:46 -0700[diff] [blame]1987 elif proto.name == 'DestroyInstance':
Courtney Goeltzenleuchterbef72722015-04-13 14:59:46 -0600[diff] [blame]1988 rbody.append(' xglDbgUnregisterMsgCallback(m_objMapper.remap(pPacket->instance), g_fpDbgMsgCallback);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1989 rr_string = ' '
1990 if ret_value:
1991 rr_string = ' replayResult = '
1992 rr_string += 'm_xglFuncs.real_xgl%s(' % proto.name
1993 for p in proto.params:
1994 # For last param of Create funcs, pass address of param
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]1995 if create_func:
1996 if p.name == proto.params[-1].name:
1997 rr_string += '&local_%s, ' % p.name
1998 elif proto.name == 'AllocDescriptorSets' and p.name == proto.params[-2].name:
1999 rr_string += 'local_%s, ' % p.name
2000 else:
2001 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2002 else:
2003 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
2004 rr_string = '%s);' % rr_string[:-2]
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]2005 if proto.name in custom_open_params:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2006 rr_list = rr_string.split(', ')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2007 rr_list[0] = rr_list[0].replace('m_objMapper.remap(pPacket->device)', 'handle')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2008 for pidx in custom_open_params[proto.name]:
2009 rr_list[pidx] = '&local_%s' % proto.params[pidx].name
2010 rr_string = ', '.join(rr_list)
2011 rr_string += ');'
2012 elif create_view:
2013 rr_list = rr_string.split(', ')
2014 rr_list[-2] = '&createInfo'
2015 rr_list[-1] = '&local_%s);' % proto.params[-1].name
2016 rr_string = ', '.join(rr_list)
2017 # this is a sneaky shortcut to use generic create code below to add_to_map
2018 create_func = True
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]2019 elif proto.name == 'EnumerateLayers':
2020 rr_string = rr_string.replace('pPacket->pOutLayers', 'ptrLayers')
Jon Ashburn200ccb52015-02-04 12:57:25 -0700[diff] [blame]2021 elif proto.name == 'ClearDescriptorSets':
2022 rr_string = rr_string.replace('pPacket->pDescriptorSets', 'localDescSets')
2023 elif proto.name == 'AllocDescriptorSets':
2024 rr_string = rr_string.replace('pPacket->pSetLayouts', 'localDescSets')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2025 rbody.append(rr_string)
2026 if 'DestroyDevice' in proto.name:
2027 rbody.append(' if (replayResult == XGL_SUCCESS)')
2028 rbody.append(' {')
Peter Lohrmann53e89242015-02-27 15:35:15 -0800[diff] [blame]2029 rbody.append(' m_pCBDump = NULL;')
2030 rbody.append(' m_pDSDump = NULL;')
Peter Lohrmanncaf39d52015-03-24 17:19:24 -0700[diff] [blame]2031 rbody.append(' m_pGlvSnapshotPrint = NULL;')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2032 rbody.append(' m_objMapper.rm_from_map(pPacket->device);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2033 rbody.append(' m_display->m_initedXGL = false;')
2034 rbody.append(' }')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]2035 if 'DestroyInstance' in proto.name:
2036 rbody.append(' if (replayResult == XGL_SUCCESS)')
2037 rbody.append(' {')
Jon Ashburn6f58a162015-02-03 09:17:12 -0700[diff] [blame]2038 rbody.append(' // TODO need to handle multiple instances and only clearing maps within an instance.')
2039 rbody.append(' // TODO this only works with a single instance used at any given time.')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2040 rbody.append(' m_objMapper.clear_all_map_handles();')
Jon Ashburn6f4b3032015-02-03 08:57:28 -0700[diff] [blame]2041 rbody.append(' }')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2042 elif 'AllocDescriptorSets' in proto.name:
2043 rbody.append(' if (replayResult == XGL_SUCCESS)')
2044 rbody.append(' {')
2045 rbody.append(' for (uint32_t i = 0; i < local_pCount; i++) {')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2046 rbody.append(' m_objMapper.add_to_map(&pPacket->%s[i], &local_%s[i]);' % (proto.params[-2].name, proto.params[-2].name))
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2047 rbody.append(' }')
2048 rbody.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2049 elif create_func: # save handle mapping if create successful
2050 rbody.append(' if (replayResult == XGL_SUCCESS)')
2051 rbody.append(' {')
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2052 rbody.append(' m_objMapper.add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2053 if 'AllocMemory' == proto.name:
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2054 rbody.append(' m_objMapper.add_entry_to_mapData(local_%s, pPacket->pAllocInfo->allocationSize);' % (proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2055 rbody.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2056 elif proto.name in do_while_dict:
2057 rbody[-1] = ' %s' % rbody[-1]
2058 rbody.append(' } while (%s);' % do_while_dict[proto.name])
Jon Ashburn8bead7a2015-02-23 11:07:30 -0700[diff] [blame]2059 rbody.append(' if (pPacket->result != XGL_NOT_READY || replayResult != XGL_SUCCESS)')
Jon Ashburnffd5f142015-02-03 13:39:05 -0700[diff] [blame]2060 elif proto.name == 'EnumerateLayers':
2061 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
2062 rbody.append(' GLV_DELETE(bufptr[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2063 if ret_value:
2064 rbody.append(' CHECK_RETURN_VALUE(xgl%s);' % proto.name)
2065 if 'MsgCallback' in proto.name:
2066 rbody.pop()
2067 rbody.pop()
2068 rbody.pop()
2069 rbody.append(' // Just eating these calls as no way to restore dbg func ptr.')
2070 rbody.append(' break;')
2071 rbody.append(' }')
2072 rbody.append(' default:')
2073 rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')
2074 rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')
2075 rbody.append(' break;')
2076 rbody.append(' }')
2077 rbody.append(' return returnValue;')
2078 rbody.append('}')
2079 return "\n".join(rbody)
2080
2081class GlaveTraceHeader(Subcommand):
2082 def generate_header(self):
2083 header_txt = []
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]2084 header_txt.append('#include "glv_vk_vk_structs.h"')
2085 header_txt.append('#include "glv_vk_packet_id.h"\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2086 header_txt.append('void AttachHooks();')
2087 header_txt.append('void DetachHooks();')
Ian Elliottbc9ca5f2015-02-27 11:10:59 -0700[diff] [blame]2088 header_txt.append('void InitTracer(void);\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2089 return "\n".join(header_txt)
2090
2091 def generate_body(self):
2092 body = [self._generate_trace_func_ptrs(),
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]2093 self._generate_trace_func_protos(),
2094 self._generate_trace_real_func_ptr_protos()]
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2095
2096 return "\n".join(body)
2097
2098class GlaveTraceC(Subcommand):
2099 def generate_header(self):
2100 header_txt = []
2101 header_txt.append('#include "glv_platform.h"')
2102 header_txt.append('#include "glv_common.h"')
Peter Lohrmann358d0092015-04-03 12:03:44 -0700[diff] [blame]2103 header_txt.append('#include "glvtrace_xgl_helpers.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2104 header_txt.append('#include "glvtrace_xgl_xgl.h"')
2105 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
2106 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
2107 header_txt.append('#include "glv_interconnect.h"')
2108 header_txt.append('#include "glv_filelike.h"')
Tobin Ehlisff765b02015-03-12 14:50:40 -0600[diff] [blame]2109 header_txt.append('#include "xgl_struct_size_helper.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2110 header_txt.append('#ifdef WIN32')
2111 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2112 header_txt.append('#endif')
2113 header_txt.append('#include "glv_trace_packet_utils.h"')
2114 header_txt.append('#include <stdio.h>\n')
2115 return "\n".join(header_txt)
2116
2117 def generate_body(self):
2118 body = [self._generate_func_ptr_assignments(),
2119 self._generate_attach_hooks(),
2120 self._generate_detach_hooks(),
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]2121 self._generate_init_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2122 self._generate_trace_funcs()]
2123
2124 return "\n".join(body)
2125
2126class GlavePacketID(Subcommand):
2127 def generate_header(self):
2128 header_txt = []
2129 header_txt.append('#pragma once\n')
2130 header_txt.append('#include "glv_trace_packet_utils.h"')
2131 header_txt.append('#include "glv_trace_packet_identifiers.h"')
2132 header_txt.append('#include "glv_interconnect.h"')
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]2133 header_txt.append('#include "glv_vk_vk_structs.h"')
2134 header_txt.append('#include "glv_vk_vkdbg_structs.h"')
2135 header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2136 header_txt.append('#include "xgl_enum_string_helper.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2137 header_txt.append('#if defined(WIN32)')
2138 header_txt.append('#define snprintf _snprintf')
2139 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2140 header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')
2141 header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\\n");\n')
2142 header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')
2143 header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')
2144 header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')
2145 header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);\n')
2146 header_txt.append('#define FINISH_TRACE_PACKET() \\')
2147 header_txt.append(' glv_finalize_trace_packet(pHeader); \\')
2148 header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')
2149 header_txt.append(' glv_delete_trace_packet(&pHeader);')
2150 return "\n".join(header_txt)
2151
2152 def generate_body(self):
2153 body = [self._generate_packet_id_enum(),
2154 self._generate_stringify_func(),
2155 self._generate_interp_func()]
2156
2157 return "\n".join(body)
2158
2159class GlaveCoreStructs(Subcommand):
2160 def generate_header(self):
2161 header_txt = []
2162 header_txt.append('#pragma once\n')
2163 header_txt.append('#include "xgl.h"')
2164 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2165 return "\n".join(header_txt)
2166
2167 def generate_body(self):
2168 body = [self._generate_struct_util_funcs(),
2169 self._generate_interp_funcs()]
2170
2171 return "\n".join(body)
2172
2173class GlaveWsiHeader(Subcommand):
2174 def generate_header(self):
2175 header_txt = []
2176 header_txt.append('#pragma once\n')
2177 header_txt.append('#include "xgl.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2178 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2179 header_txt.append('#include "xglWsiX11Ext.h"\n')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2180 header_txt.append('#else')
2181 header_txt.append('#include "xglWsiWinExt.h"')
2182 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2183 header_txt.append('void AttachHooks_xglwsix11ext();')
2184 header_txt.append('void DetachHooks_xglwsix11ext();')
2185 return "\n".join(header_txt)
2186
2187 def generate_body(self):
2188 body = [self._generate_trace_func_ptrs_ext(),
2189 self._generate_trace_func_protos_ext()]
2190
2191 return "\n".join(body)
2192
2193class GlaveWsiC(Subcommand):
2194 def generate_header(self):
2195 header_txt = []
2196 header_txt.append('#include "glv_platform.h"')
2197 header_txt.append('#include "glv_common.h"')
2198 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]2199 header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
2200 header_txt.append('#include "glv_vk_packet_id.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2201 header_txt.append('#ifdef WIN32')
2202 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2203 header_txt.append('#endif')
2204 return "\n".join(header_txt)
2205
2206 def generate_body(self):
2207 body = [self._generate_func_ptr_assignments_ext(),
2208 self._generate_attach_hooks_ext(),
2209 self._generate_detach_hooks_ext(),
2210 self._generate_trace_funcs_ext()]
2211
2212 return "\n".join(body)
2213
2214class GlaveWsiStructs(Subcommand):
2215 def generate_header(self):
2216 header_txt = []
2217 header_txt.append('#pragma once\n')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2218 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2219 header_txt.append('#include "xglWsiX11Ext.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2220 header_txt.append('#else')
2221 header_txt.append('#include "xglWsiWinExt.h"')
2222 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2223 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2224 return "\n".join(header_txt)
2225
2226 def generate_body(self):
2227 body = [self._generate_interp_funcs_ext()]
2228
2229 return "\n".join(body)
2230
2231class GlaveDbgHeader(Subcommand):
2232 def generate_header(self):
2233 header_txt = []
2234 header_txt.append('#pragma once\n')
2235 header_txt.append('#include "xgl.h"')
2236 header_txt.append('#include "xglDbg.h"\n')
2237 header_txt.append('void AttachHooks_xgldbg();')
2238 header_txt.append('void DetachHooks_xgldbg();')
2239 return "\n".join(header_txt)
2240
2241 def generate_body(self):
2242 body = [self._generate_trace_func_ptrs_ext('Dbg'),
2243 self._generate_trace_func_protos_ext('Dbg')]
2244
2245 return "\n".join(body)
2246
2247class GlaveDbgC(Subcommand):
2248 def generate_header(self):
2249 header_txt = []
2250 header_txt.append('#include "glv_platform.h"')
2251 header_txt.append('#include "glv_common.h"')
2252 header_txt.append('#include "glvtrace_xgl_xgl.h"')
2253 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]2254 header_txt.append('#include "glv_vk_vkdbg_structs.h"')
2255 header_txt.append('#include "glv_vk_packet_id.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2256 header_txt.append('#ifdef WIN32')
2257 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2258 header_txt.append('#endif')
2259 return "\n".join(header_txt)
2260
2261 def generate_body(self):
2262 body = [self._generate_func_ptr_assignments_ext('Dbg'),
2263 self._generate_attach_hooks_ext('Dbg'),
2264 self._generate_detach_hooks_ext('Dbg'),
2265 self._generate_trace_funcs_ext('Dbg')]
2266
2267 return "\n".join(body)
2268
2269class GlaveDbgStructs(Subcommand):
2270 def generate_header(self):
2271 header_txt = []
2272 header_txt.append('#pragma once\n')
2273 header_txt.append('#include "xglDbg.h"')
2274 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2275 return "\n".join(header_txt)
2276
2277 def generate_body(self):
2278 body = [self._generate_interp_funcs_ext('Dbg')]
2279
2280 return "\n".join(body)
2281
Peter Lohrmannaf44b452015-03-30 18:29:22 -0700[diff] [blame]2282class GlaveReplayXglFuncPtrs(Subcommand):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2283 def generate_header(self):
2284 header_txt = []
2285 header_txt.append('#pragma once\n')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2286 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2287 header_txt.append('#include <xcb/xcb.h>\n')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2288 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2289 header_txt.append('#include "xgl.h"')
2290 header_txt.append('#include "xglDbg.h"')
Piers Danielle2bca482015-02-24 13:58:47 -0700[diff] [blame]2291 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2292 header_txt.append('#include "xglWsiX11Ext.h"')
David Pinedo8e9cb3b2015-02-10 15:02:08 -0700[diff] [blame]2293 header_txt.append('#else')
2294 header_txt.append('#include "xglWsiWinExt.h"')
2295 header_txt.append('#endif')
Peter Lohrmannaf44b452015-03-30 18:29:22 -0700[diff] [blame]2296
2297 def generate_body(self):
2298 body = [self._generate_replay_func_ptrs()]
2299 return "\n".join(body)
2300
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2301class GlaveReplayObjMapperHeader(Subcommand):
Jon Ashburn013aa1c2015-02-13 11:25:53 -0700[diff] [blame]2302 def generate_header(self):
Ian Elliott91e681e2015-02-18 15:35:00 -0700[diff] [blame]2303 header_txt = []
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2304 header_txt.append('#pragma once\n')
2305 header_txt.append('#include <set>')
2306 header_txt.append('#include <map>')
2307 header_txt.append('#include <vector>')
2308 header_txt.append('#include <string>')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2309 header_txt.append('#include "xgl.h"')
2310 header_txt.append('#include "xglDbg.h"')
Jon Ashburn15908772015-02-17 13:28:11 -0700[diff] [blame]2311 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2312 header_txt.append('#include "xglWsiX11Ext.h"')
2313 header_txt.append('#else')
2314 header_txt.append('#include "xglWsiWinExt.h"')
2315 header_txt.append('#endif')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2316 return "\n".join(header_txt)
2317
2318 def generate_body(self):
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2319 body = [self._generate_replay_objmapper_class()]
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2320
2321 return "\n".join(body)
2322
2323class GlaveReplayC(Subcommand):
2324 def generate_header(self):
2325 header_txt = []
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2326 header_txt.append('#include "glvreplay_xgl_xglreplay.h"\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2327 header_txt.append('#include "glvreplay_xgl.h"\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2328 header_txt.append('#include "glvreplay_main.h"\n')
2329 header_txt.append('#include <algorithm>')
2330 header_txt.append('#include <queue>')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]2331 header_txt.append('\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2332 header_txt.append('extern "C" {')
Peter Lohrmanncde614c2015-03-27 12:57:10 -0700[diff] [blame]2333 header_txt.append('#include "glv_vk_vk_structs.h"')
2334 header_txt.append('#include "glv_vk_vkdbg_structs.h"')
2335 header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
2336 header_txt.append('#include "glv_vk_packet_id.h"')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2337 header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')
2338 header_txt.append('#define APP_NAME "glvreplay_xgl"')
2339 header_txt.append('#define IDI_ICON 101\n')
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]2340
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2341 return "\n".join(header_txt)
2342
2343 def generate_body(self):
Peter Lohrmann3f0d6972015-04-01 18:12:34 -0700[diff] [blame]2344 body = [self._generate_replay_init_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2345 self._generate_replay()]
2346
2347 return "\n".join(body)
2348
2349def main():
2350 subcommands = {
2351 "glave-trace-h" : GlaveTraceHeader,
2352 "glave-trace-c" : GlaveTraceC,
2353 "glave-packet-id" : GlavePacketID,
2354 "glave-core-structs" : GlaveCoreStructs,
2355 "glave-wsi-trace-h" : GlaveWsiHeader,
2356 "glave-wsi-trace-c" : GlaveWsiC,
2357 "glave-wsi-trace-structs" : GlaveWsiStructs,
2358 "glave-dbg-trace-h" : GlaveDbgHeader,
2359 "glave-dbg-trace-c" : GlaveDbgC,
2360 "glave-dbg-trace-structs" : GlaveDbgStructs,
Peter Lohrmannaf44b452015-03-30 18:29:22 -0700[diff] [blame]2361 "glave-replay-xgl-funcs" : GlaveReplayXglFuncPtrs,
Peter Lohrmann75728222015-04-02 11:45:31 -0700[diff] [blame]2362 "glave-replay-obj-mapper-h" : GlaveReplayObjMapperHeader,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2363 "glave-replay-c" : GlaveReplayC,
2364 }
2365
2366 if len(sys.argv) < 2 or sys.argv[1] not in subcommands:
2367 print("Usage: %s <subcommand> [options]" % sys.argv[0])
2368 print
2369 print("Available sucommands are: %s" % " ".join(subcommands))
2370 exit(1)
2371
2372 subcmd = subcommands[sys.argv[1]](sys.argv[2:])
2373 subcmd.run()
2374
2375if __name__ == "__main__":
2376 main()