Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / a53a6944f4bb7ef120325837f8e4dc286cdeb8eb / . / glave-generate.py
blob: f117f391a3da3737aad3fbfc7fe22401c9e92e10 [file] [log] [blame]
Tobin Ehlis5d57bca2014-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 Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]25
26import sys
27
28import xgl
29
30class Subcommand(object):
31 def __init__(self, argv):
32 self.argv = argv
Chia-I Wuc4f24e82015-01-01 08:46:31 +0800[diff] [blame]33 self.headers = xgl.headers
34 self.protos = xgl.protos
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]35
36 def run(self):
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]37 print(self.generate())
38
39 def generate(self):
40 copyright = self.generate_copyright()
41 header = self.generate_header()
42 body = self.generate_body()
43 footer = self.generate_footer()
44
45 contents = []
46 if copyright:
47 contents.append(copyright)
48 if header:
49 contents.append(header)
50 if body:
51 contents.append(body)
52 if footer:
53 contents.append(footer)
54
55 return "\n\n".join(contents)
56
57 def generate_copyright(self):
58 return """/* THIS FILE IS GENERATED. DO NOT EDIT. */
59
60/*
61 * XGL
62 *
63 * Copyright (C) 2014 LunarG, Inc.
64 *
65 * Permission is hereby granted, free of charge, to any person obtaining a
66 * copy of this software and associated documentation files (the "Software"),
67 * to deal in the Software without restriction, including without limitation
68 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
69 * and/or sell copies of the Software, and to permit persons to whom the
70 * Software is furnished to do so, subject to the following conditions:
71 *
72 * The above copyright notice and this permission notice shall be included
73 * in all copies or substantial portions of the Software.
74 *
75 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
76 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
77 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
78 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
79 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
80 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
81 * DEALINGS IN THE SOFTWARE.
82 */"""
83
84 def generate_header(self):
85 return "\n".join(["#include <" + h + ">" for h in self.headers])
86
87 def generate_body(self):
88 pass
89
90 def generate_footer(self):
91 pass
92
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]93 # Return set of printf '%' qualifier, input to that qualifier, and any dereference
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]94 def _get_printf_params(self, xgl_type, name, output_param):
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]95 deref = ""
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]96 # TODO : Need ENUM and STRUCT checks here
97 if "_TYPE" in xgl_type: # TODO : This should be generic ENUM check
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]98 return ("%s", "string_%s(%s)" % (xgl_type.replace('const ', '').strip('*'), name), deref)
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]99 if "char*" == xgl_type:
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]100 return ("%s", name, "*")
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]101 if "uint64_t" in xgl_type:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]102 if '*' in xgl_type:
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]103 return ("%lu", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
104 return ("%lu", name, deref)
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]105 if "size_t" in xgl_type:
Chia-I Wu99ff89d2014-12-27 14:14:50 +0800[diff] [blame]106 if '*' in xgl_type:
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]107 return ("%zu", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
108 return ("%zu", name, deref)
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]109 if "float" in xgl_type:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]110 if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]111 return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name), deref)
112 return ("%f", name, deref)
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]113 if "bool" in xgl_type or 'xcb_randr_crtc_t' in xgl_type:
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]114 return ("%u", name, deref)
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]115 if True in [t in xgl_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]116 if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]117 return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name), deref)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]118 if '*' in xgl_type:
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]119 return ("%i", "(%s == NULL) ? 0 : *(%s)" % (name, name), "*")
120 return ("%i", name, deref)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]121 if output_param:
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]122 return ("%p", "(void*)%s" % name, deref)
123 return ("%p", "(void*)(%s)" % name, deref)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]124
125 def _generate_trace_func_ptrs(self):
126 func_ptrs = []
127 func_ptrs.append('// Pointers to real functions and declarations of hooked functions')
128 func_ptrs.append('#ifdef WIN32')
129 func_ptrs.append('extern INIT_ONCE gInitOnce;')
130 for proto in self.protos:
131 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:
132 func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))
133
134 func_ptrs.append('\n#elif defined(PLATFORM_LINUX)')
135 func_ptrs.append('extern pthread_once_t gInitOnce;')
136 for proto in self.protos:
137 if True not in [skip_str in proto.name for skip_str in ['Dbg', 'Wsi']]:
138 func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))
139
140 func_ptrs.append('#endif\n')
141 return "\n".join(func_ptrs)
142
143 def _generate_trace_func_ptrs_ext(self, func_class='Wsi'):
144 func_ptrs = []
145 func_ptrs.append('#ifdef WIN32')
146 for proto in self.protos:
147 if func_class in proto.name:
148 func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))
149
150 func_ptrs.append('#elif defined(__linux__)')
151 for proto in self.protos:
152 if func_class in proto.name:
153 func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))
154
155 func_ptrs.append('#endif\n')
156 return "\n".join(func_ptrs)
157
158 def _generate_trace_func_protos(self):
159 func_protos = []
160 func_protos.append('// Hooked function prototypes\n')
161 for proto in self.protos:
162 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
Ian Elliottc4e3e0f2015-02-26 17:01:30 -0700[diff] [blame]163 func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]164
165 return "\n".join(func_protos)
166
167 def _generate_trace_func_protos_ext(self, func_class='Wsi'):
168 func_protos = []
169 func_protos.append('// Hooked function prototypes\n')
170 for proto in self.protos:
171 if func_class in proto.name:
Ian Elliottc4e3e0f2015-02-26 17:01:30 -0700[diff] [blame]172 func_protos.append('GLVTRACER_EXPORT %s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]173
174 return "\n".join(func_protos)
175
176
177 def _generate_func_ptr_assignments(self):
178 func_ptr_assign = []
179 for proto in self.protos:
180 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
181 func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
182 for p in proto.params:
183 if 'color' == p.name:
184 func_ptr_assign.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))
185 else:
186 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
187 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
188 func_ptr_assign.append('static BOOL isHooked = FALSE;\n')
189 return "\n".join(func_ptr_assign)
190
191 def _generate_func_ptr_assignments_ext(self, func_class='Wsi'):
192 func_ptr_assign = []
193 for proto in self.protos:
194 if func_class in proto.name:
195 func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
196 for p in proto.params:
197 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
198 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
199 return "\n".join(func_ptr_assign)
200
201 def _generate_attach_hooks(self):
202 hooks_txt = []
203 hooks_txt.append('void AttachHooks()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)')
204 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]205 # TODO : Verify if CreateInstance is appropriate to key off of here
206 hooks_txt.append(' if (real_xglCreateInstance != NULL)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]207 hooks_txt.append(' {\n isHooked = TRUE;')
208 hook_operator = '='
209 for proto in self.protos:
210 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
211 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
212 hook_operator = '&='
213 hooks_txt.append(' }\n')
214 hooks_txt.append(' if (!hookSuccess)\n {')
215 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
216 hooks_txt.append(' Mhook_EndMultiOperation();\n')
217 hooks_txt.append('#elif defined(__linux__)')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]218 hooks_txt.append(' if (real_xglCreateInstance == xglCreateInstance)')
219 hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateInstance,"xglCreateInstance");')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]220 hooks_txt.append(' isHooked = TRUE;')
221 for proto in self.protos:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]222 if 'Dbg' not in proto.name and 'Wsi' not in proto.name and 'CreateInstance' not in proto.name:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]223 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
224 hooks_txt.append(' if (!hookSuccess)\n {')
225 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
226 hooks_txt.append('#endif\n}\n')
227 return "\n".join(hooks_txt)
228
229 def _generate_attach_hooks_ext(self, func_class='Wsi'):
230 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
231 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
232 hooks_txt = []
233 hooks_txt.append('void AttachHooks%s()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)' % func_ext_dict[func_class])
234 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
235 hooks_txt.append(' if (real_xgl%s != NULL)' % first_proto_dict[func_class])
236 hooks_txt.append(' {')
237 hook_operator = '='
238 for proto in self.protos:
239 if func_class in proto.name:
240 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
241 hook_operator = '&='
242 hooks_txt.append(' }\n')
243 hooks_txt.append(' if (!hookSuccess)\n {')
244 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
245 hooks_txt.append(' Mhook_EndMultiOperation();\n')
246 hooks_txt.append('#elif defined(__linux__)')
247 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]))
248 for proto in self.protos:
249 if func_class in proto.name and first_proto_dict[func_class] not in proto.name:
250 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
251 hooks_txt.append(' if (!hookSuccess)\n {')
252 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
253 hooks_txt.append('#endif\n}\n')
254 return "\n".join(hooks_txt)
255
256 def _generate_detach_hooks(self):
257 hooks_txt = []
258 hooks_txt.append('void DetachHooks()\n{\n#ifdef __linux__\n return;\n#elif defined(WIN32)')
259 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xglGetGpuInfo != NULL)\n {')
260 hook_operator = '='
261 for proto in self.protos:
262 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
263 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
264 hook_operator = '&='
265 hooks_txt.append(' }\n isHooked = FALSE;')
266 hooks_txt.append(' if (!unhookSuccess)\n {')
267 hooks_txt.append(' glv_LogError("Failed to unhook XGL.");\n }')
268 hooks_txt.append('#endif\n}')
269 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')
270 return "\n".join(hooks_txt)
271
272 def _generate_detach_hooks_ext(self, func_class='Wsi'):
273 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
274 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
275 hooks_txt = []
276 hooks_txt.append('void DetachHooks%s()\n{\n#ifdef WIN32' % func_ext_dict[func_class])
277 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xgl%s != NULL)\n {' % first_proto_dict[func_class])
278 hook_operator = '='
279 for proto in self.protos:
280 if func_class in proto.name:
281 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
282 hook_operator = '&='
283 hooks_txt.append(' }')
284 hooks_txt.append(' if (!unhookSuccess)\n {')
285 hooks_txt.append(' glv_LogError("Failed to unhook XGL ext %s.");\n }' % func_class)
286 hooks_txt.append('#elif defined(__linux__)\n return;\n#endif\n}\n')
287 return "\n".join(hooks_txt)
288
Jon Ashburn15161e42014-12-16 18:37:04 -0700[diff] [blame]289 def _generate_init_funcs(self):
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]290 init_tracer = []
Jon Ashburn15161e42014-12-16 18:37:04 -0700[diff] [blame]291 init_tracer.append('void send_xgl_api_version_packet()\n{')
292 init_tracer.append(' struct_xglApiVersion* pPacket;')
293 init_tracer.append(' glv_trace_packet_header* pHeader;')
294 init_tracer.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_xglApiVersion, sizeof(struct_xglApiVersion), 0);')
295 init_tracer.append(' pPacket = interpret_body_as_xglApiVersion(pHeader, FALSE);')
296 init_tracer.append(' pPacket->version = XGL_API_VERSION;')
297 init_tracer.append(' FINISH_TRACE_PACKET();\n}\n')
298
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]299 init_tracer.append('static GLV_CRITICAL_SECTION g_memInfoLock;')
Ian Elliott5890a772015-02-27 11:10:59 -0700[diff] [blame]300 init_tracer.append('void InitTracer(void)\n{')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]301 init_tracer.append(' char *ipAddr = glv_get_global_var("GLVLIB_TRACE_IPADDR");')
302 init_tracer.append(' if (ipAddr == NULL)')
303 init_tracer.append(' ipAddr = "127.0.0.1";')
Jon Ashburnd27ce942015-01-09 17:36:10 -0700[diff] [blame]304 init_tracer.append(' gMessageStream = glv_MessageStream_create(FALSE, ipAddr, GLV_BASE_PORT + GLV_TID_XGL);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]305 init_tracer.append(' glv_trace_set_trace_file(glv_FileLike_create_msg(gMessageStream));')
306 init_tracer.append('// glv_tracelog_set_log_file(glv_FileLike_create_file(fopen("glv_log_traceside.txt","w")));')
Jon Ashburn15161e42014-12-16 18:37:04 -0700[diff] [blame]307 init_tracer.append(' glv_tracelog_set_tracer_id(GLV_TID_XGL);')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]308 init_tracer.append(' glv_create_critical_section(&g_memInfoLock);')
Jon Ashburn15161e42014-12-16 18:37:04 -0700[diff] [blame]309 init_tracer.append(' send_xgl_api_version_packet();\n}\n')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]310 return "\n".join(init_tracer)
311
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]312 def _gen_unmap_memory(self):
313 um_body = []
314 um_body.append('GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglUnmapMemory(')
315 um_body.append(' XGL_GPU_MEMORY mem)')
316 um_body.append('{')
317 um_body.append(' glv_trace_packet_header* pHeader;')
318 um_body.append(' XGL_RESULT result;')
319 um_body.append(' struct_xglUnmapMemory* pPacket;')
320 um_body.append(' XGLAllocInfo *entry;')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]321 um_body.append(' SEND_ENTRYPOINT_PARAMS("xglUnmapMemory(mem %p)\\n", mem);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]322 um_body.append(' // insert into packet the data that was written by CPU between the xglMapMemory call and here')
323 um_body.append(' // Note must do this prior to the real xglUnMap() or else may get a FAULT')
Jon Ashburn9c1f8072015-02-25 13:51:07 -0700[diff] [blame]324 um_body.append(' glv_enter_critical_section(&g_memInfoLock);')
325 um_body.append(' entry = find_mem_info_entry(mem);')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]326 um_body.append(' CREATE_TRACE_PACKET(xglUnmapMemory, (entry) ? entry->size : 0);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]327 um_body.append(' pPacket = interpret_body_as_xglUnmapMemory(pHeader);')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]328 um_body.append(' if (entry)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]329 um_body.append(' {')
330 um_body.append(' assert(entry->handle == mem);')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]331 um_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pData), entry->size, entry->pData);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]332 um_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));')
333 um_body.append(' entry->pData = NULL;')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]334 um_body.append(' } else')
335 um_body.append(' {')
336 um_body.append(' glv_LogError("Failed to copy app memory into trace packet (idx = %u) on xglUnmapMemory\\n", pHeader->global_packet_index);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]337 um_body.append(' }')
Jon Ashburn9c1f8072015-02-25 13:51:07 -0700[diff] [blame]338 um_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]339 um_body.append(' result = real_xglUnmapMemory(mem);')
340 um_body.append(' pPacket->mem = mem;')
341 um_body.append(' pPacket->result = result;')
342 um_body.append(' FINISH_TRACE_PACKET();')
343 um_body.append(' return result;')
344 um_body.append('}\n')
345 return "\n".join(um_body)
346
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]347 # Generate functions used to trace API calls and store the input and result data into a packet
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]348 def _generate_trace_funcs(self):
349 func_body = []
350 for proto in self.protos:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]351 if 'UnmapMemory' == proto.name:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]352 func_body.append(self._gen_unmap_memory())
353 elif 'Dbg' not in proto.name and 'Wsi' not in proto.name:
354 packet_update_txt = ''
355 return_txt = ''
356 packet_size = ''
357 in_data_size = False # flag when we need to capture local input size variable for in/out size
358 buff_ptr_indices = []
359 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
360 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL
361 if 'color' == p.name:
362 func_body.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))
363 else:
364 func_body.append(' %s %s,' % (p.ty, p.name))
365 if '*' in p.ty and 'pSysMem' != p.name and 'pReserved' != p.name:
366 if 'pData' == p.name:
367 if 'dataSize' == proto.params[proto.params.index(p)-1].name:
368 packet_size += 'dataSize + '
369 elif 'counterCount' == proto.params[proto.params.index(p)-1].name:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]370 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]371 else:
372 packet_size += '((pDataSize != NULL && pData != NULL) ? *pDataSize : 0) + '
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]373 elif '**' in p.ty and 'void' in p.ty:
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]374 packet_size += 'sizeof(void*) + '
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]375 elif 'void' in p.ty:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]376 packet_size += 'sizeof(%s) + ' % p.name
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]377 elif 'char' in p.ty:
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]378 packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]379 elif 'DEVICE_CREATE_INFO' in p.ty:
380 packet_size += 'calc_size_XGL_DEVICE_CREATE_INFO(pCreateInfo) + '
381 elif 'pDataSize' in p.name:
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]382 packet_size += '((pDataSize != NULL) ? sizeof(size_t) : 0) + '
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]383 in_data_size = True;
384 elif 'IMAGE_SUBRESOURCE' in p.ty and 'pSubresource' == p.name:
385 packet_size += '((pSubresource != NULL) ? sizeof(XGL_IMAGE_SUBRESOURCE) : 0) + '
386 else:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]387 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]388 buff_ptr_indices.append(proto.params.index(p))
389 else:
390 if 'color' == p.name:
Tobin Ehlisf9a7e252015-02-25 11:30:27 -0700[diff] [blame]391 array_str = p.ty[p.ty.find('[')+1:p.ty.find(']')]
392 packet_update_txt += ' memcpy((void*)pPacket->color, color, %s * sizeof(%s));\n' % (array_str, p.ty.strip('*').replace('const ', '').replace('[%s]' % array_str, ''))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]393 else:
394 packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)
395 if 'Count' in p.name and proto.params[-1].name != p.name and p.name not in ['queryCount', 'vertexCount', 'indexCount', 'startCounter'] and proto.name not in ['CmdLoadAtomicCounters', 'CmdSaveAtomicCounters']:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]396 if '*' in p.ty:
397 packet_size += '*%s*' % p.name
398 else:
399 packet_size += '%s*' % p.name
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]400 if '' == packet_size:
401 packet_size = '0'
402 else:
403 packet_size = packet_size.strip(' + ')
404 func_body[-1] = func_body[-1].replace(',', ')')
405 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]406 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]407 func_body.append(' %s result;' % proto.ret)
408 return_txt = 'result = '
409 if in_data_size:
Jon Ashburne3a667c2015-02-11 09:32:29 -0700[diff] [blame]410 func_body.append(' size_t _dataSize;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]411 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
Jon Ashburn04baf7a2015-02-02 12:39:24 -0700[diff] [blame]412 # functions that have non-standard sequence of packet creation and calling real function
413 # NOTE: Anytime we call the function first, need to add custom code for correctly tracking API call time
414 if 'CreateInstance' == proto.name:
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]415 func_body.append(' uint64_t startTime;')
Jon Ashburn04baf7a2015-02-02 12:39:24 -0700[diff] [blame]416 func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')
417 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
418 func_body.append(' if (real_xglCreateInstance == xglCreateInstance)')
419 func_body.append(' {')
420 func_body.append(' glv_platform_get_next_lib_sym((void **) &real_xglCreateInstance,"xglCreateInstance");')
421 func_body.append(' }')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]422 func_body.append(' startTime = glv_get_time();')
423 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Jon Ashburn04baf7a2015-02-02 12:39:24 -0700[diff] [blame]424 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(XGL_INSTANCE) + calc_size_XGL_APPLICATION_INFO(pAppInfo) + ((pAllocCb == NULL) ? 0 :sizeof(XGL_ALLOC_CALLBACKS)));' % (proto.name))
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]425 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
Jon Ashburn04baf7a2015-02-02 12:39:24 -0700[diff] [blame]426 func_body.append(' if (isHooked == FALSE) {')
427 func_body.append(' AttachHooks();')
428 func_body.append(' AttachHooks_xgldbg();')
429 func_body.append(' AttachHooks_xglwsix11ext();')
430 func_body.append(' }')
Jon Ashburn04baf7a2015-02-02 12:39:24 -0700[diff] [blame]431 elif 'EnumerateGpus' == proto.name:
432 func_body.append(' uint64_t startTime;')
433 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
434 func_body.append(' startTime = glv_get_time();')
435 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
436 func_body.append(' CREATE_TRACE_PACKET(xglEnumerateGpus, sizeof(uint32_t) + ((pGpus && pGpuCount) ? *pGpuCount * sizeof(XGL_PHYSICAL_GPU) : 0));')
437 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
438 elif 'EnumerateLayers' == proto.name:
439 func_body.append(' uint64_t startTime;')
440 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
441 func_body.append(' startTime = glv_get_time();')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]442 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]443 func_body.append(' size_t totStringSize = 0;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]444 func_body.append(' uint32_t i = 0;')
445 func_body.append(' for (i = 0; i < *pOutLayerCount; i++)')
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]446 func_body.append(' totStringSize += (pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1: 0;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]447 func_body.append(' CREATE_TRACE_PACKET(xgl%s, totStringSize + sizeof(size_t));' % (proto.name))
Jon Ashburn04baf7a2015-02-02 12:39:24 -0700[diff] [blame]448 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
Tobin Ehlis271e51d2015-01-20 13:50:59 -0700[diff] [blame]449 elif 'AllocDescriptorSets' == proto.name:
Jon Ashburn04baf7a2015-02-02 12:39:24 -0700[diff] [blame]450 func_body.append(' uint64_t startTime;')
451 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
452 func_body.append(' startTime = glv_get_time();')
Tobin Ehlis271e51d2015-01-20 13:50:59 -0700[diff] [blame]453 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
454 func_body.append(' size_t customSize = (*pCount <= 0) ? (sizeof(XGL_DESCRIPTOR_SET)) : (*pCount * sizeof(XGL_DESCRIPTOR_SET));')
455 func_body.append(' CREATE_TRACE_PACKET(xglAllocDescriptorSets, sizeof(XGL_DESCRIPTOR_SET_LAYOUT) + customSize + sizeof(uint32_t));')
Jon Ashburn04baf7a2015-02-02 12:39:24 -0700[diff] [blame]456 func_body.append(' pHeader->entrypoint_begin_time = startTime;')
Jon Ashburn459a1372015-02-04 08:50:35 -0700[diff] [blame]457 elif proto.name in ['CreateShader', 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'CreateDynamicViewportState',
Jon Ashburn46224542015-02-04 09:32:59 -0700[diff] [blame]458 'AllocMemory', 'CreateGraphicsPipeline', 'CreateComputePipeline', 'UpdateDescriptors', 'CreateDescriptorSetLayout',
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]459 'CreateDescriptorRegion', 'CmdWaitEvents', 'CmdPipelineBarrier']:
Jon Ashburn04baf7a2015-02-02 12:39:24 -0700[diff] [blame]460 # these are regular case as far as sequence of tracing but custom sizes
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]461 func_body.append(' size_t customSize;')
462 if 'CreateShader' == proto.name:
463 func_body.append(' customSize = (pCreateInfo != NULL) ? pCreateInfo->codeSize : 0;')
464 func_body.append(' CREATE_TRACE_PACKET(xglCreateShader, sizeof(XGL_SHADER_CREATE_INFO) + sizeof(XGL_SHADER) + customSize);')
465 elif 'CreateGraphicsPipeline' == proto.name:
466 func_body.append(' customSize = calculate_pipeline_state_size(pCreateInfo->pNext);')
467 func_body.append(' CREATE_TRACE_PACKET(xglCreateGraphicsPipeline, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + customSize);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]468 elif 'UpdateDescriptors' == proto.name:
469 func_body.append(' customSize = calculate_update_descriptors_size(pUpdateChain);')
470 func_body.append(' CREATE_TRACE_PACKET(xglUpdateDescriptors, sizeof(XGL_DESCRIPTOR_SET) + customSize);')
471 elif 'CreateDescriptorSetLayout' == proto.name:
472 func_body.append(' customSize = calculate_create_ds_layout_size(pSetLayoutInfoList);')
473 # NOTE : Just allocating enough packet size to account for largest array of uints
Jon Ashburn629f8002015-02-04 10:55:47 -0700[diff] [blame]474 func_body.append(' CREATE_TRACE_PACKET(xglCreateDescriptorSetLayout, XGL_SHADER_STAGE_COMPUTE * sizeof(uint32_t) + sizeof(XGL_DESCRIPTOR_SET_LAYOUT) + customSize);')
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]475 elif 'CreateFramebuffer' == proto.name:
476 func_body.append(' int dsSize = (pCreateInfo != NULL && pCreateInfo->pDepthStencilAttachment != NULL) ? sizeof(XGL_DEPTH_STENCIL_BIND_INFO) : 0;')
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]477 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && pCreateInfo->pColorAttachments != NULL) ? pCreateInfo->colorAttachmentCount : 0;')
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]478 func_body.append(' customSize = colorCount * sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) + dsSize;')
479 func_body.append(' CREATE_TRACE_PACKET(xglCreateFramebuffer, sizeof(XGL_FRAMEBUFFER_CREATE_INFO) + sizeof(XGL_FRAMEBUFFER) + customSize);')
480 elif 'CreateRenderPass' == proto.name:
Jon Ashburn002e8632015-02-20 10:30:32 -0700[diff] [blame]481 func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && (pCreateInfo->pColorLoadOps != NULL || pCreateInfo->pColorStoreOps != NULL || pCreateInfo->pColorLoadClearValues != NULL)) ? pCreateInfo->colorAttachmentCount : 0;')
482 func_body.append(' customSize = colorCount * ((pCreateInfo->pColorLoadOps != NULL) ? sizeof(XGL_ATTACHMENT_LOAD_OP) : 0);')
483 func_body.append(' customSize += colorCount * ((pCreateInfo->pColorStoreOps != NULL) ? sizeof(XGL_ATTACHMENT_STORE_OP) : 0);')
484 func_body.append(' customSize += colorCount * ((pCreateInfo->pColorLoadClearValues != NULL) ? sizeof(XGL_CLEAR_COLOR) : 0);')
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]485 func_body.append(' CREATE_TRACE_PACKET(xglCreateRenderPass, sizeof(XGL_RENDER_PASS_CREATE_INFO) + sizeof(XGL_RENDER_PASS) + customSize);')
486 elif 'BeginCommandBuffer' == proto.name:
487 func_body.append(' customSize = calculate_begin_cmdbuf_size(pBeginInfo->pNext);')
488 func_body.append(' CREATE_TRACE_PACKET(xglBeginCommandBuffer, sizeof(XGL_CMD_BUFFER_BEGIN_INFO) + customSize);')
Jon Ashburn459a1372015-02-04 08:50:35 -0700[diff] [blame]489 elif 'CreateDynamicViewportState' == proto.name:
Courtney Goeltzenleuchterbbe3cc52015-02-11 14:13:34 -0700[diff] [blame]490 func_body.append(' uint32_t vpsCount = (pCreateInfo != NULL && pCreateInfo->pViewports != NULL) ? pCreateInfo->viewportAndScissorCount : 0;')
491 func_body.append(' customSize = vpsCount * sizeof(XGL_VIEWPORT) + vpsCount * sizeof(XGL_RECT);')
Jon Ashburn459a1372015-02-04 08:50:35 -0700[diff] [blame]492 func_body.append(' CREATE_TRACE_PACKET(xglCreateDynamicViewportState, sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO) + sizeof(XGL_DYNAMIC_VP_STATE_OBJECT) + customSize);')
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]493 elif 'AllocMemory' == proto.name:
494 func_body.append(' customSize = calculate_alloc_memory_size(pAllocInfo->pNext);')
495 func_body.append(' CREATE_TRACE_PACKET(xglAllocMemory, sizeof(XGL_MEMORY_ALLOC_INFO) + sizeof(XGL_GPU_MEMORY) + customSize);')
Jon Ashburn46224542015-02-04 09:32:59 -0700[diff] [blame]496 elif 'CreateDescriptorRegion' == proto.name:
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]497 func_body.append(' uint32_t rgCount = (pCreateInfo != NULL && pCreateInfo->pTypeCount != NULL) ? pCreateInfo->count : 0;')
Jon Ashburn46224542015-02-04 09:32:59 -0700[diff] [blame]498 func_body.append(' customSize = rgCount * sizeof(XGL_DESCRIPTOR_TYPE_COUNT);')
499 func_body.append(' CREATE_TRACE_PACKET(xglCreateDescriptorRegion, sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO) + sizeof(XGL_DESCRIPTOR_REGION) + customSize);')
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]500 elif proto.name in ['CmdWaitEvents', 'CmdPipelineBarrier']:
501 event_array_type = 'XGL_EVENT'
502 if 'CmdPipelineBarrier' == proto.name:
503 event_array_type = 'XGL_SET_EVENT'
504 func_body.append(' uint32_t eventCount = (%s != NULL && %s->pEvents != NULL) ? %s->eventCount : 0;' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].name))
505 func_body.append(' uint32_t mbCount = (%s != NULL && %s->ppMemBarriers != NULL) ? %s->memBarrierCount : 0;' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].name))
Jon Ashburn308cc4c2015-02-10 13:49:30 -0700[diff] [blame]506 func_body.append(' customSize = (eventCount * sizeof(%s)) + mbCount * sizeof(void*) + calculate_memory_barrier_size(mbCount, %s->ppMemBarriers);' % (event_array_type, proto.params[-1].name))
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]507 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(%s) + customSize);' % (proto.name, proto.params[-1].ty.strip('*').replace('const ', '')))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]508 else: #'CreateComputePipeline'
509 func_body.append(' customSize = calculate_pipeline_state_size(pCreateInfo->pNext);')
510 func_body.append(' CREATE_TRACE_PACKET(xglCreateComputePipeline, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + customSize + calculate_pipeline_shader_size(&pCreateInfo->cs));')
511 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
512 else:
513 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))
514 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Jon Ashburne3a667c2015-02-11 09:32:29 -0700[diff] [blame]515 if in_data_size:
516 func_body.append(' _dataSize = (pDataSize == NULL || pData == NULL) ? 0 : *pDataSize;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]517 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
518 func_body.append(packet_update_txt.strip('\n'))
519 if 'MapMemory' == proto.name: # Custom code for MapMem case
520 func_body.append(' if (ppData != NULL)')
521 func_body.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]522 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppData), sizeof(void*), *ppData);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]523 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));')
524 func_body.append(' add_data_to_mem_info(mem, *ppData);')
525 func_body.append(' }')
526 func_body.append(' pPacket->result = result;')
527 func_body.append(' FINISH_TRACE_PACKET();')
528 elif 'EnumerateLayers' == proto.name: #custom code for EnumerateLayers case
529 func_body.append(' pPacket->gpu = gpu;')
530 func_body.append(' pPacket->maxLayerCount = maxLayerCount;')
531 func_body.append(' pPacket->maxStringSize = maxStringSize;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]532 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayerCount), sizeof(size_t), pOutLayerCount);')
Mark Lobodzinski391bb6d2015-01-09 15:12:03 -0600[diff] [blame]533 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayerCount));')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]534 func_body.append(' for (i = 0; i < *pOutLayerCount; i++) {')
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]535 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayers[i]), ((pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1 : 0), pOutLayers[i]);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]536 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayers[i]));')
537 func_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]538
539 func_body.append(' pPacket->pReserved = pReserved;')
540 func_body.append(' pPacket->result = result;')
541 func_body.append(' FINISH_TRACE_PACKET();')
542 else:
543 # TODO : Clean this up. Too much custom code and branching.
544 for idx in buff_ptr_indices:
545 if 'DEVICE_CREATE_INFO' in proto.params[idx].ty:
546 func_body.append(' add_XGL_DEVICE_CREATE_INFO_to_packet(pHeader, (XGL_DEVICE_CREATE_INFO**) &(pPacket->pCreateInfo), pCreateInfo);')
Jon Ashburnd07dfef2015-02-03 08:57:28 -0700[diff] [blame]547 elif 'APPLICATION_INFO' in proto.params[idx].ty:
548 func_body.append(' add_XGL_APPLICATION_INFO_to_packet(pHeader, (XGL_APPLICATION_INFO**)&(pPacket->pAppInfo), pAppInfo);')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]549 elif 'char' in proto.params[idx].ty:
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]550 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 Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]551 elif 'Count' in proto.params[idx-1].name and 'queryCount' != proto.params[idx-1].name:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]552 deref = ''
553 if '*' in proto.params[idx-1].ty:
554 deref = '*'
555 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s%s*sizeof(%s), %s);' % (proto.params[idx].name, deref, proto.params[idx-1].name, proto.params[idx].ty.strip('*').replace('const ', ''), proto.params[idx].name))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]556 elif 'dataSize' == proto.params[idx].name:
557 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSize, %s);' % (proto.params[idx].name, proto.params[idx].name))
558 elif 'pDataSize' == proto.params[idx].name:
Jon Ashburne3a667c2015-02-11 09:32:29 -0700[diff] [blame]559 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(size_t), &_dataSize);' % (proto.params[idx].name))
Tobin Ehlis271e51d2015-01-20 13:50:59 -0700[diff] [blame]560 elif 'pDescriptorSets' == proto.params[idx].name and 'AllocDescriptorSets' == proto.name:
561 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]562 elif 'pData' == proto.params[idx].name:
563 if 'dataSize' == proto.params[idx-1].name:
564 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSize, %s);' % (proto.params[idx].name, proto.params[idx].name))
565 elif in_data_size:
Jon Ashburne3a667c2015-02-11 09:32:29 -0700[diff] [blame]566 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), _dataSize, %s);' % (proto.params[idx].name, proto.params[idx].name))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]567 else:
568 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), (pDataSize != NULL && pData != NULL) ? *pDataSize : 0, %s);' % (proto.params[idx].name, proto.params[idx].name))
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]569 elif 'pUpdateChain' == proto.params[idx].name:
Jon Ashburn9c246bc2015-02-04 12:57:25 -0700[diff] [blame]570 pass
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]571 else:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]572 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 Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]573 # Some custom add_* and finalize_* function calls for Create* API calls
Jon Ashburn459a1372015-02-04 08:50:35 -0700[diff] [blame]574 if proto.name in ['CreateShader', 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'CreateDynamicViewportState',
Jon Ashburn46224542015-02-04 09:32:59 -0700[diff] [blame]575 'AllocMemory', 'UpdateDescriptors', 'CreateDescriptorSetLayout', 'CreateGraphicsPipeline', 'CreateComputePipeline',
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]576 'CreateDescriptorRegion', 'CmdWaitEvents', 'CmdPipelineBarrier']:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]577 if 'CreateShader' == proto.name:
578 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), customSize, pCreateInfo->pCode);')
579 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));')
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]580 elif 'CreateFramebuffer' == proto.name:
581 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments), colorCount * sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO), pCreateInfo->pColorAttachments);')
582 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment), dsSize, pCreateInfo->pDepthStencilAttachment);')
583 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments));')
584 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment));')
585 elif 'CreateRenderPass' == proto.name:
586 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps), colorCount * sizeof(XGL_ATTACHMENT_LOAD_OP), pCreateInfo->pColorLoadOps);')
587 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps), colorCount * sizeof(XGL_ATTACHMENT_STORE_OP), pCreateInfo->pColorStoreOps);')
588 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues), colorCount * sizeof(XGL_CLEAR_COLOR), pCreateInfo->pColorLoadClearValues);')
589 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps));')
590 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps));')
591 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues));')
592 elif 'BeginCommandBuffer' == proto.name:
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]593 func_body.append(' add_begin_cmdbuf_to_trace_packet(pHeader, (void**)&(pPacket->pBeginInfo->pNext), pBeginInfo->pNext);')
Jon Ashburn459a1372015-02-04 08:50:35 -0700[diff] [blame]594 elif 'CreateDynamicViewportState' == proto.name:
Courtney Goeltzenleuchterbbe3cc52015-02-11 14:13:34 -0700[diff] [blame]595 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pViewports), vpsCount * sizeof(XGL_VIEWPORT), pCreateInfo->pViewports);')
596 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pScissors), vpsCount * sizeof(XGL_RECT), pCreateInfo->pScissors);')
Jon Ashburn459a1372015-02-04 08:50:35 -0700[diff] [blame]597 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pViewports));')
598 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pScissors));')
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]599 elif 'AllocMemory' == proto.name:
600 func_body.append(' add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo->pNext), pAllocInfo->pNext);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]601 elif 'CreateGraphicsPipeline' == proto.name:
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]602 func_body.append(' add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]603 elif 'UpdateDescriptors' == proto.name:
604 func_body.append(' add_update_descriptors_to_trace_packet(pHeader, (void**)&(pPacket->pUpdateChain), pUpdateChain);')
605 elif 'CreateDescriptorSetLayout' == proto.name:
Jon Ashburn1edd8842015-02-09 09:43:26 -0700[diff] [blame]606 func_body.append(' if (pSetLayoutInfoList)')
607 func_body.append(' add_create_ds_layout_to_trace_packet(pHeader, (void**)&(pPacket->pSetLayoutInfoList->pNext), pSetLayoutInfoList->pNext);')
Jon Ashburn46224542015-02-04 09:32:59 -0700[diff] [blame]608 elif 'CreateDescriptorRegion' == proto.name:
609 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), rgCount * sizeof(XGL_DESCRIPTOR_TYPE_COUNT), pCreateInfo->pTypeCount);')
610 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));')
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]611 elif proto.name in ['CmdWaitEvents', 'CmdPipelineBarrier']:
612 event_array_type = 'XGL_EVENT'
613 if 'CmdPipelineBarrier' == proto.name:
614 event_array_type = 'XGL_SET_EVENT'
615 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->pEvents), eventCount * sizeof(%s), %s->pEvents);' % (proto.params[-1].name, event_array_type, proto.params[-1].name))
616 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->pEvents));' % (proto.params[-1].name))
617 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->ppMemBarriers), mbCount * sizeof(void*), %s->ppMemBarriers);' % (proto.params[-1].name, proto.params[-1].name))
Jon Ashburn308cc4c2015-02-10 13:49:30 -0700[diff] [blame]618 func_body.append(' uint32_t i, siz;')
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]619 func_body.append(' for (i = 0; i < mbCount; i++) {')
Jon Ashburn308cc4c2015-02-10 13:49:30 -0700[diff] [blame]620 func_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) %s->ppMemBarriers[i];' % proto.params[-1].name)
621 func_body.append(' switch (pNext->sType) {')
622 func_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:')
623 func_body.append(' siz = sizeof(XGL_MEMORY_BARRIER);')
624 func_body.append(' break;')
625 func_body.append(' case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:')
626 func_body.append(' siz = sizeof(XGL_BUFFER_MEMORY_BARRIER);')
627 func_body.append(' break;')
628 func_body.append(' case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:')
629 func_body.append(' siz = sizeof(XGL_IMAGE_MEMORY_BARRIER);')
630 func_body.append(' break;')
631 func_body.append(' default:')
632 func_body.append(' assert(0);')
633 func_body.append(' siz = 0;')
634 func_body.append(' break;')
635 func_body.append(' }')
636 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->ppMemBarriers[i]), siz, %s->ppMemBarriers[i]);' % (proto.params[-1].name, proto.params[-1].name))
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]637 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->ppMemBarriers[i]));' % (proto.params[-1].name))
638 func_body.append(' }')
639 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->ppMemBarriers));' % (proto.params[-1].name))
Jon Ashburn46224542015-02-04 09:32:59 -0700[diff] [blame]640 else: #'CreateComputePipeline'
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]641 func_body.append(' add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]642 func_body.append(' add_pipeline_shader_to_trace_packet(pHeader, (XGL_PIPELINE_SHADER*)&pPacket->pCreateInfo->cs, &pCreateInfo->cs);')
643 func_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->pCreateInfo->cs);')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]644 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]645 func_body.append(' pPacket->result = result;')
646 for idx in buff_ptr_indices:
Jon Ashburn9c246bc2015-02-04 12:57:25 -0700[diff] [blame]647 if ('DEVICE_CREATE_INFO' not in proto.params[idx].ty) and ('APPLICATION_INFO' not in proto.params[idx].ty) and ('pUpdateChain' != proto.params[idx].name):
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]648 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))
649 func_body.append(' FINISH_TRACE_PACKET();')
650 if 'AllocMemory' in proto.name:
651 func_body.append(' add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);')
652 elif 'FreeMemory' in proto.name:
653 func_body.append(' rm_handle_from_mem_info(mem);')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]654 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]655 func_body.append(' return result;')
656 func_body.append('}\n')
657 return "\n".join(func_body)
658
659 def _generate_trace_funcs_ext(self, func_class='Wsi'):
660 thread_once_funcs = ['DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback', 'DbgSetGlobalOption']
661 func_body = []
662 for proto in self.protos:
663 if func_class in proto.name:
664 packet_update_txt = ''
665 return_txt = ''
666 packet_size = ''
667 buff_ptr_indices = []
668 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
669 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL
670 func_body.append(' %s %s,' % (p.ty, p.name))
671 if 'Size' in p.name:
672 packet_size += p.name
673 if '*' in p.ty and 'pSysMem' != p.name:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]674 if 'char' in p.ty:
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]675 packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]676 elif 'Size' not in packet_size:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]677 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]678 buff_ptr_indices.append(proto.params.index(p))
679 if 'pConnectionInfo' in p.name:
680 packet_size += '((pConnectionInfo->pConnection != NULL) ? sizeof(void *) : 0)'
681 else:
682 packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)
683 if '' == packet_size:
684 packet_size = '0'
685 else:
686 packet_size = packet_size.strip(' + ')
687 func_body[-1] = func_body[-1].replace(',', ')')
688 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]689 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]690 func_body.append(' %s result;' % proto.ret)
691 return_txt = 'result = '
692 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
693 if proto.name in thread_once_funcs:
694 func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')
695 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
Ian Elliott5890a772015-02-27 11:10:59 -0700[diff] [blame]696 if 'DbgRegisterMsgCallback' in proto.name:
697 func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(char));' % proto.name)
698 else:
699 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]700 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
701 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
702 func_body.append(packet_update_txt.strip('\n'))
703 for idx in buff_ptr_indices:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]704 if 'char' in proto.params[idx].ty:
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]705 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 Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]706 elif 'Size' in proto.params[idx-1].name:
707 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 Elliott5890a772015-02-27 11:10:59 -0700[diff] [blame]708 elif 'DbgRegisterMsgCallback' in proto.name:
709 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 Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]710 else:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]711 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 Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]712 if 'WsiX11AssociateConnection' in proto.name:
713 func_body.append(' if (pConnectionInfo->pConnection != NULL) {')
714 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection), sizeof(void *), pConnectionInfo->pConnection);')
715 func_body.append(' glv_finalize_buffer_address(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection));')
716 func_body.append(' }')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]717 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]718 func_body.append(' pPacket->result = result;')
719 for idx in buff_ptr_indices:
720 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))
721 func_body.append(' FINISH_TRACE_PACKET();')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]722 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]723 func_body.append(' return result;')
724 func_body.append('}\n')
725 return "\n".join(func_body)
726
727 def _generate_helper_funcs(self):
728 hf_body = []
729 hf_body.append('// Support for shadowing CPU mapped memory')
730 hf_body.append('typedef struct _XGLAllocInfo {')
731 hf_body.append(' XGL_GPU_SIZE size;')
732 hf_body.append(' XGL_GPU_MEMORY handle;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]733 hf_body.append(' void *pData;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]734 hf_body.append(' BOOL valid;')
735 hf_body.append('} XGLAllocInfo;')
736 hf_body.append('typedef struct _XGLMemInfo {')
737 hf_body.append(' unsigned int numEntrys;')
738 hf_body.append(' XGLAllocInfo *pEntrys;')
739 hf_body.append(' XGLAllocInfo *pLastMapped;')
740 hf_body.append(' unsigned int capacity;')
741 hf_body.append('} XGLMemInfo;')
742 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]743 hf_body.append('static XGLMemInfo g_memInfo = {0, NULL, NULL, 0};')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]744 hf_body.append('')
745 hf_body.append('static void init_mem_info_entrys(XGLAllocInfo *ptr, const unsigned int num)')
746 hf_body.append('{')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]747 hf_body.append(' unsigned int i;')
748 hf_body.append(' for (i = 0; i < num; i++)')
749 hf_body.append(' {')
750 hf_body.append(' XGLAllocInfo *entry = ptr + i;')
751 hf_body.append(' entry->pData = NULL;')
752 hf_body.append(' entry->size = 0;')
753 hf_body.append(' entry->handle = NULL;')
754 hf_body.append(' entry->valid = FALSE;')
755 hf_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]756 hf_body.append('}')
757 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]758 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]759 hf_body.append('static void init_mem_info()')
760 hf_body.append('{')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]761 hf_body.append(' g_memInfo.numEntrys = 0;')
Jon Ashburna95f4382015-02-20 14:48:27 -0700[diff] [blame]762 hf_body.append(' g_memInfo.capacity = 4096;')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]763 hf_body.append(' g_memInfo.pLastMapped = NULL;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]764 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]765 hf_body.append(' g_memInfo.pEntrys = GLV_NEW_ARRAY(XGLAllocInfo, g_memInfo.capacity);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]766 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]767 hf_body.append(' if (g_memInfo.pEntrys == NULL)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]768 hf_body.append(' glv_LogError("init_mem_info() malloc failed\\n");')
769 hf_body.append(' else')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]770 hf_body.append(' init_mem_info_entrys(g_memInfo.pEntrys, g_memInfo.capacity);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]771 hf_body.append('}')
772 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]773 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]774 hf_body.append('static void delete_mem_info()')
775 hf_body.append('{')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]776 hf_body.append(' GLV_DELETE(g_memInfo.pEntrys);')
777 hf_body.append(' g_memInfo.pEntrys = NULL;')
778 hf_body.append(' g_memInfo.numEntrys = 0;')
779 hf_body.append(' g_memInfo.capacity = 0;')
780 hf_body.append(' g_memInfo.pLastMapped = NULL;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]781 hf_body.append('}')
782 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]783 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]784 hf_body.append('static XGLAllocInfo * get_mem_info_entry()')
785 hf_body.append('{')
786 hf_body.append(' unsigned int i;')
787 hf_body.append(' XGLAllocInfo *entry;')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]788 hf_body.append(' if (g_memInfo.numEntrys > g_memInfo.capacity)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]789 hf_body.append(' {')
Jon Ashburna95f4382015-02-20 14:48:27 -0700[diff] [blame]790 hf_body.append(' glv_LogError("get_mem_info_entry() bad internal state numEntrys %u\\n", g_memInfo.numEntrys);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]791 hf_body.append(' return NULL;')
792 hf_body.append(' }')
793 hf_body.append('')
Jon Ashburna95f4382015-02-20 14:48:27 -0700[diff] [blame]794 hf_body.append(' entry = g_memInfo.pEntrys;')
795 hf_body.append(' for (i = 0; i < g_memInfo.numEntrys; i++)')
796 hf_body.append(' {')
797 hf_body.append(' if ((entry + i)->valid == FALSE)')
798 hf_body.append(' return entry + i;')
799 hf_body.append(' }')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]800 hf_body.append(' if (g_memInfo.numEntrys == g_memInfo.capacity)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]801 hf_body.append(' { // grow the array 2x')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]802 hf_body.append(' g_memInfo.capacity *= 2;')
803 hf_body.append(' g_memInfo.pEntrys = (XGLAllocInfo *) GLV_REALLOC(g_memInfo.pEntrys, g_memInfo.capacity * sizeof(XGLAllocInfo));')
Jon Ashburna95f4382015-02-20 14:48:27 -0700[diff] [blame]804 hf_body.append(' if (g_memInfo.pEntrys == NULL)')
805 hf_body.append(' glv_LogError("get_mem_info_entry() realloc failed\\n");')
806 hf_body.append(' //glv_LogInfo("realloc memInfo from %u to %u\\n", g_memInfo.capacity /2, g_memInfo.capacity);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]807 hf_body.append(' //init the newly added entrys')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]808 hf_body.append(' init_mem_info_entrys(g_memInfo.pEntrys + g_memInfo.capacity / 2, g_memInfo.capacity / 2);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]809 hf_body.append(' }')
810 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]811 hf_body.append(' assert(g_memInfo.numEntrys < g_memInfo.capacity);')
Jon Ashburna95f4382015-02-20 14:48:27 -0700[diff] [blame]812 hf_body.append(' entry = g_memInfo.pEntrys + g_memInfo.numEntrys;')
813 hf_body.append(' g_memInfo.numEntrys++;')
814 hf_body.append(' assert(entry->valid == FALSE);')
815 hf_body.append(' return entry;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]816 hf_body.append('}')
817 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]818 hf_body.append('// caller must hold the g_memInfoLock')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]819 hf_body.append('static XGLAllocInfo * find_mem_info_entry(const XGL_GPU_MEMORY handle)')
820 hf_body.append('{')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]821 hf_body.append(' XGLAllocInfo *entry;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]822 hf_body.append(' unsigned int i;')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]823 hf_body.append(' entry = g_memInfo.pEntrys;')
824 hf_body.append(' if (g_memInfo.pLastMapped && g_memInfo.pLastMapped->handle == handle && g_memInfo.pLastMapped->valid)')
825 hf_body.append(' {')
826 hf_body.append(' return g_memInfo.pLastMapped;')
827 hf_body.append(' }')
828 hf_body.append(' for (i = 0; i < g_memInfo.numEntrys; i++)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]829 hf_body.append(' {')
830 hf_body.append(' if ((entry + i)->valid && (handle == (entry + i)->handle))')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]831 hf_body.append(' {')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]832 hf_body.append(' return entry + i;')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]833 hf_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]834 hf_body.append(' }')
835 hf_body.append('')
836 hf_body.append(' return NULL;')
837 hf_body.append('}')
838 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]839 hf_body.append('static XGLAllocInfo * find_mem_info_entry_lock(const XGL_GPU_MEMORY handle)')
840 hf_body.append('{')
841 hf_body.append(' XGLAllocInfo *res;')
842 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
843 hf_body.append(' res = find_mem_info_entry(handle);')
844 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
845 hf_body.append(' return res;')
846 hf_body.append('}')
847 hf_body.append('')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]848 hf_body.append('static void add_new_handle_to_mem_info(const XGL_GPU_MEMORY handle, XGL_GPU_SIZE size, void *pData)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]849 hf_body.append('{')
850 hf_body.append(' XGLAllocInfo *entry;')
851 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]852 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
853 hf_body.append(' if (g_memInfo.capacity == 0)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]854 hf_body.append(' init_mem_info();')
855 hf_body.append('')
856 hf_body.append(' entry = get_mem_info_entry();')
857 hf_body.append(' if (entry)')
858 hf_body.append(' {')
859 hf_body.append(' entry->valid = TRUE;')
860 hf_body.append(' entry->handle = handle;')
861 hf_body.append(' entry->size = size;')
862 hf_body.append(' entry->pData = pData; // NOTE: xglFreeMemory will free this mem, so no malloc()')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]863 hf_body.append(' }')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]864 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]865 hf_body.append('}')
866 hf_body.append('')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]867 hf_body.append('static void add_data_to_mem_info(const XGL_GPU_MEMORY handle, void *pData)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]868 hf_body.append('{')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]869 hf_body.append(' XGLAllocInfo *entry;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]870 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]871 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
872 hf_body.append(' entry = find_mem_info_entry(handle);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]873 hf_body.append(' if (entry)')
874 hf_body.append(' {')
875 hf_body.append(' entry->pData = pData;')
876 hf_body.append(' }')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]877 hf_body.append(' g_memInfo.pLastMapped = entry;')
878 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]879 hf_body.append('}')
880 hf_body.append('')
881 hf_body.append('static void rm_handle_from_mem_info(const XGL_GPU_MEMORY handle)')
882 hf_body.append('{')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]883 hf_body.append(' XGLAllocInfo *entry;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]884 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]885 hf_body.append(' glv_enter_critical_section(&g_memInfoLock);')
886 hf_body.append(' entry = find_mem_info_entry(handle);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]887 hf_body.append(' if (entry)')
888 hf_body.append(' {')
889 hf_body.append(' entry->valid = FALSE;')
890 hf_body.append(' entry->pData = NULL;')
891 hf_body.append(' entry->size = 0;')
892 hf_body.append(' entry->handle = NULL;')
893 hf_body.append('')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]894 hf_body.append(' if (entry == g_memInfo.pLastMapped)')
895 hf_body.append(' g_memInfo.pLastMapped = NULL;')
Jon Ashburna20b67b2015-02-26 11:45:28 -0700[diff] [blame]896 hf_body.append(' // adjust numEntrys to be last valid entry in list')
897 hf_body.append(' do {')
898 hf_body.append(' entry = g_memInfo.pEntrys + g_memInfo.numEntrys - 1;')
899 hf_body.append(' if (entry->valid == FALSE)')
900 hf_body.append(' g_memInfo.numEntrys--;')
901 hf_body.append(' } while ((entry->valid == FALSE) && (g_memInfo.numEntrys > 0));')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]902 hf_body.append(' if (g_memInfo.numEntrys == 0)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]903 hf_body.append(' delete_mem_info();')
904 hf_body.append(' }')
Jon Ashburnf7ab1a02015-02-19 17:04:06 -0700[diff] [blame]905 hf_body.append(' glv_leave_critical_section(&g_memInfoLock);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]906 hf_body.append('}')
907 hf_body.append('')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]908 hf_body.append('static void add_begin_cmdbuf_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]909 hf_body.append('{')
910 hf_body.append(' const XGL_CMD_BUFFER_BEGIN_INFO* pInNow = pIn;')
911 hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)ppOut;')
912 hf_body.append(' while (pInNow != NULL)')
913 hf_body.append(' {')
914 hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNow = ppOutNext;')
915 hf_body.append(' ppOutNext = NULL;')
916 hf_body.append('')
917 hf_body.append(' switch (pInNow->sType)')
918 hf_body.append(' {')
919 hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')
920 hf_body.append(' {')
921 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO), pInNow);')
922 hf_body.append(' ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)&(*ppOutNow)->pNext;')
923 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
924 hf_body.append(' break;')
925 hf_body.append(' }')
926 hf_body.append(' default:')
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]927 hf_body.append(' assert(!"Encountered an unexpected type in cmdbuffer_begin_info list");')
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]928 hf_body.append(' }')
929 hf_body.append(' pInNow = (XGL_CMD_BUFFER_BEGIN_INFO*)pInNow->pNext;')
930 hf_body.append(' }')
931 hf_body.append(' return;')
932 hf_body.append('}')
Tobin Ehlisf29cc372015-01-22 12:29:31 -0700[diff] [blame]933 hf_body.append('')
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]934 hf_body.append('static size_t calculate_begin_cmdbuf_size(const XGL_CMD_BUFFER_BEGIN_INFO* pNext)')
935 hf_body.append('{')
936 hf_body.append(' size_t siz = 0;')
937 hf_body.append(' while (pNext != NULL)')
938 hf_body.append(' {')
939 hf_body.append(' switch (pNext->sType)')
940 hf_body.append(' {')
941 hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')
942 hf_body.append(' {')
943 hf_body.append(' siz += sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);')
944 hf_body.append(' break;')
945 hf_body.append(' }')
946 hf_body.append(' default:')
947 hf_body.append(' glv_LogError("calculate_begin_cmdbuf_size() bad internal state sType\\n");')
948 hf_body.append(' break;')
949 hf_body.append(' }')
950 hf_body.append(' pNext = (XGL_CMD_BUFFER_BEGIN_INFO*)pNext->pNext;')
951 hf_body.append(' }')
952 hf_body.append(' return siz;')
953 hf_body.append('}')
954 hf_body.append('')
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]955 hf_body.append('static void add_alloc_memory_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
956 hf_body.append('{')
957 hf_body.append(' const XGL_MEMORY_ALLOC_INFO* pInNow = pIn;')
958 hf_body.append(' XGL_MEMORY_ALLOC_INFO** ppOutNext = (XGL_MEMORY_ALLOC_INFO**)ppOut;')
959 hf_body.append(' while (pInNow != NULL)')
960 hf_body.append(' {')
961 hf_body.append(' XGL_MEMORY_ALLOC_INFO** ppOutNow = ppOutNext;')
962 hf_body.append(' ppOutNext = NULL;')
963 hf_body.append('')
964 hf_body.append(' switch (pInNow->sType)')
965 hf_body.append(' {')
966 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:')
967 hf_body.append(' {')
968 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO), pInNow);')
969 hf_body.append(' ppOutNext = (XGL_MEMORY_ALLOC_INFO**)&(*ppOutNow)->pNext;')
970 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
971 hf_body.append(' break;')
972 hf_body.append(' }')
973 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:')
974 hf_body.append(' {')
975 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO), pInNow);')
976 hf_body.append(' ppOutNext = (XGL_MEMORY_ALLOC_INFO**)&(*ppOutNow)->pNext;')
977 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
978 hf_body.append(' break;')
979 hf_body.append(' }')
980 hf_body.append(' default:')
981 hf_body.append(' assert(!"Encountered an unexpected type in memory_alloc_info list");')
982 hf_body.append(' }')
983 hf_body.append(' pInNow = (XGL_MEMORY_ALLOC_INFO*)pInNow->pNext;')
984 hf_body.append(' }')
985 hf_body.append(' return;')
986 hf_body.append('}')
987 hf_body.append('')
988 hf_body.append('static size_t calculate_alloc_memory_size(const XGL_MEMORY_ALLOC_INFO* pNext)')
989 hf_body.append('{')
990 hf_body.append(' size_t siz = 0;')
991 hf_body.append(' while (pNext != NULL)')
992 hf_body.append(' {')
993 hf_body.append(' switch (pNext->sType)')
994 hf_body.append(' {')
995 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:')
996 hf_body.append(' {')
997 hf_body.append(' siz += sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);')
998 hf_body.append(' break;')
999 hf_body.append(' }')
1000 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:')
1001 hf_body.append(' {')
1002 hf_body.append(' siz += sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);')
1003 hf_body.append(' break;')
1004 hf_body.append(' }')
1005 hf_body.append(' default:')
1006 hf_body.append(' glv_LogError("calculate_alloc_memory_size() bad internal state sType\\n");')
1007 hf_body.append(' break;')
1008 hf_body.append(' }')
1009 hf_body.append(' pNext = (XGL_MEMORY_ALLOC_INFO*)pNext->pNext;')
1010 hf_body.append(' }')
1011 hf_body.append(' return siz;')
1012 hf_body.append('}')
1013 hf_body.append('')
Jon Ashburn308cc4c2015-02-10 13:49:30 -0700[diff] [blame]1014 hf_body.append('static size_t calculate_memory_barrier_size(uint32_t mbCount, const void** ppMemBarriers)')
1015 hf_body.append('{')
1016 hf_body.append(' uint32_t i, siz=0;')
1017 hf_body.append(' for (i = 0; i < mbCount; i++) {')
1018 hf_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) ppMemBarriers[i];')
1019 hf_body.append(' switch (pNext->sType) {')
1020 hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:')
1021 hf_body.append(' siz += sizeof(XGL_MEMORY_BARRIER);')
1022 hf_body.append(' break;')
1023 hf_body.append(' case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:')
1024 hf_body.append(' siz += sizeof(XGL_BUFFER_MEMORY_BARRIER);')
1025 hf_body.append(' break;')
1026 hf_body.append(' case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:')
1027 hf_body.append(' siz += sizeof(XGL_IMAGE_MEMORY_BARRIER);')
1028 hf_body.append(' break;')
1029 hf_body.append(' default:')
1030 hf_body.append(' assert(0);')
1031 hf_body.append(' break;')
1032 hf_body.append(' }')
1033 hf_body.append(' }')
1034 hf_body.append(' return siz;')
1035 hf_body.append('}')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1036 hf_body.append('static size_t calculate_pipeline_shader_size(const XGL_PIPELINE_SHADER* shader)')
1037 hf_body.append('{')
1038 hf_body.append(' size_t size = 0;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1039 hf_body.append(' size += sizeof(XGL_PIPELINE_SHADER);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1040 hf_body.append(' // constant buffers')
1041 hf_body.append(' if (shader->linkConstBufferCount > 0 && shader->pLinkConstBufferInfo != NULL)')
1042 hf_body.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1043 hf_body.append(' uint32_t i;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1044 hf_body.append(' for (i = 0; i < shader->linkConstBufferCount; i++)')
1045 hf_body.append(' {')
1046 hf_body.append(' size += sizeof(XGL_LINK_CONST_BUFFER);')
1047 hf_body.append(' size += shader->pLinkConstBufferInfo[i].bufferSize;')
1048 hf_body.append(' }')
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]1049 hf_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1050 hf_body.append(' return size;')
1051 hf_body.append('}')
1052 hf_body.append('')
1053 hf_body.append('static void add_pipeline_shader_to_trace_packet(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* packetShader, const XGL_PIPELINE_SHADER* paramShader)')
1054 hf_body.append('{')
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]1055 hf_body.append(' uint32_t i;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1056 hf_body.append(' // constant buffers')
1057 hf_body.append(' if (paramShader->linkConstBufferCount > 0 && paramShader->pLinkConstBufferInfo != NULL)')
1058 hf_body.append(' {')
1059 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo), sizeof(XGL_LINK_CONST_BUFFER) * paramShader->linkConstBufferCount, paramShader->pLinkConstBufferInfo);')
1060 hf_body.append(' for (i = 0; i < paramShader->linkConstBufferCount; i++)')
1061 hf_body.append(' {')
1062 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData), packetShader->pLinkConstBufferInfo[i].bufferSize, paramShader->pLinkConstBufferInfo[i].pBufferData);')
1063 hf_body.append(' }')
1064 hf_body.append(' }')
1065 hf_body.append('}')
1066 hf_body.append('')
1067 hf_body.append('static void finalize_pipeline_shader_address(glv_trace_packet_header* pHeader, const XGL_PIPELINE_SHADER* packetShader)')
1068 hf_body.append('{')
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]1069 hf_body.append(' uint32_t i;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1070 hf_body.append(' // constant buffers')
1071 hf_body.append(' if (packetShader->linkConstBufferCount > 0 && packetShader->pLinkConstBufferInfo != NULL)')
1072 hf_body.append(' {')
1073 hf_body.append(' for (i = 0; i < packetShader->linkConstBufferCount; i++)')
1074 hf_body.append(' {')
1075 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData));')
1076 hf_body.append(' }')
1077 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo));')
1078 hf_body.append(' }')
1079 hf_body.append('}')
1080 hf_body.append('')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1081 hf_body.append('static size_t calculate_create_ds_layout_size(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo)')
1082 hf_body.append('{')
1083 hf_body.append(' size_t update_size = 0;')
1084 hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pTrav = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pCreateInfo;')
1085 hf_body.append(' while (pTrav)')
1086 hf_body.append(' {')
1087 hf_body.append(' update_size += sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);')
1088 hf_body.append(' pTrav = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pTrav->pNext;')
1089 hf_body.append(' }')
1090 hf_body.append(' return update_size;')
1091 hf_body.append('}')
1092 hf_body.append('')
1093 hf_body.append('static void add_create_ds_layout_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
1094 hf_body.append('{')
1095 hf_body.append(' const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInNow = pIn;')
1096 hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO** ppOutNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO**)ppOut;')
1097 hf_body.append(' while (pInNow != NULL)')
1098 hf_body.append(' {')
1099 hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO** ppOutNow = ppOutNext;')
1100 hf_body.append(' ppOutNext = NULL;')
1101 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), pInNow);')
1102 hf_body.append(' ppOutNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO**)&(*ppOutNow)->pNext;')
1103 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1104 hf_body.append(' pInNow = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pInNow->pNext;')
1105 hf_body.append(' }')
1106 hf_body.append(' return;')
1107 hf_body.append('}')
1108 hf_body.append('')
1109 hf_body.append('static size_t calculate_update_descriptors_size(const void* pUpdateChain)')
1110 hf_body.append('{')
1111 hf_body.append(' const XGL_UPDATE_SAMPLERS* pNext = pUpdateChain;')
1112 hf_body.append(' size_t totalUpdateSize = 0;')
1113 hf_body.append(' while (pNext)')
1114 hf_body.append(' {')
1115 hf_body.append(' switch (pNext->sType)')
1116 hf_body.append(' {')
1117 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
1118 hf_body.append(' {')
1119 hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_SAMPLERS) + ((XGL_UPDATE_SAMPLERS*)pNext)->count * sizeof(XGL_SAMPLER);')
1120 hf_body.append(' break;')
1121 hf_body.append(' }')
1122 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
1123 hf_body.append(' {')
1124 hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_SAMPLER_TEXTURES) + ((XGL_UPDATE_SAMPLER_TEXTURES*)pNext)->count * (sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));')
1125 hf_body.append(' break;')
1126 hf_body.append(' }')
1127 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
1128 hf_body.append(' {')
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]1129 hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_IMAGES) + (((XGL_UPDATE_IMAGES*)pNext)->count * (sizeof(XGL_IMAGE_VIEW_ATTACH_INFO) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO*)));')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1130 hf_body.append(' break;')
1131 hf_body.append(' }')
1132 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
1133 hf_body.append(' {')
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]1134 hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_BUFFERS) + (((XGL_UPDATE_BUFFERS*)pNext)->count * (sizeof(XGL_BUFFER_VIEW_ATTACH_INFO) + sizeof(XGL_BUFFER_VIEW_ATTACH_INFO*)));')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1135 hf_body.append(' break;')
1136 hf_body.append(' }')
1137 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
1138 hf_body.append(' {')
1139 hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_AS_COPY);')
1140 hf_body.append(' break;')
1141 hf_body.append(' }')
1142 hf_body.append(' default:')
1143 hf_body.append(' assert(0);')
1144 hf_body.append(' }')
1145 hf_body.append(' pNext = (XGL_UPDATE_SAMPLERS*)pNext->pNext;')
1146 hf_body.append(' }')
1147 hf_body.append(' return totalUpdateSize;')
1148 hf_body.append('}')
1149 hf_body.append('')
1150 hf_body.append('static void add_update_descriptors_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
1151 hf_body.append('{')
1152 hf_body.append(' const XGL_UPDATE_SAMPLERS* pInNow = pIn;')
1153 hf_body.append(' XGL_UPDATE_SAMPLERS** ppOutNext = (XGL_UPDATE_SAMPLERS**)ppOut;')
1154 hf_body.append(' while (pInNow != NULL)')
1155 hf_body.append(' {')
1156 hf_body.append(' XGL_UPDATE_SAMPLERS** ppOutNow = ppOutNext;')
1157 hf_body.append(' ppOutNext = NULL;')
1158 hf_body.append(' switch (pInNow->sType)')
1159 hf_body.append(' {')
1160 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
1161 hf_body.append(' {')
1162 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_SAMPLERS), pInNow);')
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]1163 hf_body.append(' XGL_UPDATE_SAMPLERS* pPacket = (XGL_UPDATE_SAMPLERS*)*ppOutNow;')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1164 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplers, ((XGL_UPDATE_SAMPLERS*)pInNow)->count * sizeof(XGL_SAMPLER), ((XGL_UPDATE_SAMPLERS*)pInNow)->pSamplers);')
1165 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplers));')
1166 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1167 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1168 hf_body.append(' break;')
1169 hf_body.append(' }')
1170 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
1171 hf_body.append(' {')
1172 #hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_SAMPLER_TEXTURES) + ((XGL_UPDATE_SAMPLER_TEXTURES*)pNext)->count * (sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));')
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]1173 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_SAMPLER_TEXTURES), pInNow);')
1174 hf_body.append(' XGL_UPDATE_SAMPLER_TEXTURES* pPacket = (XGL_UPDATE_SAMPLER_TEXTURES*)*ppOutNow;')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1175 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplerImageViews, ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->count * sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO), ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->pSamplerImageViews);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1176 # TODO : This is still broken. How to update the original XGL_SAMPLER_IMAGE_VIEW_INFO struct ptrs to have correct address for newly added XGL_IMAGE_VIEW_ATTACH_INFO blocks below?
1177 hf_body.append(' uint32_t i;')
1178 hf_body.append(' for (i = 0; i < ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->count; i++) {')
Jon Ashburn9c246bc2015-02-04 12:57:25 -0700[diff] [blame]1179 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplerImageViews[i].pImageView, sizeof(XGL_IMAGE_VIEW_ATTACH_INFO), ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->pSamplerImageViews[i].pImageView);')
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]1180 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplerImageViews[i].pImageView));')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1181 hf_body.append(' }')
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]1182 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplerImageViews));')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1183 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1184 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1185 hf_body.append(' break;')
1186 hf_body.append(' }')
1187 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
1188 hf_body.append(' {')
1189 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_IMAGES), pInNow);')
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]1190 hf_body.append(' XGL_UPDATE_IMAGES* pPacket = (XGL_UPDATE_IMAGES*)*ppOutNow;')
Jon Ashburna04529d2015-02-04 16:26:30 -0700[diff] [blame]1191 hf_body.append(' uint32_t i;')
1192 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pImageViews, ((XGL_UPDATE_IMAGES*)pInNow)->count * sizeof(XGL_IMAGE_VIEW_ATTACH_INFO *), ((XGL_UPDATE_IMAGES*)pInNow)->pImageViews);')
1193 hf_body.append(' for (i = 0; i < ((XGL_UPDATE_IMAGES*)pInNow)->count; i++) {')
1194 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pImageViews[i], sizeof(XGL_IMAGE_VIEW_ATTACH_INFO), ((XGL_UPDATE_IMAGES*)pInNow)->pImageViews[i]);')
1195 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImageViews[i]));')
1196 hf_body.append(' }')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1197 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImageViews));')
1198 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1199 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1200 hf_body.append(' break;')
1201 hf_body.append(' }')
1202 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
1203 hf_body.append(' {')
1204 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_BUFFERS), pInNow);')
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]1205 hf_body.append(' XGL_UPDATE_BUFFERS* pPacket = (XGL_UPDATE_BUFFERS*)*ppOutNow;')
Jon Ashburna04529d2015-02-04 16:26:30 -0700[diff] [blame]1206 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pBufferViews, ((XGL_UPDATE_BUFFERS*)pInNow)->count * sizeof(XGL_BUFFER_VIEW_ATTACH_INFO *), ((XGL_UPDATE_BUFFERS*)pInNow)->pBufferViews);')
1207 hf_body.append(' uint32_t i;')
1208 hf_body.append(' for (i = 0; i < ((XGL_UPDATE_BUFFERS*)pInNow)->count; i++) {')
1209 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pBufferViews[i], sizeof(XGL_BUFFER_VIEW_ATTACH_INFO), ((XGL_UPDATE_BUFFERS*)pInNow)->pBufferViews[i]);')
1210 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBufferViews[i]));')
1211 hf_body.append(' }')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]1212 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBufferViews));')
1213 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1214 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1215 hf_body.append(' break;')
1216 hf_body.append(' }')
1217 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
1218 hf_body.append(' {')
1219 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_AS_COPY), pInNow);')
1220 hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')
1221 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1222 hf_body.append(' break;')
1223 hf_body.append(' }')
1224 hf_body.append(' default:')
1225 hf_body.append(' assert(0);')
1226 hf_body.append(' }')
1227 hf_body.append(' pInNow = (XGL_UPDATE_SAMPLERS*)pInNow->pNext;')
1228 hf_body.append(' }')
1229 hf_body.append(' return;')
1230 hf_body.append('}')
1231 hf_body.append('')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1232 hf_body.append('static size_t calculate_pipeline_state_size(const void* pState)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1233 hf_body.append('{')
1234 hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pNext = pState;')
1235 hf_body.append(' size_t totalStateSize = 0;')
1236 hf_body.append(' while (pNext)')
1237 hf_body.append(' {')
1238 hf_body.append(' switch (pNext->sType)')
1239 hf_body.append(' {')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]1240 pipe_state_list = ['IA_STATE_CREATE_INFO',
1241 'TESS_STATE_CREATE_INFO',
1242 'RS_STATE_CREATE_INFO',
1243 'DS_STATE_CREATE_INFO',
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]1244 'VP_STATE_CREATE_INFO',
1245 'MS_STATE_CREATE_INFO'
1246 ]
1247 for pipe_state in pipe_state_list:
1248 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_%s:' % pipe_state)
1249 hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_%s);' % pipe_state)
1250 hf_body.append(' break;')
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]1251 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')
1252 hf_body.append(' {')
1253 hf_body.append(' totalStateSize += (sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO) + ((XGL_PIPELINE_CB_STATE_CREATE_INFO *) pNext)->attachmentCount * sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE));')
1254 hf_body.append(' break;')
1255 hf_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1256 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')
1257 hf_body.append(' {')
1258 hf_body.append(' const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pShaderStage = (const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext;')
1259 hf_body.append(' totalStateSize += (sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO) + calculate_pipeline_shader_size(&pShaderStage->shader));')
1260 hf_body.append(' break;')
1261 hf_body.append(' }')
1262 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')
1263 hf_body.append(' {')
1264 hf_body.append(' const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVi = (const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pNext;')
1265 hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO) + pVi->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION)')
1266 hf_body.append(' + pVi->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);')
1267 hf_body.append(' break;')
1268 hf_body.append(' }')
1269 hf_body.append(' default:')
1270 hf_body.append(' assert(0);')
1271 hf_body.append(' }')
1272 hf_body.append(' pNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pNext->pNext;')
1273 hf_body.append(' }')
1274 hf_body.append(' return totalStateSize;')
1275 hf_body.append('}')
1276 hf_body.append('')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1277 hf_body.append('static void add_pipeline_state_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1278 hf_body.append('{')
1279 hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInNow = pIn;')
1280 hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)ppOut;')
1281 hf_body.append(' while (pInNow != NULL)')
1282 hf_body.append(' {')
1283 hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNow = ppOutNext;')
1284 hf_body.append(' ppOutNext = NULL;')
1285 hf_body.append('')
1286 hf_body.append(' switch (pInNow->sType)')
1287 hf_body.append(' {')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]1288 for pipe_state in pipe_state_list:
1289 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_%s:' % pipe_state)
1290 hf_body.append(' {')
1291 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_%s), pInNow);' % pipe_state)
1292 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1293 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1294 hf_body.append(' break;')
1295 hf_body.append(' }')
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]1296 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')
1297 hf_body.append(' {')
1298 hf_body.append(' XGL_PIPELINE_CB_STATE_CREATE_INFO *pPacket = NULL;')
1299 hf_body.append(' XGL_PIPELINE_CB_STATE_CREATE_INFO *pIn = NULL;')
1300 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO), pInNow);')
1301 hf_body.append(' pPacket = (XGL_PIPELINE_CB_STATE_CREATE_INFO*) *ppOutNow;')
1302 hf_body.append(' pIn = (XGL_PIPELINE_CB_STATE_CREATE_INFO*) pInNow;')
1303 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pAttachments, pIn->attachmentCount * sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE), pIn->pAttachments);')
1304 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAttachments));')
1305 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1306 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1307 hf_body.append(' break;')
1308 hf_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1309 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')
1310 hf_body.append(' {')
1311 hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacket = NULL;')
1312 hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInPacket = NULL;')
1313 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO), pInNow);')
1314 hf_body.append(' pPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) *ppOutNow;')
1315 hf_body.append(' pInPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) pInNow;')
1316 hf_body.append(' add_pipeline_shader_to_trace_packet(pHeader, &pPacket->shader, &pInPacket->shader);')
1317 hf_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->shader);')
1318 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1319 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1320 hf_body.append(' break;')
1321 hf_body.append(' }')
1322 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')
1323 hf_body.append(' {')
1324 hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pPacket = NULL;')
1325 hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pIn = NULL;')
1326 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO), pInNow);')
1327 hf_body.append(' pPacket = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) *ppOutNow;')
1328 hf_body.append(' pIn = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) pInNow;')
1329 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexBindingDescriptions, pIn->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION), pIn->pVertexBindingDescriptions);')
1330 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexBindingDescriptions));')
1331 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexAttributeDescriptions, pIn->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION), pIn->pVertexAttributeDescriptions);')
1332 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexAttributeDescriptions));')
1333 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1334 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1335 hf_body.append(' break;')
1336 hf_body.append(' }')
1337 hf_body.append(' default:')
1338 hf_body.append(' assert(!"Encountered an unexpected type in pipeline state list");')
1339 hf_body.append(' }')
1340 hf_body.append(' pInNow = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pInNow->pNext;')
1341 hf_body.append(' }')
1342 hf_body.append(' return;')
1343 hf_body.append('}')
1344 return "\n".join(hf_body)
1345
1346 def _generate_packet_id_enum(self):
1347 pid_enum = []
1348 pid_enum.append('enum GLV_TRACE_PACKET_ID_XGL')
1349 pid_enum.append('{')
1350 first_func = True
1351 for proto in self.protos:
1352 if first_func:
1353 first_func = False
Jon Ashburn15161e42014-12-16 18:37:04 -0700[diff] [blame]1354 pid_enum.append(' GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,')
1355 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1356 else:
1357 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
1358 pid_enum.append('};\n')
1359 return "\n".join(pid_enum)
1360
1361 def _generate_stringify_func(self):
1362 func_body = []
1363 func_body.append('static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)')
1364 func_body.append('{')
1365 func_body.append(' static char str[1024];')
1366 func_body.append(' switch(id) {')
Jon Ashburn15161e42014-12-16 18:37:04 -0700[diff] [blame]1367 func_body.append(' case GLV_TPI_XGL_xglApiVersion:')
1368 func_body.append(' {')
1369 func_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);')
1370 func_body.append(' snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);')
1371 func_body.append(' return str;')
1372 func_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1373 for proto in self.protos:
1374 func_body.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
1375 func_body.append(' {')
1376 func_str = 'xgl%s(' % proto.name
1377 print_vals = ''
1378 create_func = False
1379 if 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
1380 create_func = True
1381 for p in proto.params:
1382 last_param = False
1383 if (p.name == proto.params[-1].name):
1384 last_param = True
1385 if last_param and create_func: # last param of create func
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]1386 (pft, pfi, ptr) = self._get_printf_params(p.ty,'pPacket->%s' % p.name, True)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1387 else:
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]1388 (pft, pfi, ptr) = self._get_printf_params(p.ty, 'pPacket->%s' % p.name, False)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1389 if last_param == True:
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]1390 func_str += '%s%s = %s)' % (ptr, p.name, pft)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1391 print_vals += ', %s' % (pfi)
1392 else:
Jon Ashburn9ef8beb2015-02-12 10:38:36 -0700[diff] [blame]1393 func_str += '%s%s = %s, ' % (ptr, p.name, pft)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1394 print_vals += ', %s' % (pfi)
1395 func_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(pHeader->pBody);' % (proto.name, proto.name))
1396 func_body.append(' snprintf(str, 1024, "%s"%s);' % (func_str, print_vals))
1397 func_body.append(' return str;')
1398 func_body.append(' }')
1399 func_body.append(' default:')
1400 func_body.append(' return NULL;')
1401 func_body.append(' }')
1402 func_body.append('};\n')
1403 return "\n".join(func_body)
1404
1405 def _generate_interp_func(self):
1406 interp_func_body = []
1407 interp_func_body.append('static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)')
1408 interp_func_body.append('{')
1409 interp_func_body.append(' if (pHeader == NULL)')
1410 interp_func_body.append(' {')
1411 interp_func_body.append(' return NULL;')
1412 interp_func_body.append(' }')
1413 interp_func_body.append(' switch (pHeader->packet_id)')
1414 interp_func_body.append(' {')
Jon Ashburn15161e42014-12-16 18:37:04 -0700[diff] [blame]1415 interp_func_body.append(' case GLV_TPI_XGL_xglApiVersion:\n {')
1416 interp_func_body.append(' return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;\n }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1417 for proto in self.protos:
1418 interp_func_body.append(' case GLV_TPI_XGL_xgl%s:\n {' % proto.name)
1419 header_prefix = 'h'
1420 if 'Wsi' in proto.name or 'Dbg' in proto.name:
1421 header_prefix = 'pH'
1422 interp_func_body.append(' return interpret_body_as_xgl%s(pHeader)->%seader;\n }' % (proto.name, header_prefix))
1423 interp_func_body.append(' default:')
1424 interp_func_body.append(' return NULL;')
1425 interp_func_body.append(' }')
1426 interp_func_body.append(' return NULL;')
1427 interp_func_body.append('}')
1428 return "\n".join(interp_func_body)
1429
1430 def _generate_struct_util_funcs(self):
1431 pid_enum = []
1432 pid_enum.append('//=============================================================================')
1433 pid_enum.append('static uint64_t calc_size_XGL_APPLICATION_INFO(const XGL_APPLICATION_INFO* pStruct)')
1434 pid_enum.append('{')
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]1435 pid_enum.append(' return ((pStruct == NULL) ? 0 : sizeof(XGL_APPLICATION_INFO)) + strlen(pStruct->pAppName) + 1 + strlen(pStruct->pEngineName) + 1;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1436 pid_enum.append('}\n')
1437 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)')
1438 pid_enum.append('{')
1439 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_APPLICATION_INFO), pInStruct);')
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]1440 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen(pInStruct->pAppName) + 1, pInStruct->pAppName);')
1441 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen(pInStruct->pEngineName) + 1, pInStruct->pEngineName);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1442 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')
1443 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')
1444 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
1445 pid_enum.append('};\n')
1446 pid_enum.append('//=============================================================================\n')
1447 pid_enum.append('static uint64_t calc_size_XGL_DEVICE_CREATE_INFO(const XGL_DEVICE_CREATE_INFO* pStruct)')
1448 pid_enum.append('{')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1449 pid_enum.append(' uint64_t total_size_ppEnabledExtensionNames = pStruct->extensionCount * sizeof(char *);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1450 pid_enum.append(' uint32_t i;')
1451 pid_enum.append(' for (i = 0; i < pStruct->extensionCount; i++)')
1452 pid_enum.append(' {')
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]1453 pid_enum.append(' total_size_ppEnabledExtensionNames += strlen(pStruct->ppEnabledExtensionNames[i]) + 1;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1454 pid_enum.append(' }')
Jon Ashburn75dd04b2015-01-09 17:30:41 -0700[diff] [blame]1455 pid_enum.append(' uint64_t total_size_layers = 0;')
1456 pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) pStruct->pNext;')
1457 pid_enum.append(' while (pNext != NULL)')
1458 pid_enum.append(' {')
1459 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1460 pid_enum.append(' {')
1461 pid_enum.append(' total_size_layers += sizeof(XGL_LAYER_CREATE_INFO);')
1462 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1463 pid_enum.append(' {')
1464 pid_enum.append(' total_size_layers += strlen(pNext->ppActiveLayerNames[i]) + 1;')
1465 pid_enum.append(' }')
1466 pid_enum.append(' }')
1467 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) pNext->pNext;')
1468 pid_enum.append(' }')
1469 pid_enum.append(' return sizeof(XGL_DEVICE_CREATE_INFO) + (pStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO)) + total_size_ppEnabledExtensionNames + total_size_layers;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1470 pid_enum.append('}\n')
1471 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)')
1472 pid_enum.append('{')
1473 pid_enum.append(' uint32_t i;')
1474 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_DEVICE_CREATE_INFO), pInStruct);')
1475 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO), pInStruct->pRequestedQueues);')
1476 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')
1477 pid_enum.append(' if (pInStruct->extensionCount > 0) ')
1478 pid_enum.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1479 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char *), pInStruct->ppEnabledExtensionNames);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1480 pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')
1481 pid_enum.append(' {')
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]1482 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen(pInStruct->ppEnabledExtensionNames[i]) + 1, pInStruct->ppEnabledExtensionNames[i]);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1483 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')
1484 pid_enum.append(' }')
1485 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
1486 pid_enum.append(' }')
Jon Ashburn75dd04b2015-01-09 17:30:41 -0700[diff] [blame]1487 pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) pInStruct->pNext;')
1488 pid_enum.append(' while (pNext != NULL)')
1489 pid_enum.append(' {')
1490 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1491 pid_enum.append(' {')
1492 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->pNext)), sizeof(XGL_LAYER_CREATE_INFO), pNext);')
1493 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->pNext)));')
1494 pid_enum.append(' XGL_LAYER_CREATE_INFO **ppOutStruct = (XGL_LAYER_CREATE_INFO **) &((*ppStruct)->pNext);')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1495 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppOutStruct)->ppActiveLayerNames), pNext->layerCount * sizeof(char *), pNext->ppActiveLayerNames);')
Jon Ashburn75dd04b2015-01-09 17:30:41 -0700[diff] [blame]1496 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1497 pid_enum.append(' {')
1498 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])), strlen(pNext->ppActiveLayerNames[i]) + 1, pNext->ppActiveLayerNames[i]);')
1499 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])));')
1500 pid_enum.append(' }')
1501 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppOutStruct)->ppActiveLayerNames);')
1502 pid_enum.append(' }')
1503 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) pNext->pNext;')
1504 pid_enum.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1505 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')
1506 pid_enum.append('}\n')
1507 pid_enum.append('static XGL_DEVICE_CREATE_INFO* interpret_XGL_DEVICE_CREATE_INFO(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')
1508 pid_enum.append('{')
1509 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')
1510 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO != NULL)')
1511 pid_enum.append(' {')
Jon Ashburn75dd04b2015-01-09 17:30:41 -0700[diff] [blame]1512 pid_enum.append(' uint32_t i;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1513 pid_enum.append(' const char** pNames;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1514 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')
1515 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO->extensionCount > 0)')
1516 pid_enum.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1517 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);')
1518 pid_enum.append(' pNames = (const char**)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1519 pid_enum.append(' for (i = 0; i < pXGL_DEVICE_CREATE_INFO->extensionCount; i++)')
1520 pid_enum.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1521 pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames[i]));')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1522 pid_enum.append(' }')
1523 pid_enum.append(' }')
Jon Ashburn75dd04b2015-01-09 17:30:41 -0700[diff] [blame]1524 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);')
1525 pid_enum.append(' while (pNext != NULL)')
1526 pid_enum.append(' {')
1527 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1528 pid_enum.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1529 pid_enum.append(' pNext->ppActiveLayerNames = (const char**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames));')
1530 pid_enum.append(' pNames = (const char**)pNext->ppActiveLayerNames;')
Jon Ashburn75dd04b2015-01-09 17:30:41 -0700[diff] [blame]1531 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1532 pid_enum.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1533 pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames[i]));')
Jon Ashburn75dd04b2015-01-09 17:30:41 -0700[diff] [blame]1534 pid_enum.append(' }')
1535 pid_enum.append(' }')
1536 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);')
1537 pid_enum.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1538 pid_enum.append(' }\n')
1539 pid_enum.append(' return pXGL_DEVICE_CREATE_INFO;')
1540 pid_enum.append('}\n')
1541 pid_enum.append('static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* pShader)')
1542 pid_enum.append('{')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1543 pid_enum.append(' if (pShader != NULL)')
1544 pid_enum.append(' {')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1545 pid_enum.append(' // constant buffers')
1546 pid_enum.append(' if (pShader->linkConstBufferCount > 0)')
1547 pid_enum.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1548 pid_enum.append(' uint32_t i;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1549 pid_enum.append(' pShader->pLinkConstBufferInfo = (const XGL_LINK_CONST_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);')
1550 pid_enum.append(' for (i = 0; i < pShader->linkConstBufferCount; i++)')
1551 pid_enum.append(' {')
1552 pid_enum.append(' XGL_LINK_CONST_BUFFER* pBuffer = (XGL_LINK_CONST_BUFFER*)pShader->pLinkConstBufferInfo;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1553 pid_enum.append(' pBuffer[i].pBufferData = (const void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo[i].pBufferData);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1554 pid_enum.append(' }')
1555 pid_enum.append(' }')
1556 pid_enum.append(' }')
1557 pid_enum.append('}\n')
1558 pid_enum.append('//=============================================================================')
1559 return "\n".join(pid_enum)
1560
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]1561 # Interpret functions used on replay to read in packets and interpret their contents
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1562 def _generate_interp_funcs(self):
1563 # Custom txt for given function and parameter. First check if param is NULL, then insert txt if not
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]1564 # TODO : This code is now too large and complex, need to make codegen smarter for pointers embedded in struct params to handle those cases automatically
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]1565 custom_case_dict = { 'CreateInstance' : {'param': 'pAppInfo', 'txt': ['XGL_APPLICATION_INFO* pInfo = (XGL_APPLICATION_INFO*)pPacket->pAppInfo;\n',
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1566 'pInfo->pAppName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);\n',
1567 'pInfo->pEngineName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pEngineName);']},
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]1568 'CreateShader' : {'param': 'pCreateInfo', 'txt': ['XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;\n',
1569 'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
Jon Ashburn459a1372015-02-04 08:50:35 -0700[diff] [blame]1570 'CreateDynamicViewportState' : {'param': 'pCreateInfo', 'txt': ['XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInfo = (XGL_DYNAMIC_VP_STATE_CREATE_INFO*)pPacket->pCreateInfo;\n',
1571 'pInfo->pViewports = (XGL_VIEWPORT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pViewports);\n',
1572 'pInfo->pScissors = (XGL_RECT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pScissors);']},
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]1573 'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['XGL_FRAMEBUFFER_CREATE_INFO* pInfo = (XGL_FRAMEBUFFER_CREATE_INFO*)pPacket->pCreateInfo;\n',
1574 'pInfo->pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',
1575 'pInfo->pDepthStencilAttachment = (XGL_DEPTH_STENCIL_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},
1576 'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': ['XGL_RENDER_PASS_CREATE_INFO* pInfo = (XGL_RENDER_PASS_CREATE_INFO*)pPacket->pCreateInfo;\n',
1577 'pInfo->pColorLoadOps = (XGL_ATTACHMENT_LOAD_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadOps);\n',
1578 'pInfo->pColorStoreOps = (XGL_ATTACHMENT_STORE_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorStoreOps);\n',
1579 'pInfo->pColorLoadClearValues = (XGL_CLEAR_COLOR*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadClearValues);\n']},
Jon Ashburn46224542015-02-04 09:32:59 -0700[diff] [blame]1580 'CreateDescriptorRegion' : {'param': 'pCreateInfo', 'txt': ['XGL_DESCRIPTOR_REGION_CREATE_INFO* pInfo = (XGL_DESCRIPTOR_REGION_CREATE_INFO*)pPacket->pCreateInfo;\n',
1581 'pInfo->pTypeCount = (XGL_DESCRIPTOR_TYPE_COUNT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pTypeCount);\n']},
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]1582 'CmdWaitEvents' : {'param': 'pWaitInfo', 'txt': ['XGL_EVENT_WAIT_INFO* pInfo = (XGL_EVENT_WAIT_INFO*)pPacket->pWaitInfo;\n',
1583 'pInfo->pEvents = (XGL_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->pEvents);\n',
1584 'pInfo->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->ppMemBarriers);\n',
1585 'uint32_t i;\n',
1586 'for (i = 0; i < pInfo->memBarrierCount; i++) {\n',
1587 ' void** ppLocalMemBarriers = (void**)&pInfo->ppMemBarriers[i];\n',
1588 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->ppMemBarriers[i]);\n',
1589 '}']},
1590 'CmdPipelineBarrier' : {'param': 'pBarrier', 'txt': ['XGL_PIPELINE_BARRIER* pBarrier = (XGL_PIPELINE_BARRIER*)pPacket->pBarrier;\n',
1591 'pBarrier->pEvents = (XGL_SET_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->pEvents);\n',
1592 'pBarrier->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->ppMemBarriers);\n',
1593 'uint32_t i;\n',
1594 'for (i = 0; i < pBarrier->memBarrierCount; i++) {\n',
1595 ' void** ppLocalMemBarriers = (void**)&pBarrier->ppMemBarriers[i];\n',
1596 ' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pBarrier->ppMemBarriers[i]);\n',
1597 '}']},
Jon Ashburn629f8002015-02-04 10:55:47 -0700[diff] [blame]1598 'CreateDescriptorSetLayout' : {'param': 'pSetLayoutInfoList', 'txt': ['assert(pPacket->pSetLayoutInfoList->sType == XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);\n',
1599 '// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
1600 'void** ppNextVoidPtr = (void**)&(pPacket->pSetLayoutInfoList->pNext);\n',
1601 '*ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSetLayoutInfoList->pNext);\n',
1602 'XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pPacket->pSetLayoutInfoList->pNext;\n',
1603 'while (NULL != pNext)\n', '{\n',
1604 ' switch(pNext->sType)\n', ' {\n',
1605 ' case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:\n',
1606 ' {\n',
1607 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1608 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1609 ' break;\n',
1610 ' }\n',
1611 ' default:\n',
1612 ' assert(!"Encountered an unexpected type in descriptor set layout create list");\n',
1613 ' }\n',
1614 ' pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pNext->pNext;\n',
1615 '}']},
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]1616 'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['assert(pPacket->pBeginInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO);\n',
1617 '// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
Jon Ashburn1660b1b2015-02-09 12:56:10 -0700[diff] [blame]1618 'XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO** ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO**)&(pPacket->pBeginInfo->pNext);\n',
1619 '*ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',
1620 'XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pNext = *ppNext;\n',
Jon Ashburn629f8002015-02-04 10:55:47 -0700[diff] [blame]1621 'while (NULL != pNext)\n', '{\n',
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]1622 ' switch(pNext->sType)\n', ' {\n',
1623 ' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:\n',
1624 ' {\n',
Jon Ashburn1660b1b2015-02-09 12:56:10 -0700[diff] [blame]1625 ' ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO**) &pNext->pNext;\n',
1626 ' *ppNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]1627 ' break;\n',
1628 ' }\n',
1629 ' default:\n',
1630 ' assert(!"Encountered an unexpected type in begin command buffer list");\n',
1631 ' }\n',
1632 ' pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pNext->pNext;\n',
1633 '}']},
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]1634 'AllocMemory' : {'param': 'pAllocInfo', 'txt': ['assert(pPacket->pAllocInfo->sType == XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO);\n',
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]1635 'XGL_MEMORY_ALLOC_INFO** ppNext = (XGL_MEMORY_ALLOC_INFO**) &(pPacket->pAllocInfo->pNext);\n',
Jon Ashburn1660b1b2015-02-09 12:56:10 -0700[diff] [blame]1636 '*ppNext = (XGL_MEMORY_ALLOC_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocInfo->pNext);\n',
1637 'XGL_MEMORY_ALLOC_INFO* pNext = (XGL_MEMORY_ALLOC_INFO*) *ppNext;\n',
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]1638 'while (NULL != pNext)\n', '{\n',
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]1639 ' switch(pNext->sType)\n', ' {\n',
1640 ' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:\n',
1641 ' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:\n',
1642 ' {\n',
1643 ' ppNext = (XGL_MEMORY_ALLOC_INFO **) &(pNext->pNext);\n',
Tobin Ehlis7cc5ec82015-02-06 12:21:42 -0700[diff] [blame]1644 ' *ppNext = (XGL_MEMORY_ALLOC_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburnc95d41b2015-02-03 07:33:48 -0700[diff] [blame]1645 ' break;\n',
1646 ' }\n',
1647 ' default:\n',
1648 ' assert(!"Encountered an unexpected type in alloc memory list");\n',
1649 ' }\n',
1650 ' pNext = (XGL_MEMORY_ALLOC_INFO*)pNext->pNext;\n',
1651 '}']},
Tobin Ehlis7e626762015-02-04 10:53:31 -0700[diff] [blame]1652 'UpdateDescriptors' : {'param': 'pUpdateChain', 'txt': ['XGL_UPDATE_SAMPLERS* pNext = (XGL_UPDATE_SAMPLERS*)pPacket->pUpdateChain;\n',
1653 'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
1654 ' switch(pNext->sType)\n', ' {\n',
1655 ' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:\n',
1656 ' {\n',
1657 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1658 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1659 ' break;\n',
1660 ' }\n',
1661 ' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:\n',
1662 ' {\n',
1663 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1664 ' XGL_UPDATE_SAMPLERS* pUS = (XGL_UPDATE_SAMPLERS*)pNext;\n',
1665 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1666 ' pUS->pSamplers = (XGL_SAMPLER*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUS->pSamplers);\n',
1667 ' break;\n',
1668 ' }\n',
1669 ' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:\n',
1670 ' {\n',
1671 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1672 ' XGL_UPDATE_SAMPLER_TEXTURES* pUST = (XGL_UPDATE_SAMPLER_TEXTURES*)pNext;\n',
1673 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1674 ' pUST->pSamplerImageViews = (XGL_SAMPLER_IMAGE_VIEW_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews);\n',
1675 ' uint32_t i;\n',
1676 ' for (i = 0; i < pUST->count; i++) {\n',
1677 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUST->pSamplerImageViews[i].pImageView;\n',
1678 ' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews[i].pImageView);\n',
1679 ' }\n',
1680 ' break;\n',
1681 ' }\n',
1682 ' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:\n',
1683 ' {\n',
1684 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1685 ' XGL_UPDATE_IMAGES* pUI = (XGL_UPDATE_IMAGES*)pNext;\n',
1686 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburna04529d2015-02-04 16:26:30 -0700[diff] [blame]1687 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUI->pImageViews;\n',
1688 ' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews);\n',
1689 ' uint32_t i;\n',
1690 ' for (i = 0; i < pUI->count; i++) {\n',
1691 ' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUI->pImageViews[i];\n',
1692 ' *ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews[i]);\n',
1693 ' }\n',
Tobin Ehlis7e626762015-02-04 10:53:31 -0700[diff] [blame]1694 ' break;\n',
1695 ' }\n',
1696 ' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:\n',
1697 ' {\n',
1698 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1699 ' XGL_UPDATE_BUFFERS* pUB = (XGL_UPDATE_BUFFERS*)pNext;\n',
1700 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburna04529d2015-02-04 16:26:30 -0700[diff] [blame]1701 ' XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO**)&pUB->pBufferViews;\n',
1702 ' *ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews);\n',
1703 ' uint32_t i;\n',
1704 ' for (i = 0; i < pUB->count; i++) {\n',
1705 ' XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO**)&pUB->pBufferViews[i];\n',
1706 ' *ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews[i]);\n',
1707 ' }\n',
Tobin Ehlis7e626762015-02-04 10:53:31 -0700[diff] [blame]1708 ' break;\n',
1709 ' }\n',
1710 ' default:\n',
1711 ' assert(!"Encountered an unexpected type in update descriptors pUpdateChain");\n',
1712 ' }\n',
1713 ' pNext = (XGL_UPDATE_SAMPLERS*)pNext->pNext;\n',
1714 '}']},
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]1715 'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['assert(pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);\n',
1716 '// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1717 'void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',
1718 '*ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]1719 'XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n',
1720 'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1721 ' switch(pNext->sType)\n', ' {\n',
1722 ' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',
1723 ' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',
1724 ' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]1725 ' case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',
1726 ' case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',
1727 ' case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1728 ' {\n',
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1729 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1730 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1731 ' break;\n',
1732 ' }\n',
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]1733 ' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',
1734 ' {\n',
1735 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1736 ' XGL_PIPELINE_CB_STATE_CREATE_INFO *pCb = (XGL_PIPELINE_CB_STATE_CREATE_INFO *) pNext;\n',
1737 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
1738 ' pCb->pAttachments = (XGL_PIPELINE_CB_ATTACHMENT_STATE*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pCb->pAttachments);\n',
1739 ' break;\n',
1740 ' }\n',
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1741 ' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',
1742 ' {\n',
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1743 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1744 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]1745 ' interpret_pipeline_shader(pHeader, &pNext->shader);\n',
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1746 ' break;\n',
1747 ' }\n',
1748 ' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',
1749 ' {\n',
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1750 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1751 ' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1752 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1753 ' pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',
1754 ' pVi->pVertexAttributeDescriptions = (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',
1755 ' break;\n',
1756 ' }\n',
1757 ' default:\n',
1758 ' assert(!"Encountered an unexpected type in pipeline state list");\n',
1759 ' }\n',
1760 ' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',
1761 '}']},
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]1762 'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));']}}
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1763 if_body = []
Jon Ashburn15161e42014-12-16 18:37:04 -0700[diff] [blame]1764 if_body.append('typedef struct struct_xglApiVersion {')
1765 if_body.append(' glv_trace_packet_header* header;')
1766 if_body.append(' uint32_t version;')
1767 if_body.append('} struct_xglApiVersion;\n')
1768 if_body.append('static struct_xglApiVersion* interpret_body_as_xglApiVersion(glv_trace_packet_header* pHeader, BOOL check_version)')
1769 if_body.append('{')
1770 if_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)pHeader->pBody;')
1771 if_body.append(' pPacket->header = pHeader;')
1772 if_body.append(' if (check_version && pPacket->version != XGL_API_VERSION)')
1773 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);')
1774 if_body.append(' return pPacket;')
1775 if_body.append('}\n')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1776 for proto in self.protos:
1777 if 'Wsi' not in proto.name and 'Dbg' not in proto.name:
1778 if 'UnmapMemory' == proto.name:
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1779 proto.params.append(xgl.Param("void*", "pData"))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1780 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1781 if_body.append(' glv_trace_packet_header* header;')
1782 for p in proto.params:
1783 if '[4]' in p.ty:
1784 if_body.append(' %s %s[4];' % (p.ty.strip('[4]'), p.name))
1785 else:
1786 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1787 if 'void' != proto.ret:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1788 if_body.append(' %s result;' % proto.ret)
1789 if_body.append('} struct_xgl%s;\n' % proto.name)
1790 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1791 if_body.append('{')
1792 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1793 if_body.append(' pPacket->header = pHeader;')
1794 for p in proto.params:
1795 if '*' in p.ty:
1796 if 'DEVICE_CREATE_INFO' in p.ty:
1797 if_body.append(' pPacket->%s = interpret_XGL_DEVICE_CREATE_INFO(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))
1798 else:
1799 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
1800 if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
1801 if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])
1802 if_body.append(' {')
1803 if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))
1804 if_body.append(' }')
1805 if_body.append(' return pPacket;')
1806 if_body.append('}\n')
1807 return "\n".join(if_body)
1808
1809 def _generate_interp_funcs_ext(self, func_class='Wsi'):
1810 if_body = []
1811 for proto in self.protos:
1812 if func_class in proto.name:
1813 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1814 if_body.append(' glv_trace_packet_header* pHeader;')
1815 for p in proto.params:
1816 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1817 if 'void' != proto.ret:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1818 if_body.append(' %s result;' % proto.ret)
1819 if_body.append('} struct_xgl%s;\n' % proto.name)
1820 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1821 if_body.append('{')
1822 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1823 if_body.append(' pPacket->pHeader = pHeader;')
1824 for p in proto.params:
1825 if '*' in p.ty:
1826 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
1827 if_body.append(' return pPacket;')
1828 if_body.append('}\n')
1829 return "\n".join(if_body)
1830
1831 def _generate_replay_class_decls(self):
1832 cd_body = []
1833 cd_body.append('class ApiReplay {')
1834 cd_body.append('public:')
1835 cd_body.append(' virtual ~ApiReplay() { }')
1836 cd_body.append(' virtual enum glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header * packet) = 0;')
1837 cd_body.append(' virtual int init(glv_replay::Display & disp) = 0;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1838 cd_body.append(' virtual void push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg) = 0;')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]1839 cd_body.append(' virtual glv_replay::GLV_REPLAY_RESULT pop_validation_msgs() = 0;')
Jon Ashburn8ef49b12015-02-17 13:28:11 -0700[diff] [blame]1840 cd_body.append(' virtual int dump_validation_data() = 0;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1841 cd_body.append('};\n')
1842 cd_body.append('class xglDisplay: public glv_replay::DisplayImp {')
1843 cd_body.append('friend class xglReplay;')
1844 cd_body.append('public:')
1845 cd_body.append(' xglDisplay();')
1846 cd_body.append(' ~xglDisplay();')
1847 cd_body.append(' int init(const unsigned int gpu_idx);')
1848 cd_body.append(' int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height);')
1849 cd_body.append(' int create_window(const unsigned int width, const unsigned int height);')
1850 cd_body.append(' void resize_window(const unsigned int width, const unsigned int height);')
1851 cd_body.append(' void process_event();')
1852 cd_body.append(' // XGL_DEVICE get_device() { return m_dev[m_gpuIdx];}')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]1853 cd_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1854 cd_body.append(' xcb_window_t get_window_handle() { return m_XcbWindow; }')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]1855 cd_body.append('#elif defined(WIN32)')
1856 cd_body.append(' HWND get_window_handle() { return m_windowHandle; }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1857 cd_body.append('#endif')
1858 cd_body.append('private:')
1859 cd_body.append(' XGL_RESULT init_xgl(const unsigned int gpu_idx);')
1860 cd_body.append(' bool m_initedXGL;')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]1861 cd_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1862 cd_body.append(' XGL_WSI_X11_CONNECTION_INFO m_WsiConnection;')
1863 cd_body.append(' xcb_screen_t *m_pXcbScreen;')
1864 cd_body.append(' xcb_window_t m_XcbWindow;')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]1865 cd_body.append('#elif defined(WIN32)')
1866 cd_body.append(' HWND m_windowHandle;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1867 cd_body.append('#endif')
1868 cd_body.append(' unsigned int m_windowWidth;')
1869 cd_body.append(' unsigned int m_windowHeight;')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]1870 cd_body.append(' unsigned int m_frameNumber;')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]1871 cd_body.append(' std::vector<uint32_t> imageWidth;')
1872 cd_body.append(' std::vector<uint32_t> imageHeight;')
1873 cd_body.append(' std::vector<XGL_IMAGE> imageHandles;')
1874 cd_body.append(' std::vector<XGL_GPU_MEMORY> imageMemory;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1875 cd_body.append('#if 0')
1876 cd_body.append(' XGL_DEVICE m_dev[XGL_MAX_PHYSICAL_GPUS];')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1877 cd_body.append(' uint32_t m_gpuCount;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1878 cd_body.append(' unsigned int m_gpuIdx;')
1879 cd_body.append(' XGL_PHYSICAL_GPU m_gpus[XGL_MAX_PHYSICAL_GPUS];')
1880 cd_body.append(' XGL_PHYSICAL_GPU_PROPERTIES m_gpuProps[XGL_MAX_PHYSICAL_GPUS];')
1881 cd_body.append('#endif')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1882 cd_body.append(' std::vector<char *>m_extensions;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1883 cd_body.append('};\n')
1884 cd_body.append('typedef struct _XGLAllocInfo {')
1885 cd_body.append(' XGL_GPU_SIZE size;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1886 cd_body.append(' void *pData;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1887 cd_body.append('} XGLAllocInfo;')
1888 return "\n".join(cd_body)
1889
1890 def _generate_replay_func_ptrs(self):
1891 xf_body = []
1892 xf_body.append('struct xglFuncs {')
1893 xf_body.append(' void init_funcs(void * libHandle);')
1894 xf_body.append(' void *m_libHandle;\n')
1895 for proto in self.protos:
1896 xf_body.append(' typedef %s( XGLAPI * type_xgl%s)(' % (proto.ret, proto.name))
1897 for p in proto.params:
1898 if '[4]' in p.ty:
1899 xf_body.append(' %s %s[4],' % (p.ty.strip('[4]'), p.name))
1900 else:
1901 xf_body.append(' %s %s,' % (p.ty, p.name))
1902 xf_body[-1] = xf_body[-1].replace(',', ');')
1903 xf_body.append(' type_xgl%s real_xgl%s;' % (proto.name, proto.name))
1904 xf_body.append('};')
1905 return "\n".join(xf_body)
1906
1907 def _map_decl(self, type1, type2, name):
1908 return ' std::map<%s, %s> %s;' % (type1, type2, name)
1909
1910 def _add_to_map_decl(self, type1, type2, name):
1911 txt = ' void add_to_map(%s* pTraceVal, %s* pReplayVal)\n {\n' % (type1, type2)
1912 txt += ' assert(pTraceVal != NULL);\n'
1913 txt += ' assert(pReplayVal != NULL);\n'
1914 txt += ' %s[*pTraceVal] = *pReplayVal;\n }' % name
1915 return txt
1916
1917 def _rm_from_map_decl(self, ty, name):
1918 txt = ' void rm_from_map(const %s& key)\n {\n' % (ty)
1919 txt += ' %s.erase(key);\n }' % name
1920 return txt
1921
1922 def _remap_decl(self, ty, name):
1923 txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)
1924 txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)
1925 txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }' % name
1926 return txt
1927
1928 def _generate_replay_class(self):
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]1929 # Create dict mapping member var names to XGL type (i.e. 'm_imageViews' : 'XGL_IMAGE_VIEW')
1930 obj_map_dict = {}
1931 for ty in xgl.object_type_list:
1932 if ty in xgl.object_parent_list:
1933 continue
1934 mem_var = ty.replace('XGL_', '').lower()
1935 mem_var_list = mem_var.split('_')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]1936 mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))
1937 obj_map_dict[mem_var] = ty
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1938 rc_body = []
1939 rc_body.append('class xglReplay : public ApiReplay {')
1940 rc_body.append('public:')
1941 rc_body.append(' ~xglReplay();')
Ian Elliotteca16382015-02-18 15:35:00 -0700[diff] [blame]1942 rc_body.append(' xglReplay(glvreplay_settings *pReplaySettings);\n')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1943 rc_body.append(' int init(glv_replay::Display & disp);')
1944 rc_body.append(' xglDisplay * get_display() {return m_display;}')
1945 rc_body.append(' glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);')
1946 rc_body.append(' glv_replay::GLV_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn);\n')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1947 rc_body.append(' void push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg);')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]1948 rc_body.append(' glv_replay::GLV_REPLAY_RESULT pop_validation_msgs();')
Jon Ashburn8ef49b12015-02-17 13:28:11 -0700[diff] [blame]1949 rc_body.append(' int dump_validation_data();')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1950 rc_body.append('private:')
1951 rc_body.append(' struct xglFuncs m_xglFuncs;')
Jon Ashburn8ef49b12015-02-17 13:28:11 -0700[diff] [blame]1952 rc_body.append(' DRAW_STATE_DUMP_DOT_FILE m_pDSDump;')
Jeremy Hayes2c98e532015-02-26 15:59:19 -0700[diff] [blame]1953 rc_body.append(' DRAW_STATE_DUMP_COMMAND_BUFFER_DOT_FILE m_pCBDump;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1954 rc_body.append(' xglDisplay *m_display;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1955 rc_body.append(' struct shaderPair {')
1956 rc_body.append(' XGL_SHADER *addr;')
1957 rc_body.append(' XGL_SHADER val;')
1958 rc_body.append(' };')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]1959 rc_body.append(' struct validationMsg {')
1960 rc_body.append(' XGL_VALIDATION_LEVEL validationLevel;')
1961 rc_body.append(' XGL_BASE_OBJECT srcObject;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1962 rc_body.append(' size_t location;')
1963 rc_body.append(' int32_t msgCode;')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]1964 rc_body.append(' char msg[256];')
1965 rc_body.append(' };')
1966 rc_body.append(' std::vector<struct validationMsg> m_validationMsgs;')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]1967 rc_body.append(' std::vector<int> m_screenshotFrames;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1968 rc_body.append(self._map_decl('XGL_GPU_MEMORY', 'XGLAllocInfo', 'm_mapData'))
1969 # Custom code for 1-off memory mapping functions
1970 rc_body.append(' void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)')
1971 rc_body.append(' {')
1972 rc_body.append(' XGLAllocInfo info;')
1973 rc_body.append(' info.pData = NULL;')
1974 rc_body.append(' info.size = size;')
1975 rc_body.append(' m_mapData.insert(std::pair<XGL_GPU_MEMORY, XGLAllocInfo>(handle, info));')
1976 rc_body.append(' }')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]1977 rc_body.append(' void add_mapping_to_mapData(XGL_GPU_MEMORY handle, void *pData)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1978 rc_body.append(' {')
1979 rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
1980 rc_body.append(' if (it == m_mapData.end())')
1981 rc_body.append(' {')
1982 rc_body.append(' glv_LogWarn("add_mapping_to_mapData() could not find entry\\n");')
1983 rc_body.append(' return;')
1984 rc_body.append(' }')
1985 rc_body.append(' XGLAllocInfo &info = it->second;')
1986 rc_body.append(' if (info.pData != NULL)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1987 rc_body.append(' glv_LogWarn("add_mapping_to_mapData() data already mapped overwrite old mapping\\n");')
Jon Ashburna915cb12015-02-20 13:10:52 -0700[diff] [blame]1988 rc_body.append(' else if (pData == NULL)')
1989 rc_body.append(' glv_LogWarn("add_mapping_to_mapData() adding NULL pointer\\n");')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]1990 rc_body.append(' info.pData = pData;')
1991 rc_body.append(' }')
1992 rc_body.append(' void rm_entry_from_mapData(XGL_GPU_MEMORY handle)')
1993 rc_body.append(' {')
1994 rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
1995 rc_body.append(' if (it == m_mapData.end())')
1996 rc_body.append(' return;')
1997 rc_body.append(' m_mapData.erase(it);')
1998 rc_body.append(' }')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]1999 rc_body.append(' void rm_mapping_from_mapData(XGL_GPU_MEMORY handle, void* pData)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2000 rc_body.append(' {')
2001 rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
2002 rc_body.append(' if (it == m_mapData.end())')
2003 rc_body.append(' return;\n')
2004 rc_body.append(' XGLAllocInfo &info = it->second;')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]2005 rc_body.append(' if (!pData || !info.pData)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2006 rc_body.append(' {')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]2007 rc_body.append(' if (!pData)')
2008 rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null src pointer\\n");')
2009 rc_body.append(' else')
2010 rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null dest pointer size=%u\\n", info.size);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2011 rc_body.append(' info.pData = NULL;')
2012 rc_body.append(' return;')
2013 rc_body.append(' }')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]2014 rc_body.append(' memcpy(info.pData, pData, info.size);')
2015 rc_body.append(' info.pData = NULL;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2016 rc_body.append(' }\n')
2017 rc_body.append(' /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;')
2018 rc_body.append(' void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)')
2019 rc_body.append(' {')
2020 rc_body.append(' assert(pTraceGpu != NULL);')
2021 rc_body.append(' assert(pReplayGpu != NULL);')
2022 rc_body.append(' m_gpus[*pTraceGpu] = *pReplayGpu;')
2023 rc_body.append(' }\n')
2024 rc_body.append(' XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)')
2025 rc_body.append(' {')
2026 rc_body.append(' std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);')
2027 rc_body.append(' return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;')
2028 rc_body.append(' }*/\n')
2029 rc_body.append(' void clear_all_map_handles()\n {')
2030 for var in sorted(obj_map_dict):
2031 rc_body.append(' %s.clear();' % var)
2032 rc_body.append(' }')
2033 for var in sorted(obj_map_dict):
2034 rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))
2035 rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))
2036 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
2037 rc_body.append(self._remap_decl(obj_map_dict[var], var))
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]2038 # XGL_DYNAMIC_STATE_OBJECT code
2039 state_obj_remap_types = xgl.object_dynamic_state_list
2040 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
2041 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT obj;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2042 for t in state_obj_remap_types:
2043 rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != XGL_NULL_HANDLE)' % t)
2044 rc_body.append(' return obj;')
2045 rc_body.append(' return XGL_NULL_HANDLE;\n }')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]2046 rc_body.append(' void rm_from_map(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2047 for t in state_obj_remap_types:
2048 rc_body.append(' rm_from_map(static_cast <%s> (state));' % t)
2049 rc_body.append(' }')
2050 # OBJECT code
2051 rc_body.append(' XGL_OBJECT remap(const XGL_OBJECT& object)\n {')
2052 rc_body.append(' XGL_OBJECT obj;')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]2053 obj_remap_types = xgl.object_list
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2054 for var in obj_remap_types:
2055 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % (var))
2056 rc_body.append(' return obj;')
2057 rc_body.append(' return XGL_NULL_HANDLE;\n }')
2058 rc_body.append(' void rm_from_map(const XGL_OBJECT & objKey)\n {')
2059 for var in obj_remap_types:
2060 rc_body.append(' rm_from_map(static_cast <%s> (objKey));' % (var))
2061 rc_body.append(' }')
2062 rc_body.append(' XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)\n {')
2063 rc_body.append(' XGL_BASE_OBJECT obj;')
2064 base_obj_remap_types = ['XGL_DEVICE', 'XGL_QUEUE', 'XGL_GPU_MEMORY', 'XGL_OBJECT']
2065 for t in base_obj_remap_types:
2066 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % t)
2067 rc_body.append(' return obj;')
2068 rc_body.append(' return XGL_NULL_HANDLE;\n }')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]2069 rc_body.append('void process_screenshot_list(const char *list)')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]2070 rc_body.append('{')
2071 rc_body.append(' std::string spec(list), word;')
2072 rc_body.append(' size_t start = 0, comma = 0;\n')
2073 rc_body.append(' while (start < spec.size()) {')
2074 rc_body.append(' comma = spec.find(\',\', start);\n')
2075 rc_body.append(' if (comma == std::string::npos)')
2076 rc_body.append(' word = std::string(spec, start);')
2077 rc_body.append(' else')
2078 rc_body.append(' word = std::string(spec, start, comma - start);\n')
Tony Barbourcb273e72015-02-05 13:55:03 -0700[diff] [blame]2079 rc_body.append(' m_screenshotFrames.push_back(atoi(word.c_str()));')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]2080 rc_body.append(' if (comma == std::string::npos)')
2081 rc_body.append(' break;\n')
2082 rc_body.append(' start = comma + 1;\n')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]2083 rc_body.append(' }')
2084 rc_body.append('}')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2085 rc_body.append('};')
2086 return "\n".join(rc_body)
2087
2088 def _generate_replay_display_init_xgl(self):
2089 dix_body = []
2090 dix_body.append('XGL_RESULT xglDisplay::init_xgl(unsigned int gpu_idx)')
2091 dix_body.append('{')
2092 dix_body.append('#if 0')
2093 dix_body.append(' XGL_APPLICATION_INFO appInfo = {};')
2094 dix_body.append(' appInfo.pAppName = APP_NAME;')
2095 dix_body.append(' appInfo.pEngineName = "";')
2096 dix_body.append(' appInfo.apiVersion = XGL_API_VERSION;')
2097 dix_body.append(' XGL_RESULT res = xglInitAndEnumerateGpus(&appInfo, NULL, XGL_MAX_PHYSICAL_GPUS, &m_gpuCount, m_gpus);')
2098 dix_body.append(' if ( res == XGL_SUCCESS ) {')
2099 dix_body.append(' // retrieve the GPU information for all GPUs')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2100 dix_body.append(' for( uint32_t gpu = 0; gpu < m_gpuCount; gpu++)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2101 dix_body.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2102 dix_body.append(' size_t gpuInfoSize = sizeof(m_gpuProps[0]);\n')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2103 dix_body.append(' // get the GPU physical properties:')
2104 dix_body.append(' res = xglGetGpuInfo( m_gpus[gpu], XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &gpuInfoSize, &m_gpuProps[gpu]);')
2105 dix_body.append(' if (res != XGL_SUCCESS)')
2106 dix_body.append(' glv_LogWarn("Failed to retrieve properties for gpu[%d] result %d\\n", gpu, res);')
2107 dix_body.append(' }')
2108 dix_body.append(' res = XGL_SUCCESS;')
2109 dix_body.append(' } else if ((gpu_idx + 1) > m_gpuCount) {')
2110 dix_body.append(' glv_LogError("xglInitAndEnumerate number of gpus does not include requested index: num %d, requested %d\\n", m_gpuCount, gpu_idx);')
2111 dix_body.append(' return -1;')
2112 dix_body.append(' } else {')
2113 dix_body.append(' glv_LogError("xglInitAndEnumerate failed\\n");')
2114 dix_body.append(' return res;')
2115 dix_body.append(' }')
2116 dix_body.append(' // TODO add multi-gpu support always use gpu[gpu_idx] for now')
2117 dix_body.append(' // get all extensions supported by this device gpu[gpu_idx]')
2118 dix_body.append(' // first check if extensions are available and save a list of them')
2119 dix_body.append(' bool foundWSIExt = false;')
2120 dix_body.append(' for( int ext = 0; ext < sizeof( extensions ) / sizeof( extensions[0] ); ext++)')
2121 dix_body.append(' {')
2122 dix_body.append(' res = xglGetExtensionSupport( m_gpus[gpu_idx], extensions[ext] );')
2123 dix_body.append(' if (res == XGL_SUCCESS) {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2124 dix_body.append(' m_extensions.push_back((char *) extensions[ext]);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2125 dix_body.append(' if (!strcmp(extensions[ext], "XGL_WSI_WINDOWS"))')
2126 dix_body.append(' foundWSIExt = true;')
2127 dix_body.append(' }')
2128 dix_body.append(' }')
2129 dix_body.append(' if (!foundWSIExt) {')
2130 dix_body.append(' glv_LogError("XGL_WSI_WINDOWS extension not supported by gpu[%d]\\n", gpu_idx);')
2131 dix_body.append(' return XGL_ERROR_INCOMPATIBLE_DEVICE;')
2132 dix_body.append(' }')
2133 dix_body.append(' // TODO generalize this: use one universal queue for now')
2134 dix_body.append(' XGL_DEVICE_QUEUE_CREATE_INFO dqci = {};')
2135 dix_body.append(' dqci.queueCount = 1;')
2136 dix_body.append(' dqci.queueType = XGL_QUEUE_UNIVERSAL;')
2137 dix_body.append(' // create the device enabling validation level 4')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2138 dix_body.append(' const char * const * extNames = &m_extensions[0];')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2139 dix_body.append(' XGL_DEVICE_CREATE_INFO info = {};')
2140 dix_body.append(' info.queueRecordCount = 1;')
2141 dix_body.append(' info.pRequestedQueues = &dqci;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2142 dix_body.append(' info.extensionCount = static_cast <uint32_t> (m_extensions.size());')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2143 dix_body.append(' info.ppEnabledExtensionNames = extNames;')
2144 dix_body.append(' info.flags = XGL_DEVICE_CREATE_VALIDATION;')
2145 dix_body.append(' info.maxValidationLevel = XGL_VALIDATION_LEVEL_4;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2146 dix_body.append(' bool32_t xglTrue = XGL_TRUE;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2147 dix_body.append(' res = xglDbgSetGlobalOption( XGL_DBG_OPTION_BREAK_ON_ERROR, sizeof( xglTrue ), &xglTrue );')
2148 dix_body.append(' if (res != XGL_SUCCESS)')
2149 dix_body.append(' glv_LogWarn("Could not set debug option break on error\\n");')
2150 dix_body.append(' res = xglCreateDevice( m_gpus[0], &info, &m_dev[gpu_idx]);')
2151 dix_body.append(' return res;')
2152 dix_body.append('#else')
2153 dix_body.append(' return XGL_ERROR_INITIALIZATION_FAILED;')
2154 dix_body.append('#endif')
2155 dix_body.append('}')
2156 return "\n".join(dix_body)
2157
2158 def _generate_replay_display_init(self):
2159 di_body = []
2160 di_body.append('int xglDisplay::init(const unsigned int gpu_idx)')
2161 di_body.append('{')
2162 di_body.append(' //m_gpuIdx = gpu_idx;')
2163 di_body.append('#if 0')
2164 di_body.append(' XGL_RESULT result = init_xgl(gpu_idx);')
2165 di_body.append(' if (result != XGL_SUCCESS) {')
2166 di_body.append(' glv_LogError("could not init xgl library");')
2167 di_body.append(' return -1;')
2168 di_body.append(' } else {')
2169 di_body.append(' m_initedXGL = true;')
2170 di_body.append(' }')
2171 di_body.append('#endif')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]2172 di_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2173 di_body.append(' const xcb_setup_t *setup;')
2174 di_body.append(' xcb_screen_iterator_t iter;')
2175 di_body.append(' int scr;')
2176 di_body.append(' xcb_connection_t *pConnection;')
2177 di_body.append(' pConnection = xcb_connect(NULL, &scr);')
2178 di_body.append(' setup = xcb_get_setup(pConnection);')
2179 di_body.append(' iter = xcb_setup_roots_iterator(setup);')
2180 di_body.append(' while (scr-- > 0)')
2181 di_body.append(' xcb_screen_next(&iter);')
2182 di_body.append(' m_pXcbScreen = iter.data;')
2183 di_body.append(' m_WsiConnection.pConnection = pConnection;')
2184 di_body.append(' m_WsiConnection.root = m_pXcbScreen->root;')
2185 di_body.append('#endif')
2186 di_body.append(' return 0;')
2187 di_body.append('}')
2188 return "\n".join(di_body)
2189
2190 def _generate_replay_display_structors(self):
2191 ds_body = []
2192 ds_body.append('xglDisplay::xglDisplay()')
2193 ds_body.append(' : m_initedXGL(false),')
2194 ds_body.append(' m_windowWidth(0),')
2195 ds_body.append(' m_windowHeight(0)')
2196 ds_body.append('{')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]2197 ds_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2198 ds_body.append(' m_WsiConnection.pConnection = NULL;')
2199 ds_body.append(' m_WsiConnection.root = 0;')
2200 ds_body.append(' m_WsiConnection.provider = 0;')
2201 ds_body.append(' m_pXcbScreen = NULL;')
2202 ds_body.append(' m_XcbWindow = 0;')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]2203 ds_body.append('#elif defined(WIN32)')
2204 ds_body.append(' m_windowHandle = NULL;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2205 ds_body.append('#endif')
2206 ds_body.append('}')
2207 ds_body.append('xglDisplay::~xglDisplay()')
2208 ds_body.append('{')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]2209 ds_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2210 ds_body.append(' if (m_XcbWindow != 0)')
2211 ds_body.append(' {')
2212 ds_body.append(' xcb_destroy_window(m_WsiConnection.pConnection, m_XcbWindow);')
2213 ds_body.append(' }')
2214 ds_body.append(' if (m_WsiConnection.pConnection != NULL)')
2215 ds_body.append(' {')
2216 ds_body.append(' xcb_disconnect(m_WsiConnection.pConnection);')
2217 ds_body.append(' }')
2218 ds_body.append('#endif')
2219 ds_body.append('}')
2220 return "\n".join(ds_body)
2221
2222 def _generate_replay_display_window(self):
2223 dw_body = []
2224 dw_body.append('#if defined(WIN32)')
2225 dw_body.append('LRESULT WINAPI WindowProcXgl( HWND window, unsigned int msg, WPARAM wp, LPARAM lp)')
2226 dw_body.append('{')
2227 dw_body.append(' switch(msg)')
2228 dw_body.append(' {')
2229 dw_body.append(' case WM_CLOSE:')
2230 dw_body.append(' DestroyWindow( window);')
2231 dw_body.append(' // fall-thru')
2232 dw_body.append(' case WM_DESTROY:')
2233 dw_body.append(' PostQuitMessage(0) ;')
2234 dw_body.append(' return 0L ;')
2235 dw_body.append(' default:')
2236 dw_body.append(' return DefWindowProc( window, msg, wp, lp ) ;')
2237 dw_body.append(' }')
2238 dw_body.append('}')
2239 dw_body.append('#endif')
2240 dw_body.append('int xglDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)')
2241 dw_body.append('{')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]2242 dw_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2243 dw_body.append(' m_XcbWindow = hWindow;')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]2244 dw_body.append('#elif defined(WIN32)')
2245 dw_body.append(' m_windowHandle = hWindow;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2246 dw_body.append('#endif')
2247 dw_body.append(' m_windowWidth = width;')
2248 dw_body.append(' m_windowHeight = height;')
2249 dw_body.append(' return 0;')
2250 dw_body.append('}\n')
2251 dw_body.append('int xglDisplay::create_window(const unsigned int width, const unsigned int height)')
2252 dw_body.append('{')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]2253 dw_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)\n')
2254 dw_body.append(' uint32_t value_mask, value_list[32];')
2255 dw_body.append(' m_XcbWindow = xcb_generate_id(m_WsiConnection.pConnection);\n')
2256 dw_body.append(' value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;')
2257 dw_body.append(' value_list[0] = m_pXcbScreen->black_pixel;')
2258 dw_body.append(' value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |')
2259 dw_body.append(' XCB_EVENT_MASK_EXPOSURE;\n')
2260 dw_body.append(' xcb_create_window(m_WsiConnection.pConnection,')
2261 dw_body.append(' XCB_COPY_FROM_PARENT,')
2262 dw_body.append(' m_XcbWindow, m_WsiConnection.root,')
2263 dw_body.append(' 0, 0, width, height, 0,')
2264 dw_body.append(' XCB_WINDOW_CLASS_INPUT_OUTPUT,')
2265 dw_body.append(' m_pXcbScreen->root_visual,')
2266 dw_body.append(' value_mask, value_list);\n')
2267 dw_body.append(' xcb_map_window(m_WsiConnection.pConnection, m_XcbWindow);')
2268 dw_body.append(' xcb_flush(m_WsiConnection.pConnection);')
2269 dw_body.append(' return 0;')
2270 dw_body.append('#elif defined(WIN32)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2271 dw_body.append(' // Register Window class')
2272 dw_body.append(' WNDCLASSEX wcex = {};')
2273 dw_body.append(' wcex.cbSize = sizeof( WNDCLASSEX);')
2274 dw_body.append(' wcex.style = CS_HREDRAW | CS_VREDRAW;')
2275 dw_body.append(' wcex.lpfnWndProc = WindowProcXgl;')
2276 dw_body.append(' wcex.cbClsExtra = 0;')
2277 dw_body.append(' wcex.cbWndExtra = 0;')
2278 dw_body.append(' wcex.hInstance = GetModuleHandle(0);')
2279 dw_body.append(' wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')
2280 dw_body.append(' wcex.hCursor = LoadCursor( NULL, IDC_ARROW);')
2281 dw_body.append(' wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1);')
2282 dw_body.append(' wcex.lpszMenuName = NULL;')
2283 dw_body.append(' wcex.lpszClassName = APP_NAME;')
2284 dw_body.append(' wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')
2285 dw_body.append(' if( !RegisterClassEx( &wcex))')
2286 dw_body.append(' {')
2287 dw_body.append(' glv_LogError("Failed to register windows class\\n");')
2288 dw_body.append(' return -1;')
2289 dw_body.append(' }\n')
2290 dw_body.append(' // create the window')
2291 dw_body.append(' m_windowHandle = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 0, 0,')
2292 dw_body.append(' width, height, NULL, NULL, wcex.hInstance, NULL);\n')
2293 dw_body.append(' if (m_windowHandle)')
2294 dw_body.append(' {')
2295 dw_body.append(' ShowWindow( m_windowHandle, SW_SHOWDEFAULT);')
2296 dw_body.append(' m_windowWidth = width;')
2297 dw_body.append(' m_windowHeight = height;')
2298 dw_body.append(' } else {')
2299 dw_body.append(' glv_LogError("Failed to create window\\n");')
2300 dw_body.append(' return -1;')
2301 dw_body.append(' }')
2302 dw_body.append(' return 0;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2303 dw_body.append('#endif')
2304 dw_body.append('}\n')
2305 dw_body.append('void xglDisplay::resize_window(const unsigned int width, const unsigned int height)')
2306 dw_body.append('{')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]2307 dw_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2308 dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')
2309 dw_body.append(' {')
2310 dw_body.append(' uint32_t values[2];')
2311 dw_body.append(' values[0] = width;')
2312 dw_body.append(' values[1] = height;')
2313 dw_body.append(' xcb_configure_window(m_WsiConnection.pConnection, m_XcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);')
2314 dw_body.append(' m_windowWidth = width;')
2315 dw_body.append(' m_windowHeight = height;')
2316 dw_body.append(' }')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]2317 dw_body.append('#elif defined(WIN32)')
2318 dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')
2319 dw_body.append(' {')
2320 dw_body.append(' SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, width, height, SWP_NOMOVE);')
2321 dw_body.append(' m_windowWidth = width;')
2322 dw_body.append(' m_windowHeight = height;')
2323 dw_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2324 dw_body.append('#endif')
2325 dw_body.append('}\n')
2326 dw_body.append('void xglDisplay::process_event()')
2327 dw_body.append('{')
2328 dw_body.append('}')
2329 return "\n".join(dw_body)
2330
2331 def _generate_replay_structors(self):
2332 rs_body = []
Ian Elliotteca16382015-02-18 15:35:00 -0700[diff] [blame]2333 rs_body.append('xglReplay::xglReplay(glvreplay_settings *pReplaySettings)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2334 rs_body.append('{')
Ian Elliotteca16382015-02-18 15:35:00 -0700[diff] [blame]2335 rs_body.append(' g_pReplaySettings = pReplaySettings;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2336 rs_body.append(' m_display = new xglDisplay();')
Peter Lohrmannbd3950f2015-02-26 10:51:36 -0800[diff] [blame]2337 rs_body.append(' m_pDSDump = NULL;')
Peter Lohrmannd2e84852015-02-27 15:35:15 -0800[diff] [blame]2338 rs_body.append(' m_pCBDump = NULL;')
Jon Ashburnc7fd9782015-02-05 13:42:38 -0700[diff] [blame]2339 rs_body.append(' if (g_pReplaySettings && g_pReplaySettings->screenshotList) {')
2340 rs_body.append(' process_screenshot_list(g_pReplaySettings->screenshotList);')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]2341 rs_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2342 rs_body.append('}\n')
2343 rs_body.append('xglReplay::~xglReplay()')
2344 rs_body.append('{')
2345 rs_body.append(' delete m_display;')
2346 rs_body.append(' glv_platform_close_library(m_xglFuncs.m_libHandle);')
2347 rs_body.append('}')
2348 return "\n".join(rs_body)
2349
2350 def _generate_replay_init(self):
2351 ri_body = []
2352 ri_body.append('int xglReplay::init(glv_replay::Display & disp)')
2353 ri_body.append('{')
2354 ri_body.append(' int err;')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]2355 ri_body.append('#if defined PLATFORM_LINUX')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2356 ri_body.append(' void * handle = dlopen("libXGL.so", RTLD_LAZY);')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]2357 ri_body.append('#else')
2358 ri_body.append(' HMODULE handle = LoadLibrary("xgl.dll" );')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2359 ri_body.append('#endif\n')
2360 ri_body.append(' if (handle == NULL) {')
2361 ri_body.append(' glv_LogError("Failed to open xgl library.\\n");')
2362 ri_body.append(' return -1;')
2363 ri_body.append(' }')
2364 ri_body.append(' m_xglFuncs.init_funcs(handle);')
2365 ri_body.append(' disp.set_implementation(m_display);')
2366 ri_body.append(' if ((err = m_display->init(disp.get_gpu())) != 0) {')
2367 ri_body.append(' glv_LogError("Failed to init XGL display.\\n");')
2368 ri_body.append(' return err;')
2369 ri_body.append(' }')
2370 ri_body.append(' if (disp.get_window_handle() == 0)')
2371 ri_body.append(' {')
2372 ri_body.append(' if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {')
2373 ri_body.append(' glv_LogError("Failed to create Window\\n");')
2374 ri_body.append(' return err;')
2375 ri_body.append(' }')
2376 ri_body.append(' }')
2377 ri_body.append(' else')
2378 ri_body.append(' {')
2379 ri_body.append(' if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)')
2380 ri_body.append(' {')
2381 ri_body.append(' glv_LogError("Failed to set Window\\n");')
2382 ri_body.append(' return err;')
2383 ri_body.append(' }')
2384 ri_body.append(' }')
2385 ri_body.append(' return 0;')
2386 ri_body.append('}')
2387 return "\n".join(ri_body)
2388
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2389 def _generate_replay_errors(self):
2390 re_body = []
2391 re_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn)')
2392 re_body.append('{')
2393 re_body.append(' glv_replay::GLV_REPLAY_RESULT res = resIn;')
2394 re_body.append(' if (resCall != resTrace) {')
2395 re_body.append(' glv_LogWarn("Mismatched return from API call (%s) traced result %s, replay result %s\\n", entrypointName,')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]2396 re_body.append(' string_XGL_RESULT((XGL_RESULT)resTrace), string_XGL_RESULT((XGL_RESULT)resCall));')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2397 re_body.append(' res = glv_replay::GLV_REPLAY_BAD_RETURN;')
2398 re_body.append(' }')
2399 re_body.append('#if 0')
2400 re_body.append(' if (resCall != XGL_SUCCESS) {')
2401 re_body.append(' glv_LogWarn("API call (%s) returned failed result %s\\n", entrypointName, string_XGL_RESULT(resCall));')
2402 re_body.append(' }')
2403 re_body.append('#endif')
2404 re_body.append(' return res;')
2405 re_body.append('}')
2406 return "\n".join(re_body)
2407
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]2408 def _generate_replay_validation_funcs(self):
2409 rvf_body = []
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2410 rvf_body.append('void xglReplay::push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char * pMsg)')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]2411 rvf_body.append('{')
2412 rvf_body.append(' struct validationMsg msgObj;')
2413 rvf_body.append(' msgObj.validationLevel = validationLevel;')
2414 rvf_body.append(' msgObj.srcObject = srcObject;')
2415 rvf_body.append(' msgObj.location = location;')
2416 rvf_body.append(' msgObj.msgCode = msgCode;')
2417 rvf_body.append(' strncpy(msgObj.msg, pMsg, 256);')
2418 rvf_body.append(" msgObj.msg[255] = '\\0';")
2419 rvf_body.append(' m_validationMsgs.push_back(msgObj);')
2420 rvf_body.append('}\n')
2421 rvf_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::pop_validation_msgs()')
2422 rvf_body.append('{')
2423 rvf_body.append(' if (m_validationMsgs.size() == 0)')
2424 rvf_body.append(' return glv_replay::GLV_REPLAY_SUCCESS;')
2425 rvf_body.append(' m_validationMsgs.clear();')
2426 rvf_body.append(' return glv_replay::GLV_REPLAY_VALIDATION_ERROR;')
2427 rvf_body.append('}')
Jon Ashburn8ef49b12015-02-17 13:28:11 -0700[diff] [blame]2428 rvf_body.append('int xglReplay::dump_validation_data()')
2429 rvf_body.append('{')
Jeremy Hayes2c98e532015-02-26 15:59:19 -0700[diff] [blame]2430 rvf_body.append(' if (!m_pDSDump || !m_pCBDump)')
Jon Ashburn8ef49b12015-02-17 13:28:11 -0700[diff] [blame]2431 rvf_body.append(' {')
Jeremy Hayes2c98e532015-02-26 15:59:19 -0700[diff] [blame]2432 rvf_body.append(' return -1;')
Jon Ashburn8ef49b12015-02-17 13:28:11 -0700[diff] [blame]2433 rvf_body.append(' }')
Jeremy Hayes2c98e532015-02-26 15:59:19 -0700[diff] [blame]2434 rvf_body.append(' m_pDSDump((char *) "pipeline_dump.dot");')
2435 rvf_body.append(' m_pCBDump((char *) "cb_dump.dot");')
2436 rvf_body.append(' return 0;')
Jon Ashburn8ef49b12015-02-17 13:28:11 -0700[diff] [blame]2437 rvf_body.append('}')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]2438 return "\n".join(rvf_body)
2439
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2440 def _generate_replay_init_funcs(self):
2441 rif_body = []
2442 rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')
2443 for proto in self.protos:
2444 rif_body.append(' real_xgl%s = (type_xgl%s)(glv_platform_get_library_entrypoint(handle, "xgl%s"));' % (proto.name, proto.name, proto.name))
2445 rif_body.append('}')
2446 return "\n".join(rif_body)
2447
2448 def _get_packet_param(self, t, n):
2449 # list of types that require remapping
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]2450 remap_list = xgl.object_type_list
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]2451 param_exclude_list = ['p1', 'p2', 'pGpus', 'pDescriptorSets']
2452 if t.strip('*').replace('const ', '') in remap_list and n not in param_exclude_list:
2453 if '*' in t:
2454 if 'const ' not in t:
2455 return 'remap(*pPacket->%s)' % (n)
2456 else: # TODO : Don't remap array ptrs?
2457 return 'pPacket->%s' % (n)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2458 return 'remap(pPacket->%s)' % (n)
2459 return 'pPacket->%s' % (n)
2460
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]2461 def _gen_replay_enum_gpus(self):
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2462 ieg_body = []
2463 ieg_body.append(' if (!m_display->m_initedXGL)')
2464 ieg_body.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2465 ieg_body.append(' uint32_t gpuCount;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2466 ieg_body.append(' XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2467 ieg_body.append(' uint32_t maxGpus = (pPacket->maxGpus < XGL_MAX_PHYSICAL_GPUS) ? pPacket->maxGpus : XGL_MAX_PHYSICAL_GPUS;')
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]2468 ieg_body.append(' replayResult = m_xglFuncs.real_xglEnumerateGpus(remap(pPacket->instance), maxGpus, &gpuCount, &gpus[0]);')
2469 ieg_body.append(' CHECK_RETURN_VALUE(xglEnumerateGpus);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2470 ieg_body.append(' //TODO handle different number of gpus in trace versus replay')
2471 ieg_body.append(' if (gpuCount != *(pPacket->pGpuCount))')
2472 ieg_body.append(' {')
2473 ieg_body.append(' glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\\n", gpuCount, *(pPacket->pGpuCount));')
2474 ieg_body.append(' }')
2475 ieg_body.append(' else if (gpuCount == 0)')
2476 ieg_body.append(' {')
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]2477 ieg_body.append(' glv_LogError("xglEnumerateGpus number of gpus is zero\\n");')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2478 ieg_body.append(' }')
2479 ieg_body.append(' else')
2480 ieg_body.append(' {')
2481 ieg_body.append(' glv_LogInfo("Enumerated %d GPUs in the system\\n", gpuCount);')
2482 ieg_body.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2483 ieg_body.append(' // TODO handle enumeration results in a different order from trace to replay')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2484 ieg_body.append(' for (uint32_t i = 0; i < gpuCount; i++)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2485 ieg_body.append(' {')
2486 ieg_body.append(' if (pPacket->pGpus)')
2487 ieg_body.append(' add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));')
2488 ieg_body.append(' }')
2489 ieg_body.append(' }')
2490 return "\n".join(ieg_body)
2491
2492 def _gen_replay_get_gpu_info(self):
2493 ggi_body = []
2494 ggi_body.append(' if (!m_display->m_initedXGL)')
2495 ggi_body.append(' {')
2496 ggi_body.append(' switch (pPacket->infoType) {')
2497 ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:')
2498 ggi_body.append(' {')
2499 ggi_body.append(' XGL_PHYSICAL_GPU_PROPERTIES gpuProps;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2500 ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2501 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
2502 ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuProps);')
2503 ggi_body.append(' if (pPacket->pData != NULL)')
2504 ggi_body.append(' {')
2505 ggi_body.append(' glv_LogInfo("Replay Gpu Properties\\n");')
2506 ggi_body.append(' glv_LogInfo("Vendor ID %x, Device ID %x, name %s\\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);')
2507 ggi_body.append(' glv_LogInfo("API version %u, Driver version %u, gpu Type %u\\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);')
2508 ggi_body.append(' }')
2509 ggi_body.append(' break;')
2510 ggi_body.append(' }')
2511 ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:')
2512 ggi_body.append(' {')
2513 ggi_body.append(' XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2514 ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2515 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
2516 ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuPerfs);')
2517 ggi_body.append(' if (pPacket->pData != NULL)')
2518 ggi_body.append(' {')
2519 ggi_body.append(' glv_LogInfo("Replay Gpu Performance\\n");')
2520 ggi_body.append(' glv_LogInfo("Max GPU clock %f, max shader ALUs/clock %f, max texel fetches/clock %f\\n",gpuPerfs.maxGpuClock, gpuPerfs.aluPerClock, gpuPerfs.texPerClock);')
2521 ggi_body.append(' glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);')
2522 ggi_body.append(' }')
2523 ggi_body.append(' break;')
2524 ggi_body.append(' }')
2525 ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:')
2526 ggi_body.append(' {')
2527 ggi_body.append(' XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2528 ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);')
2529 ggi_body.append(' size_t numQueues = 1;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2530 ggi_body.append(' assert(pPacket->pDataSize);')
2531 ggi_body.append(' if ((*(pPacket->pDataSize) % dataSize) != 0)')
2532 ggi_body.append(' glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\\n");')
2533 ggi_body.append(' else')
2534 ggi_body.append(' numQueues = *(pPacket->pDataSize) / dataSize;')
2535 ggi_body.append(' dataSize = numQueues * dataSize;')
2536 ggi_body.append(' pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));')
2537 ggi_body.append(' pGpuQueue = pQ;')
2538 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
2539 ggi_body.append(' (pPacket->pData == NULL) ? NULL : pGpuQueue);')
2540 ggi_body.append(' if (pPacket->pData != NULL)')
2541 ggi_body.append(' {')
2542 ggi_body.append(' for (unsigned int i = 0; i < numQueues; i++)')
2543 ggi_body.append(' {')
2544 ggi_body.append(' glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\\n", i, pGpuQueue->queueFlags);')
2545 ggi_body.append(' glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);')
2546 ggi_body.append(' pGpuQueue++;')
2547 ggi_body.append(' }')
2548 ggi_body.append(' }')
2549 ggi_body.append(' glv_free(pQ);')
2550 ggi_body.append(' break;')
2551 ggi_body.append(' }')
2552 ggi_body.append(' default:')
2553 ggi_body.append(' {')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2554 ggi_body.append(' size_t size = 0;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2555 ggi_body.append(' void* pData = NULL;')
2556 ggi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2557 ggi_body.append(' {')
2558 ggi_body.append(' size = *pPacket->pDataSize;')
2559 ggi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2560 ggi_body.append(' }')
2561 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &size, pData);')
2562 ggi_body.append(' if (replayResult == XGL_SUCCESS)')
2563 ggi_body.append(' {')
Jon Ashburne3a667c2015-02-11 09:32:29 -0700[diff] [blame]2564 ggi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2565 ggi_body.append(' {')
2566 ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2567 ggi_body.append(' }')
2568 ggi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2569 ggi_body.append(' {')
2570 ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\\n");')
2571 ggi_body.append(' }')
2572 ggi_body.append(' }')
2573 ggi_body.append(' glv_free(pData);')
2574 ggi_body.append(' break;')
2575 ggi_body.append(' }')
2576 ggi_body.append(' };')
2577 ggi_body.append(' CHECK_RETURN_VALUE(xglGetGpuInfo);')
2578 ggi_body.append(' }')
2579 return "\n".join(ggi_body)
2580
2581 def _gen_replay_create_device(self):
2582 cd_body = []
2583 cd_body.append(' if (!m_display->m_initedXGL)')
2584 cd_body.append(' {')
2585 cd_body.append(' XGL_DEVICE device;')
Peter Lohrmann25643b72015-01-08 19:47:03 -0800[diff] [blame]2586 cd_body.append(' if (g_xglReplaySettings.debugLevel > 0)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2587 cd_body.append(' {')
Jon Ashburn449bfbd2014-12-19 12:31:19 -0700[diff] [blame]2588 cd_body.append(' XGL_DEVICE_CREATE_INFO cInfo, *ci, *pCreateInfoSaved;')
Peter Lohrmann76993742015-01-09 12:34:50 -0800[diff] [blame]2589 cd_body.append(' unsigned int numLayers = 0;')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2590 cd_body.append(' char ** layersStr = get_enableLayers_list(&numLayers);')
Jon Ashburn68dc68e2015-01-13 17:24:49 -0700[diff] [blame]2591 cd_body.append(' apply_layerSettings_overrides();')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]2592 cd_body.append(' XGL_LAYER_CREATE_INFO layerInfo;')
Jon Ashburn449bfbd2014-12-19 12:31:19 -0700[diff] [blame]2593 cd_body.append(' pCreateInfoSaved = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]2594 cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')
Peter Lohrmann76993742015-01-09 12:34:50 -0800[diff] [blame]2595
2596 cd_body.append(' if (layersStr != NULL && numLayers > 0)')
2597 cd_body.append(' {')
2598 cd_body.append(' while (ci->pNext != NULL)')
2599 cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) ci->pNext;')
2600 cd_body.append(' ci->pNext = &layerInfo;')
2601 cd_body.append(' layerInfo.sType = XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO;')
2602 cd_body.append(' layerInfo.pNext = 0;')
2603 cd_body.append(' layerInfo.layerCount = numLayers;')
2604 cd_body.append(' layerInfo.ppActiveLayerNames = layersStr;')
2605 cd_body.append(' }')
2606
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2607 cd_body.append(' memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));')
2608 cd_body.append(' cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]2609 cd_body.append(' cInfo.maxValidationLevel = (XGL_VALIDATION_LEVEL)((g_xglReplaySettings.debugLevel <= 4) ? (unsigned int) XGL_VALIDATION_LEVEL_0 + g_xglReplaySettings.debugLevel : (unsigned int) XGL_VALIDATION_LEVEL_0);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2610 cd_body.append(' pPacket->pCreateInfo = &cInfo;')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]2611 cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')
Jon Ashburn449bfbd2014-12-19 12:31:19 -0700[diff] [blame]2612 cd_body.append(' // restore the packet for next replay')
2613 cd_body.append(' ci->pNext = NULL;')
2614 cd_body.append(' pPacket->pCreateInfo = pCreateInfoSaved;')
Peter Lohrmann76993742015-01-09 12:34:50 -0800[diff] [blame]2615 cd_body.append(' release_enableLayer_list(layersStr);')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]2616 cd_body.append(' if (xglDbgRegisterMsgCallback(g_fpDbgMsgCallback, NULL) != XGL_SUCCESS)')
2617 cd_body.append(' glv_LogError("Failed to register xgl callback for replayer error handling\\n");')
Ian Elliotta34353f2015-03-03 09:50:57 -0700[diff] [blame]2618 cd_body.append('#if !defined(_WIN32)')
Jon Ashburn8ef49b12015-02-17 13:28:11 -0700[diff] [blame]2619 cd_body.append(' m_pDSDump = (DRAW_STATE_DUMP_DOT_FILE) m_xglFuncs.real_xglGetProcAddr(remap(pPacket->gpu), "drawStateDumpDotFile");')
Jeremy Hayes2c98e532015-02-26 15:59:19 -0700[diff] [blame]2620 cd_body.append(' m_pCBDump = (DRAW_STATE_DUMP_COMMAND_BUFFER_DOT_FILE) m_xglFuncs.real_xglGetProcAddr(remap(pPacket->gpu), "drawStateDumpCommandBufferDotFile");')
Ian Elliotta34353f2015-03-03 09:50:57 -0700[diff] [blame]2621 cd_body.append('#endif')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2622 cd_body.append(' }')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]2623 cd_body.append(' else ')
2624 cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2625 cd_body.append(' CHECK_RETURN_VALUE(xglCreateDevice);')
2626 cd_body.append(' if (replayResult == XGL_SUCCESS)')
2627 cd_body.append(' {')
2628 cd_body.append(' add_to_map(pPacket->pDevice, &device);')
2629 cd_body.append(' }')
2630 cd_body.append(' }')
2631 return "\n".join(cd_body)
2632
2633 def _gen_replay_get_extension_support(self):
2634 ges_body = []
2635 ges_body.append(' if (!m_display->m_initedXGL) {')
2636 ges_body.append(' replayResult = m_xglFuncs.real_xglGetExtensionSupport(remap(pPacket->gpu), pPacket->pExtName);')
2637 ges_body.append(' CHECK_RETURN_VALUE(xglGetExtensionSupport);')
2638 ges_body.append(' if (replayResult == XGL_SUCCESS) {')
2639 ges_body.append(' for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)')
2640 ges_body.append(' {')
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]2641 ges_body.append(' if (!strncmp(g_extensions[ext], pPacket->pExtName, strlen(g_extensions[ext]))) {')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2642 ges_body.append(' bool extInList = false;')
2643 ges_body.append(' for (unsigned int j = 0; j < m_display->m_extensions.size(); ++j) {')
Chia-I Wuf1a5a742014-12-27 15:16:07 +0800[diff] [blame]2644 ges_body.append(' if (!strncmp(m_display->m_extensions[j], g_extensions[ext], strlen(g_extensions[ext])))')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2645 ges_body.append(' extInList = true;')
2646 ges_body.append(' break;')
2647 ges_body.append(' }')
2648 ges_body.append(' if (!extInList)')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2649 ges_body.append(' m_display->m_extensions.push_back((char *) g_extensions[ext]);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2650 ges_body.append(' break;')
2651 ges_body.append(' }')
2652 ges_body.append(' }')
2653 ges_body.append(' }')
2654 ges_body.append(' }')
2655 return "\n".join(ges_body)
2656
2657 def _gen_replay_queue_submit(self):
2658 qs_body = []
2659 qs_body.append(' XGL_CMD_BUFFER *remappedBuffers = NULL;')
2660 qs_body.append(' if (pPacket->pCmdBuffers != NULL)')
2661 qs_body.append(' {')
2662 qs_body.append(' remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2663 qs_body.append(' for (uint32_t i = 0; i < pPacket->cmdBufferCount; i++)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2664 qs_body.append(' {')
2665 qs_body.append(' *(remappedBuffers + i) = remap(*(pPacket->pCmdBuffers + i));')
2666 qs_body.append(' }')
2667 qs_body.append(' }')
2668 qs_body.append(' XGL_MEMORY_REF* memRefs = NULL;')
2669 qs_body.append(' if (pPacket->pMemRefs != NULL)')
2670 qs_body.append(' {')
2671 qs_body.append(' memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);')
2672 qs_body.append(' memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2673 qs_body.append(' for (uint32_t i = 0; i < pPacket->memRefCount; i++)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2674 qs_body.append(' {')
2675 qs_body.append(' memRefs[i].mem = remap(pPacket->pMemRefs[i].mem);')
2676 qs_body.append(' }')
2677 qs_body.append(' }')
2678 qs_body.append(' replayResult = m_xglFuncs.real_xglQueueSubmit(remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,')
2679 qs_body.append(' memRefs, remap(pPacket->fence));')
2680 qs_body.append(' GLV_DELETE(remappedBuffers);')
2681 qs_body.append(' GLV_DELETE(memRefs);')
2682 return "\n".join(qs_body)
2683
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2684 def _gen_replay_get_object_info(self):
2685 goi_body = []
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2686 goi_body.append(' size_t size = 0;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2687 goi_body.append(' void* pData = NULL;')
2688 goi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2689 goi_body.append(' {')
2690 goi_body.append(' size = *pPacket->pDataSize;')
2691 goi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2692 goi_body.append(' memcpy(pData, pPacket->pData, *pPacket->pDataSize);')
2693 goi_body.append(' }')
2694 goi_body.append(' replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);')
2695 goi_body.append(' if (replayResult == XGL_SUCCESS)')
2696 goi_body.append(' {')
Jon Ashburne3a667c2015-02-11 09:32:29 -0700[diff] [blame]2697 goi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2698 goi_body.append(' {')
2699 goi_body.append(' glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2700 goi_body.append(' }')
2701 goi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2702 goi_body.append(' {')
2703 goi_body.append(' glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\\n");')
2704 goi_body.append(' }')
2705 goi_body.append(' }')
2706 goi_body.append(' glv_free(pData);')
2707 return "\n".join(goi_body)
2708
2709 def _gen_replay_get_format_info(self):
2710 gfi_body = []
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2711 gfi_body.append(' size_t size = 0;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2712 gfi_body.append(' void* pData = NULL;')
2713 gfi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2714 gfi_body.append(' {')
2715 gfi_body.append(' size = *pPacket->pDataSize;')
2716 gfi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2717 gfi_body.append(' }')
2718 gfi_body.append(' replayResult = m_xglFuncs.real_xglGetFormatInfo(remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);')
2719 gfi_body.append(' if (replayResult == XGL_SUCCESS)')
2720 gfi_body.append(' {')
Jon Ashburne3a667c2015-02-11 09:32:29 -0700[diff] [blame]2721 gfi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2722 gfi_body.append(' {')
2723 gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2724 gfi_body.append(' }')
2725 gfi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2726 gfi_body.append(' {')
2727 gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\\n");')
2728 gfi_body.append(' }')
2729 gfi_body.append(' }')
2730 gfi_body.append(' glv_free(pData);')
2731 return "\n".join(gfi_body)
2732
2733 def _gen_replay_get_image_subresource_info(self):
2734 isi_body = []
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]2735 isi_body.append(' size_t size = 0;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2736 isi_body.append(' void* pData = NULL;')
2737 isi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2738 isi_body.append(' {')
2739 isi_body.append(' size = *pPacket->pDataSize;')
2740 isi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2741 isi_body.append(' }')
2742 isi_body.append(' replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);')
2743 isi_body.append(' if (replayResult == XGL_SUCCESS)')
2744 isi_body.append(' {')
Jon Ashburne3a667c2015-02-11 09:32:29 -0700[diff] [blame]2745 isi_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2746 isi_body.append(' {')
2747 isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2748 isi_body.append(' }')
2749 isi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2750 isi_body.append(' {')
2751 isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\\n");')
2752 isi_body.append(' }')
2753 isi_body.append(' }')
2754 isi_body.append(' glv_free(pData);')
2755 return "\n".join(isi_body)
2756
Tobin Ehlisf29cc372015-01-22 12:29:31 -0700[diff] [blame]2757 def _gen_replay_update_descriptors(self):
2758 ud_body = []
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2759 # We have to remap handles internal to the structures so save the handles prior to remap and then restore
2760 # Rather than doing a deep memcpy of the entire struct and fixing any intermediate pointers, do save and restores via STL queue
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2761 ud_body.append(' XGL_UPDATE_SAMPLERS* pUpdateChain = (XGL_UPDATE_SAMPLERS*)pPacket->pUpdateChain;')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2762 ud_body.append(' std::queue<XGL_SAMPLER> saveSamplers;')
2763 ud_body.append(' std::queue<XGL_BUFFER_VIEW> saveBufferViews;')
2764 ud_body.append(' std::queue<XGL_IMAGE_VIEW> saveImageViews;')
2765 ud_body.append(' std::queue<XGL_DESCRIPTOR_SET> saveDescSets;')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2766 ud_body.append(' while (pUpdateChain) {')
2767 ud_body.append(' switch(pUpdateChain->sType)')
2768 ud_body.append(' {')
2769 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2770 ud_body.append(' for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLERS*)pUpdateChain)->count; i++) {')
2771 ud_body.append(' XGL_SAMPLER* pLocalSampler = (XGL_SAMPLER*) &((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i];')
2772 ud_body.append(' saveSamplers.push(*pLocalSampler);')
Tobin Ehlis49c3ddd2015-02-04 14:57:24 -0700[diff] [blame]2773 ud_body.append(' *pLocalSampler = remap(((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i]);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2774 ud_body.append(' }')
2775 ud_body.append(' break;')
2776 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2777 ud_body.append(' {')
2778 ud_body.append(' XGL_UPDATE_SAMPLER_TEXTURES *pUST = (XGL_UPDATE_SAMPLER_TEXTURES *) pUpdateChain;')
2779 ud_body.append(' for (uint32_t i = 0; i < pUST->count; i++) {')
2780 ud_body.append(' XGL_SAMPLER *pLocalSampler = (XGL_SAMPLER *) &pUST->pSamplerImageViews[i].pSampler;')
2781 ud_body.append(' saveSamplers.push(*pLocalSampler);')
2782 ud_body.append(' *pLocalSampler = remap(pUST->pSamplerImageViews[i].pSampler);')
2783 ud_body.append(' XGL_IMAGE_VIEW *pLocalView = (XGL_IMAGE_VIEW *) &pUST->pSamplerImageViews[i].pImageView->view;')
2784 ud_body.append(' saveImageViews.push(*pLocalView);')
2785 ud_body.append(' *pLocalView = remap(pUST->pSamplerImageViews[i].pImageView->view);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2786 ud_body.append(' }')
2787 ud_body.append(' break;')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2788 ud_body.append(' }')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2789 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2790 ud_body.append(' {')
2791 ud_body.append(' XGL_UPDATE_IMAGES *pUI = (XGL_UPDATE_IMAGES*) pUpdateChain;')
2792 ud_body.append(' for (uint32_t i = 0; i < pUI->count; i++) {')
2793 ud_body.append(' XGL_IMAGE_VIEW* pLocalView = (XGL_IMAGE_VIEW*) &pUI->pImageViews[i]->view;')
2794 ud_body.append(' saveImageViews.push(*pLocalView);')
2795 ud_body.append(' *pLocalView = remap(pUI->pImageViews[i]->view);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2796 ud_body.append(' }')
2797 ud_body.append(' break;')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2798 ud_body.append(' }')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2799 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2800 ud_body.append(' {')
2801 ud_body.append(' XGL_UPDATE_BUFFERS *pUB = (XGL_UPDATE_BUFFERS *) pUpdateChain;')
2802 ud_body.append(' for (uint32_t i = 0; i < pUB->count; i++) {')
2803 ud_body.append(' XGL_BUFFER_VIEW* pLocalView = (XGL_BUFFER_VIEW*) &pUB->pBufferViews[i]->view;')
2804 ud_body.append(' saveBufferViews.push(*pLocalView);')
2805 ud_body.append(' *pLocalView = remap(pUB->pBufferViews[i]->view);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2806 ud_body.append(' }')
2807 ud_body.append(' break;')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2808 ud_body.append(' }')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2809 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2810 ud_body.append(' saveDescSets.push(((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet);')
2811 ud_body.append(' ((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet = remap(((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2812 ud_body.append(' break;')
2813 ud_body.append(' default:')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2814 ud_body.append(' assert(0);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2815 ud_body.append(' break;')
2816 ud_body.append(' }')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2817 ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*) pUpdateChain->pNext;')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2818 ud_body.append(' }')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2819 ud_body.append(' m_xglFuncs.real_xglUpdateDescriptors(remap(pPacket->descriptorSet), pPacket->pUpdateChain);')
2820 ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*) pPacket->pUpdateChain;')
2821 ud_body.append(' while (pUpdateChain) {')
2822 ud_body.append(' switch(pUpdateChain->sType)')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2823 ud_body.append(' {')
2824 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2825 ud_body.append(' for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLERS*)pUpdateChain)->count; i++) {')
2826 ud_body.append(' XGL_SAMPLER* pLocalSampler = (XGL_SAMPLER*) &((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i];')
2827 ud_body.append(' *pLocalSampler = saveSamplers.front();')
2828 ud_body.append(' saveSamplers.pop();')
2829 ud_body.append(' }')
2830 ud_body.append(' break;')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2831 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2832 ud_body.append(' {')
2833 ud_body.append(' XGL_UPDATE_SAMPLER_TEXTURES *pUST = (XGL_UPDATE_SAMPLER_TEXTURES *) pUpdateChain;')
2834 ud_body.append(' for (uint32_t i = 0; i < pUST->count; i++) {')
2835 ud_body.append(' XGL_SAMPLER *plocalSampler = (XGL_SAMPLER *) &pUST->pSamplerImageViews[i].pSampler;')
2836 ud_body.append(' *plocalSampler = saveSamplers.front();')
2837 ud_body.append(' saveSamplers.pop();')
2838 ud_body.append(' XGL_IMAGE_VIEW *pLocalView = (XGL_IMAGE_VIEW *) &pUST->pSamplerImageViews[i].pImageView->view;')
2839 ud_body.append(' *pLocalView = saveImageViews.front();')
2840 ud_body.append(' saveImageViews.pop();')
2841 ud_body.append(' }')
2842 ud_body.append(' break;')
2843 ud_body.append(' }')
2844 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
2845 ud_body.append(' {')
2846 ud_body.append(' XGL_UPDATE_IMAGES *pUI = (XGL_UPDATE_IMAGES*) pUpdateChain;')
2847 ud_body.append(' for (uint32_t i = 0; i < pUI->count; i++) {')
2848 ud_body.append(' XGL_IMAGE_VIEW* pLocalView = (XGL_IMAGE_VIEW*) &pUI->pImageViews[i]->view;')
2849 ud_body.append(' *pLocalView = saveImageViews.front();')
2850 ud_body.append(' saveImageViews.pop();')
2851 ud_body.append(' }')
2852 ud_body.append(' break;')
2853 ud_body.append(' }')
2854 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
2855 ud_body.append(' {')
2856 ud_body.append(' XGL_UPDATE_BUFFERS *pUB = (XGL_UPDATE_BUFFERS *) pUpdateChain;')
2857 ud_body.append(' for (uint32_t i = 0; i < pUB->count; i++) {')
2858 ud_body.append(' XGL_BUFFER_VIEW* pLocalView = (XGL_BUFFER_VIEW*) &pUB->pBufferViews[i]->view;')
2859 ud_body.append(' *pLocalView = saveBufferViews.front();')
2860 ud_body.append(' saveBufferViews.pop();')
2861 ud_body.append(' }')
2862 ud_body.append(' break;')
2863 ud_body.append(' }')
2864 ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
2865 ud_body.append(' ((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet = saveDescSets.front();')
2866 ud_body.append(' saveDescSets.pop();')
2867 ud_body.append(' //pFreeMe = (XGL_UPDATE_SAMPLERS*)pLocalUpdateChain;')
2868 ud_body.append(' //pLocalUpdateChain = (void*)((XGL_UPDATE_SAMPLERS*)pLocalUpdateChain)->pNext;')
2869 ud_body.append(' //free(pFreeMe);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2870 ud_body.append(' break;')
2871 ud_body.append(' default:')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2872 ud_body.append(' assert(0);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2873 ud_body.append(' break;')
2874 ud_body.append(' }')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]2875 ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*) pUpdateChain->pNext;')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2876 ud_body.append(' }')
2877 return "\n".join(ud_body)
Tobin Ehlisf29cc372015-01-22 12:29:31 -0700[diff] [blame]2878
2879 def _gen_replay_create_descriptor_set_layout(self):
2880 cdsl_body = []
Jon Ashburn05cfe262015-02-10 14:32:23 -0700[diff] [blame]2881 cdsl_body.append(' XGL_SAMPLER saveSampler;')
2882 cdsl_body.append(' if (pPacket->pSetLayoutInfoList != NULL) {')
2883 cdsl_body.append(' XGL_SAMPLER *pSampler = (XGL_SAMPLER *) &pPacket->pSetLayoutInfoList->immutableSampler;')
2884 cdsl_body.append(' saveSampler = pPacket->pSetLayoutInfoList->immutableSampler;')
2885 cdsl_body.append(' *pSampler = remap(saveSampler);')
2886 cdsl_body.append(' }')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2887 cdsl_body.append(' XGL_DESCRIPTOR_SET_LAYOUT setLayout;')
Jon Ashburn05cfe262015-02-10 14:32:23 -0700[diff] [blame]2888 cdsl_body.append(' replayResult = m_xglFuncs.real_xglCreateDescriptorSetLayout(remap(pPacket->device), pPacket->stageFlags, pPacket->pSetBindPoints, remap(pPacket->priorSetLayout), pPacket->pSetLayoutInfoList, &setLayout);')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2889 cdsl_body.append(' if (replayResult == XGL_SUCCESS)')
2890 cdsl_body.append(' {')
2891 cdsl_body.append(' add_to_map(pPacket->pSetLayout, &setLayout);')
2892 cdsl_body.append(' }')
Jon Ashburn05cfe262015-02-10 14:32:23 -0700[diff] [blame]2893 cdsl_body.append(' if (pPacket->pSetLayoutInfoList != NULL) {')
2894 cdsl_body.append(' XGL_SAMPLER *pSampler = (XGL_SAMPLER *) &pPacket->pSetLayoutInfoList->immutableSampler;')
2895 cdsl_body.append(' *pSampler = saveSampler;')
2896 cdsl_body.append(' }')
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]2897 return "\n".join(cdsl_body)
Tobin Ehlisf29cc372015-01-22 12:29:31 -0700[diff] [blame]2898
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2899 def _gen_replay_create_graphics_pipeline(self):
2900 cgp_body = []
2901 cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')
2902 cgp_body.append(' struct shaderPair saveShader[10];')
2903 cgp_body.append(' unsigned int idx = 0;')
2904 cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')
Jon Ashburn23438a72015-02-03 17:47:58 -0700[diff] [blame]2905 cgp_body.append(' createInfo.lastSetLayout = remap(createInfo.lastSetLayout);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]2906 cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')
2907 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')
2908 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')
2909 cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')
2910 cgp_body.append(' {')
2911 cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')
2912 cgp_body.append(' {')
2913 cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')
2914 cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')
2915 cgp_body.append(' pNext->shader.shader = remap(pPacketNext->shader.shader);')
2916 cgp_body.append(' }')
2917 cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')
2918 cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')
2919 cgp_body.append(' }')
2920 cgp_body.append(' XGL_PIPELINE pipeline;')
2921 cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(remap(pPacket->device), &createInfo, &pipeline);')
2922 cgp_body.append(' if (replayResult == XGL_SUCCESS)')
2923 cgp_body.append(' {')
2924 cgp_body.append(' add_to_map(pPacket->pPipeline, &pipeline);')
2925 cgp_body.append(' }')
2926 cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')
2927 cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')
2928 return "\n".join(cgp_body)
2929
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]2930 def _gen_replay_cmd_wait_events(self):
2931 cwe_body = []
Jon Ashburn67c65802015-02-10 10:36:22 -0700[diff] [blame]2932 cwe_body.append(' XGL_EVENT saveEvent[100];')
2933 cwe_body.append(' uint32_t idx, numRemapBuf=0, numRemapImg=0;')
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]2934 cwe_body.append(' assert(pPacket->pWaitInfo && pPacket->pWaitInfo->eventCount <= 100);')
2935 cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->eventCount; idx++)')
2936 cwe_body.append(' {')
Jon Ashburn67c65802015-02-10 10:36:22 -0700[diff] [blame]2937 cwe_body.append(' XGL_EVENT *pEvent = (XGL_EVENT *) &(pPacket->pWaitInfo->pEvents[idx]);')
2938 cwe_body.append(' saveEvent[idx] = pPacket->pWaitInfo->pEvents[idx];')
2939 cwe_body.append(' *pEvent = remap(pPacket->pWaitInfo->pEvents[idx]);')
2940 cwe_body.append(' }')
2941 cwe_body.append('')
2942 cwe_body.append(' XGL_BUFFER saveBuf[100];')
2943 cwe_body.append(' XGL_IMAGE saveImg[100];')
2944 cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->memBarrierCount; idx++)')
2945 cwe_body.append(' {')
2946 cwe_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
2947 cwe_body.append(' assert(pNext);')
2948 cwe_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
2949 cwe_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
2950 cwe_body.append(' assert(numRemapBuf < 100);')
2951 cwe_body.append(' saveBuf[numRemapBuf++] = pNextBuf->buffer;')
2952 cwe_body.append(' pNextBuf->buffer = remap(pNextBuf->buffer);')
2953 cwe_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
2954 cwe_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
2955 cwe_body.append(' assert(numRemapImg < 100);')
2956 cwe_body.append(' saveImg[numRemapImg++] = pNextImg->image;')
2957 cwe_body.append(' pNextImg->image = remap(pNextImg->image);')
2958 cwe_body.append(' }')
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]2959 cwe_body.append(' }')
2960 cwe_body.append(' m_xglFuncs.real_xglCmdWaitEvents(remap(pPacket->cmdBuffer), pPacket->pWaitInfo);')
Jon Ashburn67c65802015-02-10 10:36:22 -0700[diff] [blame]2961 cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->memBarrierCount; idx++) {')
2962 cwe_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
2963 cwe_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
2964 cwe_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
2965 cwe_body.append(' pNextBuf->buffer = saveBuf[idx];')
2966 cwe_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
2967 cwe_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pWaitInfo->ppMemBarriers[idx];')
2968 cwe_body.append(' pNextImg->image = saveImg[idx];')
2969 cwe_body.append(' }')
2970 cwe_body.append(' }')
2971 cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->eventCount; idx++) {')
2972 cwe_body.append(' XGL_EVENT *pEvent = (XGL_EVENT *) &(pPacket->pWaitInfo->pEvents[idx]);')
2973 cwe_body.append(' *pEvent = saveEvent[idx];')
2974 cwe_body.append(' }')
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]2975 return "\n".join(cwe_body)
2976
Jon Ashburn67c65802015-02-10 10:36:22 -0700[diff] [blame]2977 def _gen_replay_cmd_pipeline_barrier(self):
2978 cpb_body = []
2979 cpb_body.append(' uint32_t idx, numRemapBuf=0, numRemapImg=0;')
2980 cpb_body.append(' XGL_BUFFER saveBuf[100];')
2981 cpb_body.append(' XGL_IMAGE saveImg[100];')
2982 cpb_body.append(' for (idx = 0; idx < pPacket->pBarrier->memBarrierCount; idx++)')
2983 cpb_body.append(' {')
2984 cpb_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
2985 cpb_body.append(' assert(pNext);')
2986 cpb_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
2987 cpb_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
2988 cpb_body.append(' assert(numRemapBuf < 100);')
2989 cpb_body.append(' saveBuf[numRemapBuf++] = pNextBuf->buffer;')
2990 cpb_body.append(' pNextBuf->buffer = remap(pNextBuf->buffer);')
2991 cpb_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
2992 cpb_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
2993 cpb_body.append(' assert(numRemapImg < 100);')
2994 cpb_body.append(' saveImg[numRemapImg++] = pNextImg->image;')
2995 cpb_body.append(' pNextImg->image = remap(pNextImg->image);')
2996 cpb_body.append(' }')
2997 cpb_body.append(' }')
2998 cpb_body.append(' m_xglFuncs.real_xglCmdPipelineBarrier(remap(pPacket->cmdBuffer), pPacket->pBarrier);')
2999 cpb_body.append(' for (idx = 0; idx < pPacket->pBarrier->memBarrierCount; idx++) {')
3000 cpb_body.append(' XGL_MEMORY_BARRIER *pNext = (XGL_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
3001 cpb_body.append(' if (pNext->sType == XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) {')
3002 cpb_body.append(' XGL_BUFFER_MEMORY_BARRIER *pNextBuf = (XGL_BUFFER_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
3003 cpb_body.append(' pNextBuf->buffer = saveBuf[idx];')
3004 cpb_body.append(' } else if (pNext->sType == XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {')
3005 cpb_body.append(' XGL_IMAGE_MEMORY_BARRIER *pNextImg = (XGL_IMAGE_MEMORY_BARRIER *) pPacket->pBarrier->ppMemBarriers[idx];')
3006 cpb_body.append(' pNextImg->image = saveImg[idx];')
3007 cpb_body.append(' }')
3008 cpb_body.append(' }')
3009 return "\n".join(cpb_body)
3010
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]3011 def _gen_replay_create_framebuffer(self):
3012 cf_body = []
3013 cf_body.append(' XGL_FRAMEBUFFER_CREATE_INFO *pInfo = (XGL_FRAMEBUFFER_CREATE_INFO *) pPacket->pCreateInfo;')
3014 cf_body.append(' XGL_COLOR_ATTACHMENT_BIND_INFO *pColorAttachments, *pSavedColor = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pInfo->pColorAttachments;')
3015 cf_body.append(' bool allocatedColorAttachments = false;')
3016 cf_body.append(' if (pSavedColor != NULL)')
3017 cf_body.append(' {')
3018 cf_body.append(' allocatedColorAttachments = true;')
3019 cf_body.append(' pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pInfo->colorAttachmentCount);')
3020 cf_body.append(' memcpy(pColorAttachments, pSavedColor, sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) * pInfo->colorAttachmentCount);')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]3021 cf_body.append(' for (uint32_t i = 0; i < pInfo->colorAttachmentCount; i++)')
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]3022 cf_body.append(' {')
3023 cf_body.append(' pColorAttachments[i].view = remap(pInfo->pColorAttachments[i].view);')
3024 cf_body.append(' }')
3025 cf_body.append(' pInfo->pColorAttachments = pColorAttachments;')
3026 cf_body.append(' }')
3027 cf_body.append(' // remap depth stencil target')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]3028 cf_body.append(' const XGL_DEPTH_STENCIL_BIND_INFO *pSavedDS = pInfo->pDepthStencilAttachment;')
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]3029 cf_body.append(' XGL_DEPTH_STENCIL_BIND_INFO depthTarget;')
3030 cf_body.append(' if (pSavedDS != NULL)')
3031 cf_body.append(' {')
3032 cf_body.append(' memcpy(&depthTarget, pSavedDS, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));')
3033 cf_body.append(' depthTarget.view = remap(pSavedDS->view);')
3034 cf_body.append(' pInfo->pDepthStencilAttachment = &depthTarget;')
3035 cf_body.append(' }')
3036 cf_body.append(' XGL_FRAMEBUFFER local_framebuffer;')
3037 cf_body.append(' replayResult = m_xglFuncs.real_xglCreateFramebuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_framebuffer);')
3038 cf_body.append(' pInfo->pColorAttachments = pSavedColor;')
3039 cf_body.append(' pInfo->pDepthStencilAttachment = pSavedDS;')
3040 cf_body.append(' if (replayResult == XGL_SUCCESS)')
3041 cf_body.append(' {')
3042 cf_body.append(' add_to_map(pPacket->pFramebuffer, &local_framebuffer);')
3043 cf_body.append(' }')
3044 cf_body.append(' if (allocatedColorAttachments)')
3045 cf_body.append(' {')
3046 cf_body.append(' GLV_DELETE((void*)pColorAttachments);')
3047 cf_body.append(' }')
3048 return "\n".join(cf_body)
3049
3050 def _gen_replay_create_renderpass(self):
3051 cr_body = []
3052 cr_body.append(' XGL_RENDER_PASS_CREATE_INFO *pInfo = (XGL_RENDER_PASS_CREATE_INFO *) pPacket->pCreateInfo;')
3053 cr_body.append(' // remap framebuffer')
3054 cr_body.append(' XGL_FRAMEBUFFER savedFB, *pFB = &(pInfo->framebuffer);')
3055 cr_body.append(' if (*pFB != NULL)')
3056 cr_body.append(' {')
3057 cr_body.append(' savedFB = pInfo->framebuffer;')
3058 cr_body.append(' *pFB = remap(pInfo->framebuffer);')
3059 cr_body.append(' }')
3060 cr_body.append(' XGL_RENDER_PASS local_renderpass;')
3061 cr_body.append(' replayResult = m_xglFuncs.real_xglCreateRenderPass(remap(pPacket->device), pPacket->pCreateInfo, &local_renderpass);')
3062 cr_body.append(' pInfo->framebuffer = savedFB;')
3063 cr_body.append(' if (replayResult == XGL_SUCCESS)')
3064 cr_body.append(' {')
3065 cr_body.append(' add_to_map(pPacket->pRenderPass, &local_renderpass);')
3066 cr_body.append(' }')
3067 return "\n".join(cr_body)
3068
3069 def _gen_replay_begin_command_buffer(self):
3070 bcb_body = []
3071 bcb_body.append(' XGL_CMD_BUFFER_BEGIN_INFO* pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*)pPacket->pBeginInfo;')
3072 bcb_body.append(' // assume only zero or one graphics_begin_info in the chain')
3073 bcb_body.append(' XGL_RENDER_PASS savedRP, *pRP;')
3074 bcb_body.append(' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *pGInfo = NULL;')
3075 bcb_body.append(' while (pInfo != NULL)')
3076 bcb_body.append(' {')
3077 bcb_body.append('')
3078 bcb_body.append(' if (pInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO)')
3079 bcb_body.append(' {')
3080 bcb_body.append(' pGInfo = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *) pInfo;')
3081 bcb_body.append(' savedRP = pGInfo->renderPass;')
3082 bcb_body.append(' pRP = &(pGInfo->renderPass);')
3083 bcb_body.append(' *pRP = remap(pGInfo->renderPass);')
3084 bcb_body.append(' break;')
3085 bcb_body.append(' }')
3086 bcb_body.append(' pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*) pInfo->pNext;')
3087 bcb_body.append(' }')
3088 bcb_body.append(' replayResult = m_xglFuncs.real_xglBeginCommandBuffer(remap(pPacket->cmdBuffer), pPacket->pBeginInfo);')
3089 bcb_body.append(' if (pGInfo != NULL)')
3090 bcb_body.append(' pGInfo->renderPass = savedRP;')
3091 return "\n".join(bcb_body)
3092
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3093 def _gen_replay_store_pipeline(self):
3094 sp_body = []
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]3095 sp_body.append(' size_t size = 0;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3096 sp_body.append(' void* pData = NULL;')
3097 sp_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
3098 sp_body.append(' {')
3099 sp_body.append(' size = *pPacket->pDataSize;')
3100 sp_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
3101 sp_body.append(' }')
3102 sp_body.append(' replayResult = m_xglFuncs.real_xglStorePipeline(remap(pPacket->pipeline), &size, pData);')
3103 sp_body.append(' if (replayResult == XGL_SUCCESS)')
3104 sp_body.append(' {')
Jon Ashburne3a667c2015-02-11 09:32:29 -0700[diff] [blame]3105 sp_body.append(' if (size != *pPacket->pDataSize && pData != NULL)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3106 sp_body.append(' {')
3107 sp_body.append(' glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
3108 sp_body.append(' }')
3109 sp_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
3110 sp_body.append(' {')
3111 sp_body.append(' glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\\n");')
3112 sp_body.append(' }')
3113 sp_body.append(' }')
3114 sp_body.append(' glv_free(pData);')
3115 return "\n".join(sp_body)
3116
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3117 def _gen_replay_get_multi_gpu_compatibility(self):
3118 gmgc_body = []
3119 gmgc_body.append(' XGL_GPU_COMPATIBILITY_INFO cInfo;')
3120 gmgc_body.append(' XGL_PHYSICAL_GPU handle0, handle1;')
3121 gmgc_body.append(' handle0 = remap(pPacket->gpu0);')
3122 gmgc_body.append(' handle1 = remap(pPacket->gpu1);')
3123 gmgc_body.append(' replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);')
3124 return "\n".join(gmgc_body)
3125
3126 def _gen_replay_destroy_object(self):
3127 do_body = []
3128 do_body.append(' XGL_OBJECT object = remap(pPacket->object);')
3129 do_body.append(' if (object != XGL_NULL_HANDLE)')
3130 do_body.append(' replayResult = m_xglFuncs.real_xglDestroyObject(object);')
3131 do_body.append(' if (replayResult == XGL_SUCCESS)')
3132 do_body.append(' rm_from_map(pPacket->object);')
3133 return "\n".join(do_body)
3134
3135 def _gen_replay_wait_for_fences(self):
3136 wf_body = []
3137 wf_body.append(' XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]3138 wf_body.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3139 wf_body.append(' {')
3140 wf_body.append(' *(pFence + i) = remap(*(pPacket->pFences + i));')
3141 wf_body.append(' }')
3142 wf_body.append(' replayResult = m_xglFuncs.real_xglWaitForFences(remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);')
3143 wf_body.append(' GLV_DELETE(pFence);')
3144 return "\n".join(wf_body)
3145
3146 def _gen_replay_wsi_associate_connection(self):
3147 wac_body = []
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3148 wac_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3149 wac_body.append(' //associate with the replayers Wsi connection rather than tracers')
3150 wac_body.append(' replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3151 wac_body.append('#elif defined(WIN32)')
3152 wac_body.append(' //TBD')
3153 wac_body.append(' replayResult = XGL_SUCCESS;')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]3154 wac_body.append('#endif')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3155 return "\n".join(wac_body)
3156
3157 def _gen_replay_wsi_get_msc(self):
3158 wgm_body = []
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3159 wgm_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
3160 wgm_body.append(' xcb_window_t window = m_display->m_XcbWindow;')
3161 wgm_body.append(' replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')
3162 wgm_body.append('#elif defined(WIN32)')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]3163 wgm_body.append(' //TBD')
3164 wgm_body.append(' replayResult = XGL_SUCCESS;')
3165 wgm_body.append('#else')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3166
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]3167 wgm_body.append('#endif')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3168 return "\n".join(wgm_body)
3169
3170 def _gen_replay_wsi_create_presentable_image(self):
3171 cpi_body = []
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3172 cpi_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3173 cpi_body.append(' XGL_IMAGE img;')
3174 cpi_body.append(' XGL_GPU_MEMORY mem;')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]3175 cpi_body.append(' m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height);')
3176 cpi_body.append(' m_display->imageWidth.push_back(pPacket->pCreateInfo->extent.width);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3177 cpi_body.append(' replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);')
3178 cpi_body.append(' if (replayResult == XGL_SUCCESS)')
3179 cpi_body.append(' {')
3180 cpi_body.append(' if (pPacket->pImage != NULL)')
3181 cpi_body.append(' add_to_map(pPacket->pImage, &img);')
3182 cpi_body.append(' if(pPacket->pMem != NULL)')
3183 cpi_body.append(' add_to_map(pPacket->pMem, &mem);')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]3184 cpi_body.append(' m_display->imageHandles.push_back(img);')
3185 cpi_body.append(' m_display->imageMemory.push_back(mem);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3186 cpi_body.append(' }')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3187 cpi_body.append('#elif defined(WIN32)')
3188 cpi_body.append(' //TBD')
3189 cpi_body.append(' replayResult = XGL_SUCCESS;')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]3190 cpi_body.append('#endif')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3191 return "\n".join(cpi_body)
3192
3193 def _gen_replay_wsi_queue_present(self):
3194 wqp_body = []
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3195 wqp_body.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3196 wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]3197 wqp_body.append(' std::vector<int>::iterator it;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3198 wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')
3199 wqp_body.append(' pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);')
3200 wqp_body.append(' // use replayers Xcb window')
3201 wqp_body.append(' pInfo.destWindow = m_display->m_XcbWindow;')
3202 wqp_body.append(' replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]3203 wqp_body.append(' it = std::find(m_screenshotFrames.begin(), m_screenshotFrames.end(), m_display->m_frameNumber);')
3204 wqp_body.append(' if (it != m_screenshotFrames.end())')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]3205 wqp_body.append(' {')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]3206 wqp_body.append(' for(unsigned int i=0; i<m_display->imageHandles.size(); i++)')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]3207 wqp_body.append(' {')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]3208 wqp_body.append(' if (m_display->imageHandles[i] == pInfo.srcImage)')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]3209 wqp_body.append(' {')
3210 wqp_body.append(' char frameName[32];')
3211 wqp_body.append(' sprintf(frameName, "%d",m_display->m_frameNumber);')
Tony Barboura7390a02015-02-05 09:46:17 -0700[diff] [blame]3212 wqp_body.append(' glvWritePPM(frameName, m_display->imageWidth[i], m_display->imageHeight[i],')
3213 wqp_body.append(' m_display->imageHandles[i], m_display->imageMemory[i], &m_xglFuncs);')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]3214 wqp_body.append(' break;')
3215 wqp_body.append(' }')
3216 wqp_body.append(' }')
3217 wqp_body.append(' }')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3218 wqp_body.append('#elif defined(WIN32)')
3219 wqp_body.append(' //TBD')
3220 wqp_body.append(' replayResult = XGL_SUCCESS;')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]3221 wqp_body.append('#endif')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]3222 wqp_body.append(' m_display->m_frameNumber++;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3223 return "\n".join(wqp_body)
3224
3225 # I don't like making these 3 mem functions 'fully' custom, but just doing it for now to avoid being too cute
3226 def _gen_replay_free_memory(self):
3227 fm_body = []
3228 fm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')
3229 fm_body.append(' replayResult = m_xglFuncs.real_xglFreeMemory(handle);')
3230 fm_body.append(' if (replayResult == XGL_SUCCESS) ')
3231 fm_body.append(' {')
3232 fm_body.append(' rm_entry_from_mapData(handle);')
3233 fm_body.append(' rm_from_map(pPacket->mem);')
3234 fm_body.append(' }')
3235 return "\n".join(fm_body)
3236
3237 def _gen_replay_map_memory(self):
3238 mm_body = []
3239 mm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600[diff] [blame]3240 mm_body.append(' void* pData;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3241 mm_body.append(' replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);')
3242 mm_body.append(' if (replayResult == XGL_SUCCESS)')
3243 mm_body.append(' add_mapping_to_mapData(handle, pData);')
3244 return "\n".join(mm_body)
3245
3246 def _gen_replay_unmap_memory(self):
3247 um_body = []
3248 um_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')
Jon Ashburn290dcb12015-03-02 17:12:31 -0700[diff] [blame]3249 um_body.append(' rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3250 um_body.append(' replayResult = m_xglFuncs.real_xglUnmapMemory(handle);')
3251 return "\n".join(um_body)
3252
3253 def _gen_replay_bind_dynamic_memory_view(self):
3254 bdmv_body = []
3255 bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')
3256 bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));')
3257 bdmv_body.append(' memView.mem = remap(pPacket->pMemView->mem);')
3258 bdmv_body.append(' m_xglFuncs.real_xglCmdBindDynamicMemoryView(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')
3259 return "\n".join(bdmv_body)
3260
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]3261 # Generate main replay case statements where actual replay API call is dispatched based on input packet data
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3262 def _generate_replay(self):
3263 # map protos to custom functions if body is fully custom
Tobin Ehlis10777032015-01-16 15:13:34 -0700[diff] [blame]3264 custom_body_dict = {'EnumerateGpus': self._gen_replay_enum_gpus,
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3265 'GetGpuInfo': self._gen_replay_get_gpu_info,
3266 'CreateDevice': self._gen_replay_create_device,
3267 'GetExtensionSupport': self._gen_replay_get_extension_support,
3268 'QueueSubmit': self._gen_replay_queue_submit,
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3269 'GetObjectInfo': self._gen_replay_get_object_info,
3270 'GetFormatInfo': self._gen_replay_get_format_info,
3271 'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,
3272 'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,
Jon Ashburn38349d02015-01-02 18:28:26 -0700[diff] [blame]3273 'CreateFramebuffer': self._gen_replay_create_framebuffer,
3274 'CreateRenderPass': self._gen_replay_create_renderpass,
3275 'BeginCommandBuffer': self._gen_replay_begin_command_buffer,
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3276 'StorePipeline': self._gen_replay_store_pipeline,
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3277 'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,
3278 'DestroyObject': self._gen_replay_destroy_object,
3279 'WaitForFences': self._gen_replay_wait_for_fences,
3280 'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,
3281 'WsiX11GetMSC': self._gen_replay_wsi_get_msc,
3282 'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,
3283 'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,
3284 'FreeMemory': self._gen_replay_free_memory,
3285 'MapMemory': self._gen_replay_map_memory,
3286 'UnmapMemory': self._gen_replay_unmap_memory,
Tobin Ehlisf6f8cd42015-02-03 14:41:26 -0700[diff] [blame]3287 'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view,
3288 'UpdateDescriptors': self._gen_replay_update_descriptors,
Tobin Ehlisa8f6afe2015-02-05 11:29:45 -0700[diff] [blame]3289 'CreateDescriptorSetLayout': self._gen_replay_create_descriptor_set_layout,
Jon Ashburn67c65802015-02-10 10:36:22 -0700[diff] [blame]3290 'CmdWaitEvents': self._gen_replay_cmd_wait_events,
3291 'CmdPipelineBarrier': self._gen_replay_cmd_pipeline_barrier}
Tobin Ehlisf29cc372015-01-22 12:29:31 -0700[diff] [blame]3292 # TODO : Need to guard CreateInstance with "if (!m_display->m_initedXGL)" check
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3293 # Despite returning a value, don't check these funcs b/c custom code includes check already
Jon Ashburn03d0bcc2015-02-03 11:24:08 -0700[diff] [blame]3294 custom_check_ret_val = ['EnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport']
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3295 # multi-gpu Open funcs w/ list of local params to create
3296 custom_open_params = {'OpenSharedMemory': (-1,),
3297 'OpenSharedQueueSemaphore': (-1,),
3298 'OpenPeerMemory': (-1,),
3299 'OpenPeerImage': (-1, -2,)}
3300 # Functions that create views are unique from other create functions
Jon Ashburn03d0bcc2015-02-03 11:24:08 -0700[diff] [blame]3301 create_view_list = ['CreateBufferView', 'CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3302 # Functions to treat as "Create' that don't have 'Create' in the name
Tobin Ehlis271e51d2015-01-20 13:50:59 -0700[diff] [blame]3303 special_create_list = ['LoadPipeline', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3304 # A couple funcs use do while loops
3305 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'}
3306 rbody = []
3307 rbody.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')
3308 rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')
3309 rbody.append('{')
3310 rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')
3311 rbody.append(' XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;')
3312 rbody.append(' switch (packet->packet_id)')
3313 rbody.append(' {')
Jon Ashburnd07dfef2015-02-03 08:57:28 -0700[diff] [blame]3314 rbody.append(' case GLV_TPI_XGL_xglApiVersion:')
3315 rbody.append(' break; // nothing to replay on the version packet')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3316 for proto in self.protos:
3317 ret_value = False
3318 create_view = False
3319 create_func = False
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]3320 # TODO : How to handle void* return of GetProcAddr?
3321 if ('void' not in proto.ret) and (proto.name not in custom_check_ret_val):
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3322 ret_value = True
3323 if proto.name in create_view_list:
3324 create_view = True
3325 elif 'Create' in proto.name or proto.name in special_create_list:
3326 create_func = True
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3327 rbody.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
3328 rbody.append(' {')
3329 rbody.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(packet->pBody);' % (proto.name, proto.name))
3330 if proto.name in custom_body_dict:
3331 rbody.append(custom_body_dict[proto.name]())
3332 else:
3333 if proto.name in custom_open_params:
3334 rbody.append(' XGL_DEVICE handle;')
3335 for pidx in custom_open_params[proto.name]:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]3336 rbody.append(' %s local_%s;' % (proto.params[pidx].ty.replace('const ', '').strip('*'), proto.params[pidx].name))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3337 rbody.append(' handle = remap(pPacket->device);')
3338 elif create_view:
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]3339 rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').replace('const ', '')))
3340 rbody.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(%s));' % (proto.params[1].ty.strip('*').replace('const ', '')))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3341 if 'CreateComputePipeline' == proto.name:
3342 rbody.append(' createInfo.cs.shader = remap(pPacket->pCreateInfo->cs.shader);')
Jon Ashburn03d0bcc2015-02-03 11:24:08 -0700[diff] [blame]3343 elif 'CreateBufferView' == proto.name:
3344 rbody.append(' createInfo.buffer = remap(pPacket->pCreateInfo->buffer);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3345 else:
3346 rbody.append(' createInfo.image = remap(pPacket->pCreateInfo->image);')
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]3347 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3348 elif create_func: # Declare local var to store created handle into
Tobin Ehlisbf967aa2015-01-15 17:53:54 -0700[diff] [blame]3349 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
Tobin Ehlis271e51d2015-01-20 13:50:59 -0700[diff] [blame]3350 if 'AllocDescriptorSets' == proto.name:
Jon Ashburn9c246bc2015-02-04 12:57:25 -0700[diff] [blame]3351 rbody.append(' %s local_%s[100];' % (proto.params[-2].ty.strip('*').replace('const ', ''), proto.params[-2].name))
3352 rbody.append(' XGL_DESCRIPTOR_SET_LAYOUT localDescSets[100];')
3353 rbody.append(' assert(pPacket->count <= 100);')
3354 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
3355 rbody.append(' {')
3356 rbody.append(' localDescSets[i] = remap(pPacket->%s[i]);' % (proto.params[-3].name))
3357 rbody.append(' }')
3358 elif proto.name == 'ClearDescriptorSets':
3359 rbody.append(' XGL_DESCRIPTOR_SET localDescSets[100];')
3360 rbody.append(' assert(pPacket->count <= 100);')
3361 rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3362 rbody.append(' {')
Jon Ashburn9c246bc2015-02-04 12:57:25 -0700[diff] [blame]3363 rbody.append(' localDescSets[i] = remap(pPacket->%s[i]);' % (proto.params[-1].name))
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3364 rbody.append(' }')
3365 elif proto.name in do_while_dict:
3366 rbody.append(' do {')
Jon Ashburnc5798822015-02-03 13:39:05 -0700[diff] [blame]3367 elif proto.name == 'EnumerateLayers':
3368 rbody.append(' char **bufptr = GLV_NEW_ARRAY(char *, pPacket->maxLayerCount);')
3369 rbody.append(' char **ptrLayers = (pPacket->pOutLayers == NULL) ? bufptr : (char **) pPacket->pOutLayers;')
3370 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
3371 rbody.append(' bufptr[i] = GLV_NEW_ARRAY(char, pPacket->maxStringSize);')
Jon Ashburn5cc46352015-02-12 12:37:46 -0700[diff] [blame]3372 elif proto.name == 'DestroyInstance':
3373 rbody.append(' xglDbgUnregisterMsgCallback(g_fpDbgMsgCallback);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3374 rr_string = ' '
3375 if ret_value:
3376 rr_string = ' replayResult = '
3377 rr_string += 'm_xglFuncs.real_xgl%s(' % proto.name
3378 for p in proto.params:
3379 # For last param of Create funcs, pass address of param
Tobin Ehlis271e51d2015-01-20 13:50:59 -0700[diff] [blame]3380 if create_func:
3381 if p.name == proto.params[-1].name:
3382 rr_string += '&local_%s, ' % p.name
3383 elif proto.name == 'AllocDescriptorSets' and p.name == proto.params[-2].name:
3384 rr_string += 'local_%s, ' % p.name
3385 else:
3386 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3387 else:
3388 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
3389 rr_string = '%s);' % rr_string[:-2]
Jon Ashburn9c246bc2015-02-04 12:57:25 -0700[diff] [blame]3390 if proto.name in custom_open_params:
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3391 rr_list = rr_string.split(', ')
3392 rr_list[0] = rr_list[0].replace('remap(pPacket->device)', 'handle')
3393 for pidx in custom_open_params[proto.name]:
3394 rr_list[pidx] = '&local_%s' % proto.params[pidx].name
3395 rr_string = ', '.join(rr_list)
3396 rr_string += ');'
3397 elif create_view:
3398 rr_list = rr_string.split(', ')
3399 rr_list[-2] = '&createInfo'
3400 rr_list[-1] = '&local_%s);' % proto.params[-1].name
3401 rr_string = ', '.join(rr_list)
3402 # this is a sneaky shortcut to use generic create code below to add_to_map
3403 create_func = True
Jon Ashburnc5798822015-02-03 13:39:05 -0700[diff] [blame]3404 elif proto.name == 'EnumerateLayers':
3405 rr_string = rr_string.replace('pPacket->pOutLayers', 'ptrLayers')
Jon Ashburn9c246bc2015-02-04 12:57:25 -0700[diff] [blame]3406 elif proto.name == 'ClearDescriptorSets':
3407 rr_string = rr_string.replace('pPacket->pDescriptorSets', 'localDescSets')
3408 elif proto.name == 'AllocDescriptorSets':
3409 rr_string = rr_string.replace('pPacket->pSetLayouts', 'localDescSets')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3410 rbody.append(rr_string)
3411 if 'DestroyDevice' in proto.name:
3412 rbody.append(' if (replayResult == XGL_SUCCESS)')
3413 rbody.append(' {')
Peter Lohrmannd2e84852015-02-27 15:35:15 -0800[diff] [blame]3414 rbody.append(' m_pCBDump = NULL;')
3415 rbody.append(' m_pDSDump = NULL;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3416 rbody.append(' rm_from_map(pPacket->device);')
3417 rbody.append(' m_display->m_initedXGL = false;')
3418 rbody.append(' }')
Jon Ashburnd07dfef2015-02-03 08:57:28 -0700[diff] [blame]3419 if 'DestroyInstance' in proto.name:
3420 rbody.append(' if (replayResult == XGL_SUCCESS)')
3421 rbody.append(' {')
Jon Ashburn6e9ca2b2015-02-03 09:17:12 -0700[diff] [blame]3422 rbody.append(' // TODO need to handle multiple instances and only clearing maps within an instance.')
3423 rbody.append(' // TODO this only works with a single instance used at any given time.')
3424 rbody.append(' clear_all_map_handles();')
Jon Ashburnd07dfef2015-02-03 08:57:28 -0700[diff] [blame]3425 rbody.append(' }')
Tobin Ehlis271e51d2015-01-20 13:50:59 -0700[diff] [blame]3426 elif 'AllocDescriptorSets' in proto.name:
3427 rbody.append(' if (replayResult == XGL_SUCCESS)')
3428 rbody.append(' {')
3429 rbody.append(' for (uint32_t i = 0; i < local_pCount; i++) {')
Tobin Ehlisf29cc372015-01-22 12:29:31 -0700[diff] [blame]3430 rbody.append(' add_to_map(&pPacket->%s[i], &local_%s[i]);' % (proto.params[-2].name, proto.params[-2].name))
Tobin Ehlis271e51d2015-01-20 13:50:59 -0700[diff] [blame]3431 rbody.append(' }')
3432 rbody.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3433 elif create_func: # save handle mapping if create successful
3434 rbody.append(' if (replayResult == XGL_SUCCESS)')
3435 rbody.append(' {')
3436 rbody.append(' add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))
3437 if 'AllocMemory' == proto.name:
3438 rbody.append(' add_entry_to_mapData(local_%s, pPacket->pAllocInfo->allocationSize);' % (proto.params[-1].name))
3439 rbody.append(' }')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3440 elif proto.name in do_while_dict:
3441 rbody[-1] = ' %s' % rbody[-1]
3442 rbody.append(' } while (%s);' % do_while_dict[proto.name])
Jon Ashburn0a576112015-02-23 11:07:30 -0700[diff] [blame]3443 rbody.append(' if (pPacket->result != XGL_NOT_READY || replayResult != XGL_SUCCESS)')
Jon Ashburnc5798822015-02-03 13:39:05 -0700[diff] [blame]3444 elif proto.name == 'EnumerateLayers':
3445 rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')
3446 rbody.append(' GLV_DELETE(bufptr[i]);')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3447 if ret_value:
3448 rbody.append(' CHECK_RETURN_VALUE(xgl%s);' % proto.name)
3449 if 'MsgCallback' in proto.name:
3450 rbody.pop()
3451 rbody.pop()
3452 rbody.pop()
3453 rbody.append(' // Just eating these calls as no way to restore dbg func ptr.')
3454 rbody.append(' break;')
3455 rbody.append(' }')
3456 rbody.append(' default:')
3457 rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')
3458 rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')
3459 rbody.append(' break;')
3460 rbody.append(' }')
3461 rbody.append(' return returnValue;')
3462 rbody.append('}')
3463 return "\n".join(rbody)
3464
3465class GlaveTraceHeader(Subcommand):
3466 def generate_header(self):
3467 header_txt = []
3468 header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
3469 header_txt.append('#include "glvtrace_xgl_packet_id.h"\n')
3470 header_txt.append('void AttachHooks();')
3471 header_txt.append('void DetachHooks();')
Ian Elliott5890a772015-02-27 11:10:59 -0700[diff] [blame]3472 header_txt.append('void InitTracer(void);\n')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3473 return "\n".join(header_txt)
3474
3475 def generate_body(self):
3476 body = [self._generate_trace_func_ptrs(),
3477 self._generate_trace_func_protos()]
3478
3479 return "\n".join(body)
3480
3481class GlaveTraceC(Subcommand):
3482 def generate_header(self):
3483 header_txt = []
3484 header_txt.append('#include "glv_platform.h"')
3485 header_txt.append('#include "glv_common.h"')
3486 header_txt.append('#include "glvtrace_xgl_xgl.h"')
3487 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
3488 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
3489 header_txt.append('#include "glv_interconnect.h"')
3490 header_txt.append('#include "glv_filelike.h"')
3491 header_txt.append('#ifdef WIN32')
3492 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
3493 header_txt.append('#endif')
3494 header_txt.append('#include "glv_trace_packet_utils.h"')
3495 header_txt.append('#include <stdio.h>\n')
3496 return "\n".join(header_txt)
3497
3498 def generate_body(self):
3499 body = [self._generate_func_ptr_assignments(),
3500 self._generate_attach_hooks(),
3501 self._generate_detach_hooks(),
Jon Ashburn15161e42014-12-16 18:37:04 -0700[diff] [blame]3502 self._generate_init_funcs(),
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3503 self._generate_helper_funcs(),
3504 self._generate_trace_funcs()]
3505
3506 return "\n".join(body)
3507
3508class GlavePacketID(Subcommand):
3509 def generate_header(self):
3510 header_txt = []
3511 header_txt.append('#pragma once\n')
3512 header_txt.append('#include "glv_trace_packet_utils.h"')
3513 header_txt.append('#include "glv_trace_packet_identifiers.h"')
3514 header_txt.append('#include "glv_interconnect.h"')
3515 header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
3516 header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
3517 header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
3518 header_txt.append('#include "xgl_enum_string_helper.h"')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3519 header_txt.append('#if defined(WIN32)')
3520 header_txt.append('#define snprintf _snprintf')
3521 header_txt.append('#endif')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3522 header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')
3523 header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\\n");\n')
3524 header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')
3525 header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')
3526 header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')
3527 header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);\n')
3528 header_txt.append('#define FINISH_TRACE_PACKET() \\')
3529 header_txt.append(' glv_finalize_trace_packet(pHeader); \\')
3530 header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')
3531 header_txt.append(' glv_delete_trace_packet(&pHeader);')
3532 return "\n".join(header_txt)
3533
3534 def generate_body(self):
3535 body = [self._generate_packet_id_enum(),
3536 self._generate_stringify_func(),
3537 self._generate_interp_func()]
3538
3539 return "\n".join(body)
3540
3541class GlaveCoreStructs(Subcommand):
3542 def generate_header(self):
3543 header_txt = []
3544 header_txt.append('#pragma once\n')
3545 header_txt.append('#include "xgl.h"')
3546 header_txt.append('#include "glv_trace_packet_utils.h"\n')
3547 return "\n".join(header_txt)
3548
3549 def generate_body(self):
3550 body = [self._generate_struct_util_funcs(),
3551 self._generate_interp_funcs()]
3552
3553 return "\n".join(body)
3554
3555class GlaveWsiHeader(Subcommand):
3556 def generate_header(self):
3557 header_txt = []
3558 header_txt.append('#pragma once\n')
3559 header_txt.append('#include "xgl.h"')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3560 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3561 header_txt.append('#include "xglWsiX11Ext.h"\n')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]3562 header_txt.append('#else')
3563 header_txt.append('#include "xglWsiWinExt.h"')
3564 header_txt.append('#endif')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3565 header_txt.append('void AttachHooks_xglwsix11ext();')
3566 header_txt.append('void DetachHooks_xglwsix11ext();')
3567 return "\n".join(header_txt)
3568
3569 def generate_body(self):
3570 body = [self._generate_trace_func_ptrs_ext(),
3571 self._generate_trace_func_protos_ext()]
3572
3573 return "\n".join(body)
3574
3575class GlaveWsiC(Subcommand):
3576 def generate_header(self):
3577 header_txt = []
3578 header_txt.append('#include "glv_platform.h"')
3579 header_txt.append('#include "glv_common.h"')
3580 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
3581 header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
3582 header_txt.append('#include "glvtrace_xgl_packet_id.h"')
3583 header_txt.append('#ifdef WIN32')
3584 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
3585 header_txt.append('#endif')
3586 return "\n".join(header_txt)
3587
3588 def generate_body(self):
3589 body = [self._generate_func_ptr_assignments_ext(),
3590 self._generate_attach_hooks_ext(),
3591 self._generate_detach_hooks_ext(),
3592 self._generate_trace_funcs_ext()]
3593
3594 return "\n".join(body)
3595
3596class GlaveWsiStructs(Subcommand):
3597 def generate_header(self):
3598 header_txt = []
3599 header_txt.append('#pragma once\n')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3600 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3601 header_txt.append('#include "xglWsiX11Ext.h"')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]3602 header_txt.append('#else')
3603 header_txt.append('#include "xglWsiWinExt.h"')
3604 header_txt.append('#endif')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3605 header_txt.append('#include "glv_trace_packet_utils.h"\n')
3606 return "\n".join(header_txt)
3607
3608 def generate_body(self):
3609 body = [self._generate_interp_funcs_ext()]
3610
3611 return "\n".join(body)
3612
3613class GlaveDbgHeader(Subcommand):
3614 def generate_header(self):
3615 header_txt = []
3616 header_txt.append('#pragma once\n')
3617 header_txt.append('#include "xgl.h"')
3618 header_txt.append('#include "xglDbg.h"\n')
3619 header_txt.append('void AttachHooks_xgldbg();')
3620 header_txt.append('void DetachHooks_xgldbg();')
3621 return "\n".join(header_txt)
3622
3623 def generate_body(self):
3624 body = [self._generate_trace_func_ptrs_ext('Dbg'),
3625 self._generate_trace_func_protos_ext('Dbg')]
3626
3627 return "\n".join(body)
3628
3629class GlaveDbgC(Subcommand):
3630 def generate_header(self):
3631 header_txt = []
3632 header_txt.append('#include "glv_platform.h"')
3633 header_txt.append('#include "glv_common.h"')
3634 header_txt.append('#include "glvtrace_xgl_xgl.h"')
3635 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
3636 header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
3637 header_txt.append('#include "glvtrace_xgl_packet_id.h"')
3638 header_txt.append('#ifdef WIN32')
3639 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
3640 header_txt.append('#endif')
3641 return "\n".join(header_txt)
3642
3643 def generate_body(self):
3644 body = [self._generate_func_ptr_assignments_ext('Dbg'),
3645 self._generate_attach_hooks_ext('Dbg'),
3646 self._generate_detach_hooks_ext('Dbg'),
3647 self._generate_trace_funcs_ext('Dbg')]
3648
3649 return "\n".join(body)
3650
3651class GlaveDbgStructs(Subcommand):
3652 def generate_header(self):
3653 header_txt = []
3654 header_txt.append('#pragma once\n')
3655 header_txt.append('#include "xglDbg.h"')
3656 header_txt.append('#include "glv_trace_packet_utils.h"\n')
3657 return "\n".join(header_txt)
3658
3659 def generate_body(self):
3660 body = [self._generate_interp_funcs_ext('Dbg')]
3661
3662 return "\n".join(body)
3663
3664class GlaveReplayHeader(Subcommand):
3665 def generate_header(self):
3666 header_txt = []
3667 header_txt.append('#pragma once\n')
3668 header_txt.append('#include <set>')
3669 header_txt.append('#include <map>')
3670 header_txt.append('#include <vector>')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]3671 header_txt.append('#include <string>')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3672 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3673 header_txt.append('#include <xcb/xcb.h>\n')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]3674 header_txt.append('#endif')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3675 header_txt.append('#include "glvreplay_window.h"')
3676 header_txt.append('#include "glvreplay_factory.h"')
3677 header_txt.append('#include "glv_trace_packet_identifiers.h"\n')
3678 header_txt.append('#include "xgl.h"')
3679 header_txt.append('#include "xglDbg.h"')
Piers Daniell188f8202015-02-24 13:58:47 -0700[diff] [blame]3680 header_txt.append('#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3681 header_txt.append('#include "xglWsiX11Ext.h"')
David Pinedo53509302015-02-10 15:02:08 -0700[diff] [blame]3682 header_txt.append('#else')
3683 header_txt.append('#include "xglWsiWinExt.h"')
3684 header_txt.append('#endif')
Jon Ashburn8ef49b12015-02-17 13:28:11 -0700[diff] [blame]3685 header_txt.append('#include "draw_state.h"')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3686 return "\n".join(header_txt)
3687
3688 def generate_body(self):
3689 body = [self._generate_replay_class_decls(),
3690 self._generate_replay_func_ptrs(),
3691 self._generate_replay_class()]
3692
3693 return "\n".join(body)
3694
3695class GlaveReplayC(Subcommand):
3696 def generate_header(self):
3697 header_txt = []
3698 header_txt.append('#include "glvreplay_xgl_replay.h"\n')
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]3699 header_txt.append('#include "glvreplay_xgl.h"\n')
Tony Barbour5d5bc992015-02-02 13:21:18 -0700[diff] [blame]3700 header_txt.append('#include "glvreplay_xgl_write_ppm.h"\n')
3701 header_txt.append('#include "glvreplay_main.h"\n')
3702 header_txt.append('#include <algorithm>')
Jon Ashburn19cedb42015-02-13 11:25:53 -0700[diff] [blame]3703 header_txt.append('#include <queue>')
Ian Elliotteca16382015-02-18 15:35:00 -0700[diff] [blame]3704 header_txt.append('glvreplay_settings *g_pReplaySettings;')
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3705 header_txt.append('extern "C" {')
3706 header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
3707 header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
3708 header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
3709 header_txt.append('#include "glvtrace_xgl_packet_id.h"')
3710 header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')
3711 header_txt.append('#define APP_NAME "glvreplay_xgl"')
3712 header_txt.append('#define IDI_ICON 101\n')
3713 header_txt.append('static const char* g_extensions[] =')
3714 header_txt.append('{')
3715 header_txt.append(' "XGL_WSI_WINDOWS",')
3716 header_txt.append(' "XGL_TIMER_QUEUE",')
3717 header_txt.append(' "XGL_GPU_TIMESTAMP_CALIBRATION",')
3718 header_txt.append(' "XGL_DMA_QUEUE",')
3719 header_txt.append(' "XGL_COMMAND_BUFFER_CONTROL_FLOW",')
3720 header_txt.append(' "XGL_COPY_OCCLUSION_QUERY_DATA",')
3721 header_txt.append(' "XGL_ADVANCED_MULTISAMPLING",')
3722 header_txt.append(' "XGL_BORDER_COLOR_PALETTE"')
3723 header_txt.append('};')
3724 return "\n".join(header_txt)
3725
3726 def generate_body(self):
3727 body = [self._generate_replay_display_init_xgl(),
3728 self._generate_replay_display_init(),
3729 self._generate_replay_display_structors(),
3730 self._generate_replay_display_window(),
3731 self._generate_replay_structors(),
3732 self._generate_replay_init(),
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3733 self._generate_replay_errors(),
Jon Ashburnce66ab82014-12-18 17:03:34 -0700[diff] [blame]3734 self._generate_replay_validation_funcs(),
Tobin Ehlis5d57bca2014-12-15 18:14:12 -0700[diff] [blame]3735 self._generate_replay_init_funcs(),
3736 self._generate_replay()]
3737
3738 return "\n".join(body)
3739
3740def main():
3741 subcommands = {
3742 "glave-trace-h" : GlaveTraceHeader,
3743 "glave-trace-c" : GlaveTraceC,
3744 "glave-packet-id" : GlavePacketID,
3745 "glave-core-structs" : GlaveCoreStructs,
3746 "glave-wsi-trace-h" : GlaveWsiHeader,
3747 "glave-wsi-trace-c" : GlaveWsiC,
3748 "glave-wsi-trace-structs" : GlaveWsiStructs,
3749 "glave-dbg-trace-h" : GlaveDbgHeader,
3750 "glave-dbg-trace-c" : GlaveDbgC,
3751 "glave-dbg-trace-structs" : GlaveDbgStructs,
3752 "glave-replay-h" : GlaveReplayHeader,
3753 "glave-replay-c" : GlaveReplayC,
3754 }
3755
3756 if len(sys.argv) < 2 or sys.argv[1] not in subcommands:
3757 print("Usage: %s <subcommand> [options]" % sys.argv[0])
3758 print
3759 print("Available sucommands are: %s" % " ".join(subcommands))
3760 exit(1)
3761
3762 subcmd = subcommands[sys.argv[1]](sys.argv[2:])
3763 subcmd.run()
3764
3765if __name__ == "__main__":
3766 main()