Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 628a8a58ce2a33ffb5f2b83b5d54de7be7b9c83a / . / glave-generate.py
blob: 6b2876275a9ebebcb61baaa90a9cd8cc1bfa88f5 [file] [log] [blame]
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1#!/usr/bin/env python3
2#
3# XGL
4#
5# Copyright (C) 2014 LunarG, Inc.
6#
7# Permission is hereby granted, free of charge, to any person obtaining a
8# copy of this software and associated documentation files (the "Software"),
9# to deal in the Software without restriction, including without limitation
10# the rights to use, copy, modify, merge, publish, distribute, sublicense,
11# and/or sell copies of the Software, and to permit persons to whom the
12# Software is furnished to do so, subject to the following conditions:
13#
14# The above copyright notice and this permission notice shall be included
15# in all copies or substantial portions of the Software.
16#
17# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23# DEALINGS IN THE SOFTWARE.
24#
25# Authors:
26# Chia-I Wu <olv@lunarg.com>
27
28import sys
29
30import xgl
31
32class Subcommand(object):
33 def __init__(self, argv):
34 self.argv = argv
Chia-I Wuec30dcb2015-01-01 08:46:31 +0800[diff] [blame]35 self.headers = xgl.headers
36 self.protos = xgl.protos
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]37
38 def run(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]39 print(self.generate())
40
41 def generate(self):
42 copyright = self.generate_copyright()
43 header = self.generate_header()
44 body = self.generate_body()
45 footer = self.generate_footer()
46
47 contents = []
48 if copyright:
49 contents.append(copyright)
50 if header:
51 contents.append(header)
52 if body:
53 contents.append(body)
54 if footer:
55 contents.append(footer)
56
57 return "\n\n".join(contents)
58
59 def generate_copyright(self):
60 return """/* THIS FILE IS GENERATED. DO NOT EDIT. */
61
62/*
63 * XGL
64 *
65 * Copyright (C) 2014 LunarG, Inc.
66 *
67 * Permission is hereby granted, free of charge, to any person obtaining a
68 * copy of this software and associated documentation files (the "Software"),
69 * to deal in the Software without restriction, including without limitation
70 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
71 * and/or sell copies of the Software, and to permit persons to whom the
72 * Software is furnished to do so, subject to the following conditions:
73 *
74 * The above copyright notice and this permission notice shall be included
75 * in all copies or substantial portions of the Software.
76 *
77 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
78 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
79 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
80 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
81 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
82 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
83 * DEALINGS IN THE SOFTWARE.
84 */"""
85
86 def generate_header(self):
87 return "\n".join(["#include <" + h + ">" for h in self.headers])
88
89 def generate_body(self):
90 pass
91
92 def generate_footer(self):
93 pass
94
95 # Return set of printf '%' qualifier and input to that qualifier
96 def _get_printf_params(self, xgl_type, name, output_param):
97 # TODO : Need ENUM and STRUCT checks here
98 if "_TYPE" in xgl_type: # TODO : This should be generic ENUM check
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]99 return ("%s", "string_%s(%s)" % (xgl_type.replace('const ', '').strip('*'), name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]100 if "char*" == xgl_type:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]101 return ("%s", name)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]102 if "uint64_t" in xgl_type:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]103 if '*' in xgl_type:
104 return ("%lu", "*%s" % name)
105 return ("%lu", name)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]106 if "size_t" in xgl_type:
Chia-I Wu54ed0792014-12-27 14:14:50 +0800[diff] [blame]107 if '*' in xgl_type:
108 return ("%zu", "*%s" % name)
109 return ("%zu", name)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]110 if "float" in xgl_type:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]111 if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
112 return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
113 return ("%f", name)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]114 if "bool" in xgl_type or 'xcb_randr_crtc_t' in xgl_type:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]115 return ("%u", name)
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]116 if True in [t in xgl_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]117 if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
118 return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
119 if '*' in xgl_type:
120 return ("%i", "*(%s)" % name)
121 return ("%i", name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]122 if output_param:
123 return ("%p", "(void*)*%s" % name)
124 return ("%p", "(void*)(%s)" % name)
125
126 def _generate_trace_func_ptrs(self):
127 func_ptrs = []
128 func_ptrs.append('// Pointers to real functions and declarations of hooked functions')
129 func_ptrs.append('#ifdef WIN32')
130 func_ptrs.append('extern INIT_ONCE gInitOnce;')
131 for proto in self.protos:
132 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:
133 func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))
134
135 func_ptrs.append('\n#elif defined(PLATFORM_LINUX)')
136 func_ptrs.append('extern pthread_once_t gInitOnce;')
137 for proto in self.protos:
138 if True not in [skip_str in proto.name for skip_str in ['Dbg', 'Wsi']]:
139 func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))
140
141 func_ptrs.append('#endif\n')
142 return "\n".join(func_ptrs)
143
144 def _generate_trace_func_ptrs_ext(self, func_class='Wsi'):
145 func_ptrs = []
146 func_ptrs.append('#ifdef WIN32')
147 for proto in self.protos:
148 if func_class in proto.name:
149 func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))
150
151 func_ptrs.append('#elif defined(__linux__)')
152 for proto in self.protos:
153 if func_class in proto.name:
154 func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))
155
156 func_ptrs.append('#endif\n')
157 return "\n".join(func_ptrs)
158
159 def _generate_trace_func_protos(self):
160 func_protos = []
161 func_protos.append('// Hooked function prototypes\n')
162 for proto in self.protos:
163 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
164 func_protos.append('%s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))
165
166 return "\n".join(func_protos)
167
168 def _generate_trace_func_protos_ext(self, func_class='Wsi'):
169 func_protos = []
170 func_protos.append('// Hooked function prototypes\n')
171 for proto in self.protos:
172 if func_class in proto.name:
173 func_protos.append('%s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))
174
175 return "\n".join(func_protos)
176
177
178 def _generate_func_ptr_assignments(self):
179 func_ptr_assign = []
180 for proto in self.protos:
181 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
182 func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
183 for p in proto.params:
184 if 'color' == p.name:
185 func_ptr_assign.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))
186 else:
187 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
188 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
189 func_ptr_assign.append('static BOOL isHooked = FALSE;\n')
190 return "\n".join(func_ptr_assign)
191
192 def _generate_func_ptr_assignments_ext(self, func_class='Wsi'):
193 func_ptr_assign = []
194 for proto in self.protos:
195 if func_class in proto.name:
196 func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))
197 for p in proto.params:
198 func_ptr_assign.append(' %s %s,' % (p.ty, p.name))
199 func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))
200 return "\n".join(func_ptr_assign)
201
202 def _generate_attach_hooks(self):
203 hooks_txt = []
204 hooks_txt.append('void AttachHooks()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)')
205 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]206 # TODO : Verify if CreateInstance is appropriate to key off of here
207 hooks_txt.append(' if (real_xglCreateInstance != NULL)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]208 hooks_txt.append(' {\n isHooked = TRUE;')
209 hook_operator = '='
210 for proto in self.protos:
211 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
212 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
213 hook_operator = '&='
214 hooks_txt.append(' }\n')
215 hooks_txt.append(' if (!hookSuccess)\n {')
216 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
217 hooks_txt.append(' Mhook_EndMultiOperation();\n')
218 hooks_txt.append('#elif defined(__linux__)')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]219 hooks_txt.append(' if (real_xglCreateInstance == xglCreateInstance)')
220 hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateInstance,"xglCreateInstance");')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]221 hooks_txt.append(' isHooked = TRUE;')
222 for proto in self.protos:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]223 if 'Dbg' not in proto.name and 'Wsi' not in proto.name and 'CreateInstance' not in proto.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]224 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
225 hooks_txt.append(' if (!hookSuccess)\n {')
226 hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')
227 hooks_txt.append('#endif\n}\n')
228 return "\n".join(hooks_txt)
229
230 def _generate_attach_hooks_ext(self, func_class='Wsi'):
231 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
232 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
233 hooks_txt = []
234 hooks_txt.append('void AttachHooks%s()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)' % func_ext_dict[func_class])
235 hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')
236 hooks_txt.append(' if (real_xgl%s != NULL)' % first_proto_dict[func_class])
237 hooks_txt.append(' {')
238 hook_operator = '='
239 for proto in self.protos:
240 if func_class in proto.name:
241 hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))
242 hook_operator = '&='
243 hooks_txt.append(' }\n')
244 hooks_txt.append(' if (!hookSuccess)\n {')
245 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
246 hooks_txt.append(' Mhook_EndMultiOperation();\n')
247 hooks_txt.append('#elif defined(__linux__)')
248 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]))
249 for proto in self.protos:
250 if func_class in proto.name and first_proto_dict[func_class] not in proto.name:
251 hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))
252 hooks_txt.append(' if (!hookSuccess)\n {')
253 hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)
254 hooks_txt.append('#endif\n}\n')
255 return "\n".join(hooks_txt)
256
257 def _generate_detach_hooks(self):
258 hooks_txt = []
259 hooks_txt.append('void DetachHooks()\n{\n#ifdef __linux__\n return;\n#elif defined(WIN32)')
260 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xglGetGpuInfo != NULL)\n {')
261 hook_operator = '='
262 for proto in self.protos:
263 if 'Dbg' not in proto.name and 'Wsi' not in proto.name:
264 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
265 hook_operator = '&='
266 hooks_txt.append(' }\n isHooked = FALSE;')
267 hooks_txt.append(' if (!unhookSuccess)\n {')
268 hooks_txt.append(' glv_LogError("Failed to unhook XGL.");\n }')
269 hooks_txt.append('#endif\n}')
270 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')
271 return "\n".join(hooks_txt)
272
273 def _generate_detach_hooks_ext(self, func_class='Wsi'):
274 func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}
275 first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}
276 hooks_txt = []
277 hooks_txt.append('void DetachHooks%s()\n{\n#ifdef WIN32' % func_ext_dict[func_class])
278 hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xgl%s != NULL)\n {' % first_proto_dict[func_class])
279 hook_operator = '='
280 for proto in self.protos:
281 if func_class in proto.name:
282 hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))
283 hook_operator = '&='
284 hooks_txt.append(' }')
285 hooks_txt.append(' if (!unhookSuccess)\n {')
286 hooks_txt.append(' glv_LogError("Failed to unhook XGL ext %s.");\n }' % func_class)
287 hooks_txt.append('#elif defined(__linux__)\n return;\n#endif\n}\n')
288 return "\n".join(hooks_txt)
289
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]290 def _generate_init_funcs(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]291 init_tracer = []
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]292 init_tracer.append('void send_xgl_api_version_packet()\n{')
293 init_tracer.append(' struct_xglApiVersion* pPacket;')
294 init_tracer.append(' glv_trace_packet_header* pHeader;')
295 init_tracer.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_xglApiVersion, sizeof(struct_xglApiVersion), 0);')
296 init_tracer.append(' pPacket = interpret_body_as_xglApiVersion(pHeader, FALSE);')
297 init_tracer.append(' pPacket->version = XGL_API_VERSION;')
298 init_tracer.append(' FINISH_TRACE_PACKET();\n}\n')
299
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]300 init_tracer.append('void InitTracer()\n{')
Jon Ashburn0fed6752015-01-09 17:36:10 -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";')
304 init_tracer.append(' gMessageStream = glv_MessageStream_create(FALSE, ipAddr, GLV_BASE_PORT + GLV_TID_XGL);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]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 Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]307 init_tracer.append(' glv_tracelog_set_tracer_id(GLV_TID_XGL);')
308 init_tracer.append(' send_xgl_api_version_packet();\n}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]309 return "\n".join(init_tracer)
310
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]311 def _gen_unmap_memory(self):
312 um_body = []
313 um_body.append('GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglUnmapMemory(')
314 um_body.append(' XGL_GPU_MEMORY mem)')
315 um_body.append('{')
316 um_body.append(' glv_trace_packet_header* pHeader;')
317 um_body.append(' XGL_RESULT result;')
318 um_body.append(' struct_xglUnmapMemory* pPacket;')
319 um_body.append(' XGLAllocInfo *entry;')
320 um_body.append(' SEND_ENTRYPOINT_PARAMS("xglUnmapMemory(mem %p)\\n", mem);')
321 um_body.append(' // insert into packet the data that was written by CPU between the xglMapMemory call and here')
322 um_body.append(' // Note must do this prior to the real xglUnMap() or else may get a FAULT')
323 um_body.append(' entry = find_mem_info_entry(mem);')
324 um_body.append(' CREATE_TRACE_PACKET(xglUnmapMemory, (entry) ? entry->size : 0);')
325 um_body.append(' pPacket = interpret_body_as_xglUnmapMemory(pHeader);')
326 um_body.append(' if (entry)')
327 um_body.append(' {')
328 um_body.append(' assert(entry->handle == mem);')
329 um_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pData), entry->size, entry->pData);')
330 um_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));')
331 um_body.append(' entry->pData = NULL;')
332 um_body.append(' }')
333 um_body.append(' result = real_xglUnmapMemory(mem);')
334 um_body.append(' pPacket->mem = mem;')
335 um_body.append(' pPacket->result = result;')
336 um_body.append(' FINISH_TRACE_PACKET();')
337 um_body.append(' return result;')
338 um_body.append('}\n')
339 return "\n".join(um_body)
340
341#EL == EnumerateLayers
342#I think this another case where you have to make the real call prior to CREATE_TRACE_PACKET(). SInce you
343#don't know how many layers will be returned or how big the strings will be. Alternatively, could be
344#on the safe side of CREATE_TRACE_PACKET with maxStringSize*maxLayerCount.
345#EL also needs a loop where add a trace buffer for each layer, depending on how you CREATE_TRACE_PACKET.
346
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]347# TODO : Tracing needs special checks in CreateInstance now
348# Need to call glv_platform_thread_once() and do (isHooked == FALSE) check
349# See example code below from old InitAndEnumerateGpus
350#GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglInitAndEnumerateGpus(
351# const XGL_APPLICATION_INFO* pAppInfo,
352# const XGL_ALLOC_CALLBACKS* pAllocCb,
353# XGL_UINT maxGpus,
354# XGL_UINT* pGpuCount,
355# XGL_PHYSICAL_GPU* pGpus)
356#{
357# glv_trace_packet_header* pHeader;
358# XGL_RESULT result;
359# uint64_t startTime;
360# struct_xglInitAndEnumerateGpus* pPacket;
361#
362# glv_platform_thread_once(&gInitOnce, InitTracer);
363# SEND_ENTRYPOINT_ID(xglInitAndEnumerateGpus);
364# if (real_xglInitAndEnumerateGpus == xglInitAndEnumerateGpus)
365# {
366# glv_platform_get_next_lib_sym((void **) &real_xglInitAndEnumerateGpus,"xglInitAndEnumerateGpus");
367# }
368# startTime = glv_get_time();
369# result = real_xglInitAndEnumerateGpus(pAppInfo, pAllocCb, maxGpus, pGpuCount, pGpus);
370#
371# // since we do not know how many gpus will be found must create trace packet after calling xglInit
372# CREATE_TRACE_PACKET(xglInitAndEnumerateGpus, calc_size_XGL_APPLICATION_INFO(pAppInfo) + ((pAllocCb == NULL) ? 0 :sizeof(XGL_ALLOC_CALLBACKS))
373# + sizeof(XGL_UINT) + ((pGpus && pGpuCount) ? *pGpuCount * sizeof(XGL_PHYSICAL_GPU) : 0));
374# pHeader->entrypoint_begin_time = startTime;
375# if (isHooked == FALSE) {
376# AttachHooks();
377# AttachHooks_xgldbg();
378# AttachHooks_xglwsix11ext();
379# }
380# pPacket = interpret_body_as_xglInitAndEnumerateGpus(pHeader);
381# add_XGL_APPLICATION_INFO_to_packet(pHeader, (XGL_APPLICATION_INFO**)&(pPacket->pAppInfo), pAppInfo);
382# if (pAllocCb) {
383# glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocCb), sizeof(XGL_ALLOC_CALLBACKS), pAllocCb);
384# glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocCb));
385# }
386# glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpuCount), sizeof(XGL_UINT), pGpuCount);
387# glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pGpuCount));
388# if (pGpuCount && pGpus)
389# {
390# glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), sizeof(XGL_PHYSICAL_GPU) * *pGpuCount, pGpus);
391# glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pGpus));
392# }
393# pPacket->maxGpus = maxGpus;
394# pPacket->result = result;
395# FINISH_TRACE_PACKET();
396# return result;
397#}
398
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]399 def _generate_trace_funcs(self):
400 func_body = []
401 for proto in self.protos:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]402 if 'UnmapMemory' == proto.name:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]403 func_body.append(self._gen_unmap_memory())
404 elif 'Dbg' not in proto.name and 'Wsi' not in proto.name:
405 packet_update_txt = ''
406 return_txt = ''
407 packet_size = ''
408 in_data_size = False # flag when we need to capture local input size variable for in/out size
409 buff_ptr_indices = []
410 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
411 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL
412 if 'color' == p.name:
413 func_body.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))
414 else:
415 func_body.append(' %s %s,' % (p.ty, p.name))
416 if '*' in p.ty and 'pSysMem' != p.name and 'pReserved' != p.name:
417 if 'pData' == p.name:
418 if 'dataSize' == proto.params[proto.params.index(p)-1].name:
419 packet_size += 'dataSize + '
420 elif 'counterCount' == proto.params[proto.params.index(p)-1].name:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]421 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]422 else:
423 packet_size += '((pDataSize != NULL && pData != NULL) ? *pDataSize : 0) + '
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]424 elif '**' in p.ty and 'void' in p.ty:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]425 packet_size += 'sizeof(void*) + '
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]426 elif 'void' in p.ty:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]427 packet_size += 'sizeof(%s) + ' % p.name
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]428 elif 'char' in p.ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]429 packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]430 elif 'DEVICE_CREATE_INFO' in p.ty:
431 packet_size += 'calc_size_XGL_DEVICE_CREATE_INFO(pCreateInfo) + '
432 elif 'pDataSize' in p.name:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]433 packet_size += '((pDataSize != NULL) ? sizeof(size_t) : 0) + '
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]434 in_data_size = True;
435 elif 'IMAGE_SUBRESOURCE' in p.ty and 'pSubresource' == p.name:
436 packet_size += '((pSubresource != NULL) ? sizeof(XGL_IMAGE_SUBRESOURCE) : 0) + '
437 else:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]438 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]439 buff_ptr_indices.append(proto.params.index(p))
440 else:
441 if 'color' == p.name:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]442 packet_update_txt += ' memcpy((void*)pPacket->color, color, 4 * sizeof(uint32_t));\n'
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]443 else:
444 packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)
445 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 Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]446 if '*' in p.ty:
447 packet_size += '*%s*' % p.name
448 else:
449 packet_size += '%s*' % p.name
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]450 if '' == packet_size:
451 packet_size = '0'
452 else:
453 packet_size = packet_size.strip(' + ')
454 func_body[-1] = func_body[-1].replace(',', ')')
455 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]456 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]457 func_body.append(' %s result;' % proto.ret)
458 return_txt = 'result = '
459 if in_data_size:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]460 func_body.append(' size_t dataSizeIn = (pDataSize == NULL) ? 0 : *pDataSize;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]461 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
462 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]463 # TODO : DescriptorUpdates and CreateSetLayout need to handle saving chain of structs
464 # TODO : EnumGpus needs to call function first and then update the returned count of GPUs
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]465 if 'EnumerateLayers' == proto.name:
466 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]467 func_body.append(' size_t totStringSize = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]468 func_body.append(' uint32_t i = 0;')
469 func_body.append(' for (i = 0; i < *pOutLayerCount; i++)')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]470 func_body.append(' totStringSize += (pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1: 0;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]471 func_body.append(' CREATE_TRACE_PACKET(xgl%s, totStringSize + sizeof(size_t));' % (proto.name))
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]472 elif 'AllocDescriptorSets' == proto.name:
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]473 # TODO : Anytime we call the function first, need to add custom code for correctly tracking API call time
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]474 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
475 func_body.append(' size_t customSize = (*pCount <= 0) ? (sizeof(XGL_DESCRIPTOR_SET)) : (*pCount * sizeof(XGL_DESCRIPTOR_SET));')
476 func_body.append(' CREATE_TRACE_PACKET(xglAllocDescriptorSets, sizeof(XGL_DESCRIPTOR_SET_LAYOUT) + customSize + sizeof(uint32_t));')
477 elif proto.name in ['CreateShader', 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'CreateGraphicsPipeline', 'CreateComputePipeline']:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]478 func_body.append(' size_t customSize;')
479 if 'CreateShader' == proto.name:
480 func_body.append(' customSize = (pCreateInfo != NULL) ? pCreateInfo->codeSize : 0;')
481 func_body.append(' CREATE_TRACE_PACKET(xglCreateShader, sizeof(XGL_SHADER_CREATE_INFO) + sizeof(XGL_SHADER) + customSize);')
482 elif 'CreateGraphicsPipeline' == proto.name:
483 func_body.append(' customSize = calculate_pipeline_state_size(pCreateInfo->pNext);')
484 func_body.append(' CREATE_TRACE_PACKET(xglCreateGraphicsPipeline, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + customSize);')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]485 elif 'CreateFramebuffer' == proto.name:
486 func_body.append(' int dsSize = (pCreateInfo != NULL && pCreateInfo->pDepthStencilAttachment != NULL) ? sizeof(XGL_DEPTH_STENCIL_BIND_INFO) : 0;')
487 func_body.append(' int colorCount = (pCreateInfo != NULL && pCreateInfo->pColorAttachments != NULL) ? pCreateInfo->colorAttachmentCount : 0;')
488 func_body.append(' customSize = colorCount * sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) + dsSize;')
489 func_body.append(' CREATE_TRACE_PACKET(xglCreateFramebuffer, sizeof(XGL_FRAMEBUFFER_CREATE_INFO) + sizeof(XGL_FRAMEBUFFER) + customSize);')
490 elif 'CreateRenderPass' == proto.name:
491# HACK ALERT, TODO this API currently has insufficient parameters to determine the count of the colorLoadOps, colorStoreOps, in the CREATE_INFO struct
492# assume number of colorAttachments == 1 for now rather than tracing code keeping a list of framebuffer objects with colorAttachmentCounts
493 func_body.append(' int colorCount = (pCreateInfo != NULL && pCreateInfo->pColorLoadOps != NULL && pCreateInfo->pColorStoreOps != NULL && pCreateInfo->pColorLoadClearValues != NULL) ? 1 : 0; //TODO fixme')
494 func_body.append(' customSize = colorCount * (sizeof(XGL_ATTACHMENT_LOAD_OP) + sizeof(XGL_ATTACHMENT_STORE_OP) + sizeof(XGL_CLEAR_COLOR));')
495 func_body.append(' CREATE_TRACE_PACKET(xglCreateRenderPass, sizeof(XGL_RENDER_PASS_CREATE_INFO) + sizeof(XGL_RENDER_PASS) + customSize);')
496 elif 'BeginCommandBuffer' == proto.name:
497 func_body.append(' customSize = calculate_begin_cmdbuf_size(pBeginInfo->pNext);')
498 func_body.append(' CREATE_TRACE_PACKET(xglBeginCommandBuffer, sizeof(XGL_CMD_BUFFER_BEGIN_INFO) + customSize);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]499 else: #'CreateComputePipeline'
500 func_body.append(' customSize = calculate_pipeline_state_size(pCreateInfo->pNext);')
501 func_body.append(' CREATE_TRACE_PACKET(xglCreateComputePipeline, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + customSize + calculate_pipeline_shader_size(&pCreateInfo->cs));')
502 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
503 else:
504 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))
505 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
506 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
507 func_body.append(packet_update_txt.strip('\n'))
508 if 'MapMemory' == proto.name: # Custom code for MapMem case
509 func_body.append(' if (ppData != NULL)')
510 func_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]511 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppData), sizeof(void*), *ppData);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]512 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));')
513 func_body.append(' add_data_to_mem_info(mem, *ppData);')
514 func_body.append(' }')
515 func_body.append(' pPacket->result = result;')
516 func_body.append(' FINISH_TRACE_PACKET();')
517 elif 'EnumerateLayers' == proto.name: #custom code for EnumerateLayers case
518 func_body.append(' pPacket->gpu = gpu;')
519 func_body.append(' pPacket->maxLayerCount = maxLayerCount;')
520 func_body.append(' pPacket->maxStringSize = maxStringSize;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]521 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayerCount), sizeof(size_t), pOutLayerCount);')
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]522 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayerCount));')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]523 func_body.append(' for (i = 0; i < *pOutLayerCount; i++) {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]524 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayers[i]), ((pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1 : 0), pOutLayers[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]525 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayers[i]));')
526 func_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]527
528 func_body.append(' pPacket->pReserved = pReserved;')
529 func_body.append(' pPacket->result = result;')
530 func_body.append(' FINISH_TRACE_PACKET();')
531 else:
532 # TODO : Clean this up. Too much custom code and branching.
533 for idx in buff_ptr_indices:
534 if 'DEVICE_CREATE_INFO' in proto.params[idx].ty:
535 func_body.append(' add_XGL_DEVICE_CREATE_INFO_to_packet(pHeader, (XGL_DEVICE_CREATE_INFO**) &(pPacket->pCreateInfo), pCreateInfo);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]536 elif 'char' in proto.params[idx].ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]537 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), ((%s != NULL) ? strlen(%s) + 1 : 0), %s);' % (proto.params[idx].name, proto.params[idx].name, proto.params[idx].name, proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]538 elif 'Count' in proto.params[idx-1].name and 'queryCount' != proto.params[idx-1].name:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]539 deref = ''
540 if '*' in proto.params[idx-1].ty:
541 deref = '*'
542 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 Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]543 elif 'dataSize' == proto.params[idx].name:
544 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSize, %s);' % (proto.params[idx].name, proto.params[idx].name))
545 elif 'pDataSize' == proto.params[idx].name:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]546 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(size_t), &dataSizeIn);' % (proto.params[idx].name))
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]547 elif 'pDescriptorSets' == proto.params[idx].name and 'AllocDescriptorSets' == proto.name:
548 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]549 elif 'pData' == proto.params[idx].name:
550 if 'dataSize' == proto.params[idx-1].name:
551 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSize, %s);' % (proto.params[idx].name, proto.params[idx].name))
552 elif in_data_size:
553 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSizeIn, %s);' % (proto.params[idx].name, proto.params[idx].name))
554 else:
555 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))
556 else:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]557 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, proto.params[idx].ty.strip('*').replace('const ', ''), proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]558 # Some custom add_* and finalize_* function calls for Create* API calls
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]559 if proto.name in ['CreateShader', 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'CreateGraphicsPipeline', 'CreateComputePipeline']:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]560 if 'CreateShader' == proto.name:
561 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), customSize, pCreateInfo->pCode);')
562 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]563 elif 'CreateFramebuffer' == proto.name:
564 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments), colorCount * sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO), pCreateInfo->pColorAttachments);')
565 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment), dsSize, pCreateInfo->pDepthStencilAttachment);')
566 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments));')
567 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment));')
568 elif 'CreateRenderPass' == proto.name:
569 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps), colorCount * sizeof(XGL_ATTACHMENT_LOAD_OP), pCreateInfo->pColorLoadOps);')
570 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps), colorCount * sizeof(XGL_ATTACHMENT_STORE_OP), pCreateInfo->pColorStoreOps);')
571 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues), colorCount * sizeof(XGL_CLEAR_COLOR), pCreateInfo->pColorLoadClearValues);')
572 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps));')
573 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps));')
574 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues));')
575 elif 'BeginCommandBuffer' == proto.name:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]576 func_body.append(' add_begin_cmdbuf_to_trace_packet(pHeader, (void**)&pPacket->pBeginInfo->pNext, pBeginInfo->pNext);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]577 elif 'CreateGraphicsPipeline' == proto.name:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]578 func_body.append(' add_pipeline_state_to_trace_packet(pHeader, (void**)&pPacket->pCreateInfo->pNext, pCreateInfo->pNext);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]579 else:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]580 func_body.append(' add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]581 func_body.append(' add_pipeline_shader_to_trace_packet(pHeader, (XGL_PIPELINE_SHADER*)&pPacket->pCreateInfo->cs, &pCreateInfo->cs);')
582 func_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->pCreateInfo->cs);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]583 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]584 func_body.append(' pPacket->result = result;')
585 for idx in buff_ptr_indices:
586 if 'DEVICE_CREATE_INFO' not in proto.params[idx].ty:
587 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))
588 func_body.append(' FINISH_TRACE_PACKET();')
589 if 'AllocMemory' in proto.name:
590 func_body.append(' add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);')
591 elif 'FreeMemory' in proto.name:
592 func_body.append(' rm_handle_from_mem_info(mem);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]593 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]594 func_body.append(' return result;')
595 func_body.append('}\n')
596 return "\n".join(func_body)
597
598 def _generate_trace_funcs_ext(self, func_class='Wsi'):
599 thread_once_funcs = ['DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback', 'DbgSetGlobalOption']
600 func_body = []
601 for proto in self.protos:
602 if func_class in proto.name:
603 packet_update_txt = ''
604 return_txt = ''
605 packet_size = ''
606 buff_ptr_indices = []
607 func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))
608 for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL
609 func_body.append(' %s %s,' % (p.ty, p.name))
610 if 'Size' in p.name:
611 packet_size += p.name
612 if '*' in p.ty and 'pSysMem' != p.name:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]613 if 'char' in p.ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]614 packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]615 elif 'Size' not in packet_size:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]616 packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]617 buff_ptr_indices.append(proto.params.index(p))
618 if 'pConnectionInfo' in p.name:
619 packet_size += '((pConnectionInfo->pConnection != NULL) ? sizeof(void *) : 0)'
620 else:
621 packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)
622 if '' == packet_size:
623 packet_size = '0'
624 else:
625 packet_size = packet_size.strip(' + ')
626 func_body[-1] = func_body[-1].replace(',', ')')
627 func_body.append('{\n glv_trace_packet_header* pHeader;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]628 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]629 func_body.append(' %s result;' % proto.ret)
630 return_txt = 'result = '
631 func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)
632 if proto.name in thread_once_funcs:
633 func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')
634 func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)
635 func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))
636 func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))
637 func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)
638 func_body.append(packet_update_txt.strip('\n'))
639 for idx in buff_ptr_indices:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]640 if 'char' in proto.params[idx].ty:
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]641 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), ((%s != NULL) ? strlen(%s) + 1 : 0), %s);' % (proto.params[idx].name, proto.params[idx].name, proto.params[idx].name, proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]642 elif 'Size' in proto.params[idx-1].name:
643 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))
644 else:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]645 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, proto.params[idx].ty.strip('*').replace('const ', ''), proto.params[idx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]646 if 'WsiX11AssociateConnection' in proto.name:
647 func_body.append(' if (pConnectionInfo->pConnection != NULL) {')
648 func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection), sizeof(void *), pConnectionInfo->pConnection);')
649 func_body.append(' glv_finalize_buffer_address(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection));')
650 func_body.append(' }')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]651 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]652 func_body.append(' pPacket->result = result;')
653 for idx in buff_ptr_indices:
654 func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))
655 func_body.append(' FINISH_TRACE_PACKET();')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]656 if 'void' not in proto.ret or '*' in proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]657 func_body.append(' return result;')
658 func_body.append('}\n')
659 return "\n".join(func_body)
660
661 def _generate_helper_funcs(self):
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]662 # TODO : Need helper funcs to calculate the size of DescriptorUpdate and CreateSetLayout struct chains
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]663 hf_body = []
664 hf_body.append('// Support for shadowing CPU mapped memory')
665 hf_body.append('typedef struct _XGLAllocInfo {')
666 hf_body.append(' XGL_GPU_SIZE size;')
667 hf_body.append(' XGL_GPU_MEMORY handle;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]668 hf_body.append(' void *pData;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]669 hf_body.append(' BOOL valid;')
670 hf_body.append('} XGLAllocInfo;')
671 hf_body.append('typedef struct _XGLMemInfo {')
672 hf_body.append(' unsigned int numEntrys;')
673 hf_body.append(' XGLAllocInfo *pEntrys;')
674 hf_body.append(' XGLAllocInfo *pLastMapped;')
675 hf_body.append(' unsigned int capacity;')
676 hf_body.append('} XGLMemInfo;')
677 hf_body.append('')
678 hf_body.append('static XGLMemInfo mInfo = {0, NULL, NULL, 0};')
679 hf_body.append('')
680 hf_body.append('static void init_mem_info_entrys(XGLAllocInfo *ptr, const unsigned int num)')
681 hf_body.append('{')
682 hf_body.append(' unsigned int i;')
683 hf_body.append(' for (i = 0; i < num; i++)')
684 hf_body.append(' {')
685 hf_body.append(' XGLAllocInfo *entry = ptr + i;')
686 hf_body.append(' entry->pData = NULL;')
687 hf_body.append(' entry->size = 0;')
688 hf_body.append(' entry->handle = NULL;')
689 hf_body.append(' entry->valid = FALSE;')
690 hf_body.append(' }')
691 hf_body.append('}')
692 hf_body.append('')
693 hf_body.append('static void init_mem_info()')
694 hf_body.append('{')
695 hf_body.append(' mInfo.numEntrys = 0;')
696 hf_body.append(' mInfo.capacity = 1024;')
697 hf_body.append(' mInfo.pLastMapped = NULL;')
698 hf_body.append('')
699 hf_body.append(' mInfo.pEntrys = GLV_NEW_ARRAY(XGLAllocInfo, mInfo.capacity);')
700 hf_body.append('')
701 hf_body.append(' if (mInfo.pEntrys == NULL)')
702 hf_body.append(' glv_LogError("init_mem_info() malloc failed\\n");')
703 hf_body.append(' else')
704 hf_body.append(' init_mem_info_entrys(mInfo.pEntrys, mInfo.capacity);')
705 hf_body.append('}')
706 hf_body.append('')
707 hf_body.append('static void delete_mem_info()')
708 hf_body.append('{')
709 hf_body.append(' GLV_DELETE(mInfo.pEntrys);')
710 hf_body.append(' mInfo.pEntrys = NULL;')
711 hf_body.append(' mInfo.numEntrys = 0;')
712 hf_body.append(' mInfo.capacity = 0;')
713 hf_body.append(' mInfo.pLastMapped = NULL;')
714 hf_body.append('}')
715 hf_body.append('')
716 hf_body.append('static XGLAllocInfo * get_mem_info_entry()')
717 hf_body.append('{')
718 hf_body.append(' unsigned int i;')
719 hf_body.append(' XGLAllocInfo *entry;')
720 hf_body.append(' if (mInfo.numEntrys > mInfo.capacity)')
721 hf_body.append(' {')
722 hf_body.append(' glv_LogError("get_mem_info_entry() bad internal state numEntrys\\n");')
723 hf_body.append(' return NULL;')
724 hf_body.append(' }')
725 hf_body.append('')
726 hf_body.append(' if (mInfo.numEntrys == mInfo.capacity)')
727 hf_body.append(' { // grow the array 2x')
728 hf_body.append(' mInfo.capacity *= 2;')
729 hf_body.append(' mInfo.pEntrys = (XGLAllocInfo *) GLV_REALLOC(mInfo.pEntrys, mInfo.capacity * sizeof(XGLAllocInfo));')
730 hf_body.append(' //init the newly added entrys')
731 hf_body.append(' init_mem_info_entrys(mInfo.pEntrys + mInfo.capacity / 2, mInfo.capacity / 2);')
732 hf_body.append(' }')
733 hf_body.append('')
734 hf_body.append(' assert(mInfo.numEntrys < mInfo.capacity);')
735 hf_body.append(' entry = mInfo.pEntrys;')
736 hf_body.append(' for (i = 0; i < mInfo.capacity; i++)')
737 hf_body.append(' {')
738 hf_body.append(' if ((entry + i)->valid == FALSE)')
739 hf_body.append(' return entry + i;')
740 hf_body.append(' }')
741 hf_body.append('')
742 hf_body.append(' glv_LogError("get_mem_info_entry() did not find an entry\\n");')
743 hf_body.append(' return NULL;')
744 hf_body.append('}')
745 hf_body.append('')
746 hf_body.append('static XGLAllocInfo * find_mem_info_entry(const XGL_GPU_MEMORY handle)')
747 hf_body.append('{')
748 hf_body.append(' XGLAllocInfo *entry = mInfo.pEntrys;')
749 hf_body.append(' unsigned int i;')
750 hf_body.append(' if (mInfo.pLastMapped && mInfo.pLastMapped->handle == handle && mInfo.pLastMapped->valid)')
751 hf_body.append(' return mInfo.pLastMapped;')
752 hf_body.append(' for (i = 0; i < mInfo.numEntrys; i++)')
753 hf_body.append(' {')
754 hf_body.append(' if ((entry + i)->valid && (handle == (entry + i)->handle))')
755 hf_body.append(' return entry + i;')
756 hf_body.append(' }')
757 hf_body.append('')
758 hf_body.append(' return NULL;')
759 hf_body.append('}')
760 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]761 hf_body.append('static void add_new_handle_to_mem_info(const XGL_GPU_MEMORY handle, XGL_GPU_SIZE size, void *pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]762 hf_body.append('{')
763 hf_body.append(' XGLAllocInfo *entry;')
764 hf_body.append('')
765 hf_body.append(' if (mInfo.capacity == 0)')
766 hf_body.append(' init_mem_info();')
767 hf_body.append('')
768 hf_body.append(' entry = get_mem_info_entry();')
769 hf_body.append(' if (entry)')
770 hf_body.append(' {')
771 hf_body.append(' entry->valid = TRUE;')
772 hf_body.append(' entry->handle = handle;')
773 hf_body.append(' entry->size = size;')
774 hf_body.append(' entry->pData = pData; // NOTE: xglFreeMemory will free this mem, so no malloc()')
775 hf_body.append(' mInfo.numEntrys++;')
776 hf_body.append(' }')
777 hf_body.append('}')
778 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]779 hf_body.append('static void add_data_to_mem_info(const XGL_GPU_MEMORY handle, void *pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]780 hf_body.append('{')
781 hf_body.append(' XGLAllocInfo *entry = find_mem_info_entry(handle);')
782 hf_body.append('')
783 hf_body.append(' if (entry)')
784 hf_body.append(' {')
785 hf_body.append(' entry->pData = pData;')
786 hf_body.append(' }')
787 hf_body.append(' mInfo.pLastMapped = entry;')
788 hf_body.append('}')
789 hf_body.append('')
790 hf_body.append('static void rm_handle_from_mem_info(const XGL_GPU_MEMORY handle)')
791 hf_body.append('{')
792 hf_body.append(' XGLAllocInfo *entry = find_mem_info_entry(handle);')
793 hf_body.append('')
794 hf_body.append(' if (entry)')
795 hf_body.append(' {')
796 hf_body.append(' entry->valid = FALSE;')
797 hf_body.append(' entry->pData = NULL;')
798 hf_body.append(' entry->size = 0;')
799 hf_body.append(' entry->handle = NULL;')
800 hf_body.append('')
801 hf_body.append(' mInfo.numEntrys--;')
802 hf_body.append(' if (entry == mInfo.pLastMapped)')
803 hf_body.append(' mInfo.pLastMapped = NULL;')
804 hf_body.append(' if (mInfo.numEntrys == 0)')
805 hf_body.append(' delete_mem_info();')
806 hf_body.append(' }')
807 hf_body.append('}')
808 hf_body.append('')
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]809 hf_body.append('static size_t calculate_create_ds_layout_size(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo)')
810 hf_body.append('{')
811 hf_body.append(' size_t update_size = 0;')
812 hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pTrav = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pCreateInfo;')
813 hf_body.append(' while (pTrav)')
814 hf_body.append(' {')
815 hf_body.append(' update_size += sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);')
816 hf_body.append(' pTrav = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pTrav->pNext;')
817 hf_body.append(' }')
818 hf_body.append(' return update_size;')
819 hf_body.append('}')
820 hf_body.append('static void add_create_ds_layout_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
821 hf_body.append('{')
822 hf_body.append(' // TODO : ADD THIS CODE;')
823 hf_body.append('}')
824 hf_body.append('static size_t calculate_ds_update_size(const void* pUpdateChain)')
825 hf_body.append('{')
826 hf_body.append(' size_t update_size = 0;')
827 hf_body.append(' XGL_UPDATE_SAMPLERS* pTrav = (XGL_UPDATE_SAMPLERS*)pUpdateChain;')
828 hf_body.append(' while (pTrav)')
829 hf_body.append(' {')
830 hf_body.append(' switch (pTrav->sType)')
831 hf_body.append(' {')
832 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')
833 hf_body.append(' {')
834 hf_body.append(' update_size += sizeof(XGL_UPDATE_SAMPLERS);')
835 hf_body.append(' break;')
836 hf_body.append(' }')
837 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')
838 hf_body.append(' {')
839 hf_body.append(' update_size += sizeof(XGL_UPDATE_SAMPLER_TEXTURES);')
840 hf_body.append(' break;')
841 hf_body.append(' }')
842 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')
843 hf_body.append(' {')
844 hf_body.append(' update_size += sizeof(XGL_UPDATE_IMAGES);')
845 hf_body.append(' break;')
846 hf_body.append(' }')
847 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')
848 hf_body.append(' {')
849 hf_body.append(' update_size += sizeof(XGL_UPDATE_BUFFERS);')
850 hf_body.append(' break;')
851 hf_body.append(' }')
852 hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')
853 hf_body.append(' {')
854 hf_body.append(' update_size += sizeof(XGL_UPDATE_AS_COPY);')
855 hf_body.append(' break;')
856 hf_body.append(' }')
857 hf_body.append(' default:')
858 hf_body.append(' glv_LogError("calculate_ds_update_size() bad internal state sType\\n");')
859 hf_body.append(' break;')
860 hf_body.append(' }')
861 hf_body.append(' pTrav = (XGL_UPDATE_SAMPLERS*)pTrav->pNext;')
862 hf_body.append(' }')
863 hf_body.append(' return update_size;')
864 hf_body.append('}')
865 hf_body.append('static void add_ds_update_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
866 hf_body.append('{')
867 hf_body.append(' // TODO : ADD THIS CODE;')
868 hf_body.append('}')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]869 hf_body.append('static void add_begin_cmdbuf_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]870 hf_body.append('{')
871 hf_body.append(' const XGL_CMD_BUFFER_BEGIN_INFO* pInNow = pIn;')
872 hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)ppOut;')
873 hf_body.append(' while (pInNow != NULL)')
874 hf_body.append(' {')
875 hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNow = ppOutNext;')
876 hf_body.append(' ppOutNext = NULL;')
877 hf_body.append('')
878 hf_body.append(' switch (pInNow->sType)')
879 hf_body.append(' {')
880 hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')
881 hf_body.append(' {')
882 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO), pInNow);')
883 hf_body.append(' ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)&(*ppOutNow)->pNext;')
884 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
885 hf_body.append(' break;')
886 hf_body.append(' }')
887 hf_body.append(' default:')
888 hf_body.append(' assert(!"Encountered an unexpected type in pipeline state list");')
889 hf_body.append(' }')
890 hf_body.append(' pInNow = (XGL_CMD_BUFFER_BEGIN_INFO*)pInNow->pNext;')
891 hf_body.append(' }')
892 hf_body.append(' return;')
893 hf_body.append('}')
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]894 hf_body.append('')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]895 hf_body.append('static size_t calculate_begin_cmdbuf_size(const XGL_CMD_BUFFER_BEGIN_INFO* pNext)')
896 hf_body.append('{')
897 hf_body.append(' size_t siz = 0;')
898 hf_body.append(' while (pNext != NULL)')
899 hf_body.append(' {')
900 hf_body.append(' switch (pNext->sType)')
901 hf_body.append(' {')
902 hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')
903 hf_body.append(' {')
904 hf_body.append(' siz += sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);')
905 hf_body.append(' break;')
906 hf_body.append(' }')
907 hf_body.append(' default:')
908 hf_body.append(' glv_LogError("calculate_begin_cmdbuf_size() bad internal state sType\\n");')
909 hf_body.append(' break;')
910 hf_body.append(' }')
911 hf_body.append(' pNext = (XGL_CMD_BUFFER_BEGIN_INFO*)pNext->pNext;')
912 hf_body.append(' }')
913 hf_body.append(' return siz;')
914 hf_body.append('}')
915 hf_body.append('')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]916 hf_body.append('static size_t calculate_pipeline_shader_size(const XGL_PIPELINE_SHADER* shader)')
917 hf_body.append('{')
918 hf_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]919 hf_body.append(' size += sizeof(XGL_PIPELINE_SHADER);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]920 hf_body.append(' // constant buffers')
921 hf_body.append(' if (shader->linkConstBufferCount > 0 && shader->pLinkConstBufferInfo != NULL)')
922 hf_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]923 hf_body.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]924 hf_body.append(' for (i = 0; i < shader->linkConstBufferCount; i++)')
925 hf_body.append(' {')
926 hf_body.append(' size += sizeof(XGL_LINK_CONST_BUFFER);')
927 hf_body.append(' size += shader->pLinkConstBufferInfo[i].bufferSize;')
928 hf_body.append(' }')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]929 hf_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]930 hf_body.append(' return size;')
931 hf_body.append('}')
932 hf_body.append('')
933 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)')
934 hf_body.append('{')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]935 hf_body.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]936 hf_body.append(' // constant buffers')
937 hf_body.append(' if (paramShader->linkConstBufferCount > 0 && paramShader->pLinkConstBufferInfo != NULL)')
938 hf_body.append(' {')
939 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo), sizeof(XGL_LINK_CONST_BUFFER) * paramShader->linkConstBufferCount, paramShader->pLinkConstBufferInfo);')
940 hf_body.append(' for (i = 0; i < paramShader->linkConstBufferCount; i++)')
941 hf_body.append(' {')
942 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData), packetShader->pLinkConstBufferInfo[i].bufferSize, paramShader->pLinkConstBufferInfo[i].pBufferData);')
943 hf_body.append(' }')
944 hf_body.append(' }')
945 hf_body.append('}')
946 hf_body.append('')
947 hf_body.append('static void finalize_pipeline_shader_address(glv_trace_packet_header* pHeader, const XGL_PIPELINE_SHADER* packetShader)')
948 hf_body.append('{')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]949 hf_body.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]950 hf_body.append(' // constant buffers')
951 hf_body.append(' if (packetShader->linkConstBufferCount > 0 && packetShader->pLinkConstBufferInfo != NULL)')
952 hf_body.append(' {')
953 hf_body.append(' for (i = 0; i < packetShader->linkConstBufferCount; i++)')
954 hf_body.append(' {')
955 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData));')
956 hf_body.append(' }')
957 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo));')
958 hf_body.append(' }')
959 hf_body.append('}')
960 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]961 hf_body.append('static size_t calculate_pipeline_state_size(const void* pState)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]962 hf_body.append('{')
963 hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pNext = pState;')
964 hf_body.append(' size_t totalStateSize = 0;')
965 hf_body.append(' while (pNext)')
966 hf_body.append(' {')
967 hf_body.append(' switch (pNext->sType)')
968 hf_body.append(' {')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]969 pipe_state_list = ['IA_STATE_CREATE_INFO',
970 'TESS_STATE_CREATE_INFO',
971 'RS_STATE_CREATE_INFO',
972 'DS_STATE_CREATE_INFO',
973 'CB_STATE_CREATE_INFO',
974 'VP_STATE_CREATE_INFO',
975 'MS_STATE_CREATE_INFO'
976 ]
977 for pipe_state in pipe_state_list:
978 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_%s:' % pipe_state)
979 hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_%s);' % pipe_state)
980 hf_body.append(' break;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]981 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')
982 hf_body.append(' {')
983 hf_body.append(' const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pShaderStage = (const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext;')
984 hf_body.append(' totalStateSize += (sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO) + calculate_pipeline_shader_size(&pShaderStage->shader));')
985 hf_body.append(' break;')
986 hf_body.append(' }')
987 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')
988 hf_body.append(' {')
989 hf_body.append(' const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVi = (const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pNext;')
990 hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO) + pVi->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION)')
991 hf_body.append(' + pVi->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);')
992 hf_body.append(' break;')
993 hf_body.append(' }')
994 hf_body.append(' default:')
995 hf_body.append(' assert(0);')
996 hf_body.append(' }')
997 hf_body.append(' pNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pNext->pNext;')
998 hf_body.append(' }')
999 hf_body.append(' return totalStateSize;')
1000 hf_body.append('}')
1001 hf_body.append('')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1002 hf_body.append('static void add_pipeline_state_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1003 hf_body.append('{')
1004 hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInNow = pIn;')
1005 hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)ppOut;')
1006 hf_body.append(' while (pInNow != NULL)')
1007 hf_body.append(' {')
1008 hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNow = ppOutNext;')
1009 hf_body.append(' ppOutNext = NULL;')
1010 hf_body.append('')
1011 hf_body.append(' switch (pInNow->sType)')
1012 hf_body.append(' {')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1013 # TODO : FINISH THIS LOOP AND DELETE CODE BELOW IT
1014 for pipe_state in pipe_state_list:
1015 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_%s:' % pipe_state)
1016 hf_body.append(' {')
1017 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_%s), pInNow);' % pipe_state)
1018 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1019 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1020 hf_body.append(' break;')
1021 hf_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1022 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')
1023 hf_body.append(' {')
1024 hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacket = NULL;')
1025 hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInPacket = NULL;')
1026 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO), pInNow);')
1027 hf_body.append(' pPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) *ppOutNow;')
1028 hf_body.append(' pInPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) pInNow;')
1029 hf_body.append(' add_pipeline_shader_to_trace_packet(pHeader, &pPacket->shader, &pInPacket->shader);')
1030 hf_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->shader);')
1031 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1032 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1033 hf_body.append(' break;')
1034 hf_body.append(' }')
1035 hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')
1036 hf_body.append(' {')
1037 hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pPacket = NULL;')
1038 hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pIn = NULL;')
1039 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO), pInNow);')
1040 hf_body.append(' pPacket = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) *ppOutNow;')
1041 hf_body.append(' pIn = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) pInNow;')
1042 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexBindingDescriptions, pIn->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION), pIn->pVertexBindingDescriptions);')
1043 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexBindingDescriptions));')
1044 hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexAttributeDescriptions, pIn->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION), pIn->pVertexAttributeDescriptions);')
1045 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexAttributeDescriptions));')
1046 hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')
1047 hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')
1048 hf_body.append(' break;')
1049 hf_body.append(' }')
1050 hf_body.append(' default:')
1051 hf_body.append(' assert(!"Encountered an unexpected type in pipeline state list");')
1052 hf_body.append(' }')
1053 hf_body.append(' pInNow = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pInNow->pNext;')
1054 hf_body.append(' }')
1055 hf_body.append(' return;')
1056 hf_body.append('}')
1057 return "\n".join(hf_body)
1058
1059 def _generate_packet_id_enum(self):
1060 pid_enum = []
1061 pid_enum.append('enum GLV_TRACE_PACKET_ID_XGL')
1062 pid_enum.append('{')
1063 first_func = True
1064 for proto in self.protos:
1065 if first_func:
1066 first_func = False
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1067 pid_enum.append(' GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,')
1068 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1069 else:
1070 pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)
1071 pid_enum.append('};\n')
1072 return "\n".join(pid_enum)
1073
1074 def _generate_stringify_func(self):
1075 func_body = []
1076 func_body.append('static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)')
1077 func_body.append('{')
1078 func_body.append(' static char str[1024];')
1079 func_body.append(' switch(id) {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1080 func_body.append(' case GLV_TPI_XGL_xglApiVersion:')
1081 func_body.append(' {')
1082 func_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);')
1083 func_body.append(' snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);')
1084 func_body.append(' return str;')
1085 func_body.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1086 for proto in self.protos:
1087 func_body.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
1088 func_body.append(' {')
1089 func_str = 'xgl%s(' % proto.name
1090 print_vals = ''
1091 create_func = False
1092 if 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
1093 create_func = True
1094 for p in proto.params:
1095 last_param = False
1096 if (p.name == proto.params[-1].name):
1097 last_param = True
1098 if last_param and create_func: # last param of create func
1099 (pft, pfi) = self._get_printf_params(p.ty,'pPacket->%s' % p.name, True)
1100 else:
1101 (pft, pfi) = self._get_printf_params(p.ty, 'pPacket->%s' % p.name, False)
1102 if last_param == True:
1103 func_str += '%s = %s)' % (p.name, pft)
1104 print_vals += ', %s' % (pfi)
1105 else:
1106 func_str += '%s = %s, ' % (p.name, pft)
1107 print_vals += ', %s' % (pfi)
1108 func_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(pHeader->pBody);' % (proto.name, proto.name))
1109 func_body.append(' snprintf(str, 1024, "%s"%s);' % (func_str, print_vals))
1110 func_body.append(' return str;')
1111 func_body.append(' }')
1112 func_body.append(' default:')
1113 func_body.append(' return NULL;')
1114 func_body.append(' }')
1115 func_body.append('};\n')
1116 return "\n".join(func_body)
1117
1118 def _generate_interp_func(self):
1119 interp_func_body = []
1120 interp_func_body.append('static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)')
1121 interp_func_body.append('{')
1122 interp_func_body.append(' if (pHeader == NULL)')
1123 interp_func_body.append(' {')
1124 interp_func_body.append(' return NULL;')
1125 interp_func_body.append(' }')
1126 interp_func_body.append(' switch (pHeader->packet_id)')
1127 interp_func_body.append(' {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1128 interp_func_body.append(' case GLV_TPI_XGL_xglApiVersion:\n {')
1129 interp_func_body.append(' return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;\n }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1130 for proto in self.protos:
1131 interp_func_body.append(' case GLV_TPI_XGL_xgl%s:\n {' % proto.name)
1132 header_prefix = 'h'
1133 if 'Wsi' in proto.name or 'Dbg' in proto.name:
1134 header_prefix = 'pH'
1135 interp_func_body.append(' return interpret_body_as_xgl%s(pHeader)->%seader;\n }' % (proto.name, header_prefix))
1136 interp_func_body.append(' default:')
1137 interp_func_body.append(' return NULL;')
1138 interp_func_body.append(' }')
1139 interp_func_body.append(' return NULL;')
1140 interp_func_body.append('}')
1141 return "\n".join(interp_func_body)
1142
1143 def _generate_struct_util_funcs(self):
1144 pid_enum = []
1145 pid_enum.append('//=============================================================================')
1146 pid_enum.append('static uint64_t calc_size_XGL_APPLICATION_INFO(const XGL_APPLICATION_INFO* pStruct)')
1147 pid_enum.append('{')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]1148 pid_enum.append(' return ((pStruct == NULL) ? 0 : sizeof(XGL_APPLICATION_INFO)) + strlen(pStruct->pAppName) + 1 + strlen(pStruct->pEngineName) + 1;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1149 pid_enum.append('}\n')
1150 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)')
1151 pid_enum.append('{')
1152 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_APPLICATION_INFO), pInStruct);')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]1153 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen(pInStruct->pAppName) + 1, pInStruct->pAppName);')
1154 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen(pInStruct->pEngineName) + 1, pInStruct->pEngineName);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1155 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')
1156 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')
1157 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')
1158 pid_enum.append('};\n')
1159 pid_enum.append('//=============================================================================\n')
1160 pid_enum.append('static uint64_t calc_size_XGL_DEVICE_CREATE_INFO(const XGL_DEVICE_CREATE_INFO* pStruct)')
1161 pid_enum.append('{')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1162 pid_enum.append(' uint64_t total_size_ppEnabledExtensionNames = pStruct->extensionCount * sizeof(char *);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1163 pid_enum.append(' uint32_t i;')
1164 pid_enum.append(' for (i = 0; i < pStruct->extensionCount; i++)')
1165 pid_enum.append(' {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]1166 pid_enum.append(' total_size_ppEnabledExtensionNames += strlen(pStruct->ppEnabledExtensionNames[i]) + 1;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1167 pid_enum.append(' }')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1168 pid_enum.append(' uint64_t total_size_layers = 0;')
1169 pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) pStruct->pNext;')
1170 pid_enum.append(' while (pNext != NULL)')
1171 pid_enum.append(' {')
1172 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1173 pid_enum.append(' {')
1174 pid_enum.append(' total_size_layers += sizeof(XGL_LAYER_CREATE_INFO);')
1175 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1176 pid_enum.append(' {')
1177 pid_enum.append(' total_size_layers += strlen(pNext->ppActiveLayerNames[i]) + 1;')
1178 pid_enum.append(' }')
1179 pid_enum.append(' }')
1180 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) pNext->pNext;')
1181 pid_enum.append(' }')
1182 pid_enum.append(' return sizeof(XGL_DEVICE_CREATE_INFO) + (pStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO)) + total_size_ppEnabledExtensionNames + total_size_layers;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1183 pid_enum.append('}\n')
1184 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)')
1185 pid_enum.append('{')
1186 pid_enum.append(' uint32_t i;')
1187 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_DEVICE_CREATE_INFO), pInStruct);')
1188 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO), pInStruct->pRequestedQueues);')
1189 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')
1190 pid_enum.append(' if (pInStruct->extensionCount > 0) ')
1191 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1192 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char *), pInStruct->ppEnabledExtensionNames);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1193 pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')
1194 pid_enum.append(' {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]1195 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen(pInStruct->ppEnabledExtensionNames[i]) + 1, pInStruct->ppEnabledExtensionNames[i]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1196 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')
1197 pid_enum.append(' }')
1198 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')
1199 pid_enum.append(' }')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1200 pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) pInStruct->pNext;')
1201 pid_enum.append(' while (pNext != NULL)')
1202 pid_enum.append(' {')
1203 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1204 pid_enum.append(' {')
1205 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->pNext)), sizeof(XGL_LAYER_CREATE_INFO), pNext);')
1206 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->pNext)));')
1207 pid_enum.append(' XGL_LAYER_CREATE_INFO **ppOutStruct = (XGL_LAYER_CREATE_INFO **) &((*ppStruct)->pNext);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1208 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppOutStruct)->ppActiveLayerNames), pNext->layerCount * sizeof(char *), pNext->ppActiveLayerNames);')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1209 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1210 pid_enum.append(' {')
1211 pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])), strlen(pNext->ppActiveLayerNames[i]) + 1, pNext->ppActiveLayerNames[i]);')
1212 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])));')
1213 pid_enum.append(' }')
1214 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppOutStruct)->ppActiveLayerNames);')
1215 pid_enum.append(' }')
1216 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) pNext->pNext;')
1217 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1218 pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')
1219 pid_enum.append('}\n')
1220 pid_enum.append('static XGL_DEVICE_CREATE_INFO* interpret_XGL_DEVICE_CREATE_INFO(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')
1221 pid_enum.append('{')
1222 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')
1223 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO != NULL)')
1224 pid_enum.append(' {')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1225 pid_enum.append(' uint32_t i;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1226 pid_enum.append(' const char** pNames;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1227 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')
1228 pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO->extensionCount > 0)')
1229 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1230 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);')
1231 pid_enum.append(' pNames = (const char**)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1232 pid_enum.append(' for (i = 0; i < pXGL_DEVICE_CREATE_INFO->extensionCount; i++)')
1233 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1234 pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames[i]));')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1235 pid_enum.append(' }')
1236 pid_enum.append(' }')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1237 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);')
1238 pid_enum.append(' while (pNext != NULL)')
1239 pid_enum.append(' {')
1240 pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')
1241 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1242 pid_enum.append(' pNext->ppActiveLayerNames = (const char**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames));')
1243 pid_enum.append(' pNames = (const char**)pNext->ppActiveLayerNames;')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1244 pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')
1245 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1246 pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames[i]));')
Jon Ashburn780112b2015-01-09 17:30:41 -0700[diff] [blame]1247 pid_enum.append(' }')
1248 pid_enum.append(' }')
1249 pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);')
1250 pid_enum.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1251 pid_enum.append(' }\n')
1252 pid_enum.append(' return pXGL_DEVICE_CREATE_INFO;')
1253 pid_enum.append('}\n')
1254 pid_enum.append('static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* pShader)')
1255 pid_enum.append('{')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1256 pid_enum.append(' if (pShader != NULL)')
1257 pid_enum.append(' {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1258 pid_enum.append(' // constant buffers')
1259 pid_enum.append(' if (pShader->linkConstBufferCount > 0)')
1260 pid_enum.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1261 pid_enum.append(' uint32_t i;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1262 pid_enum.append(' pShader->pLinkConstBufferInfo = (const XGL_LINK_CONST_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);')
1263 pid_enum.append(' for (i = 0; i < pShader->linkConstBufferCount; i++)')
1264 pid_enum.append(' {')
1265 pid_enum.append(' XGL_LINK_CONST_BUFFER* pBuffer = (XGL_LINK_CONST_BUFFER*)pShader->pLinkConstBufferInfo;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1266 pid_enum.append(' pBuffer[i].pBufferData = (const void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo[i].pBufferData);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1267 pid_enum.append(' }')
1268 pid_enum.append(' }')
1269 pid_enum.append(' }')
1270 pid_enum.append('}\n')
1271 pid_enum.append('//=============================================================================')
1272 return "\n".join(pid_enum)
1273
1274 def _generate_interp_funcs(self):
1275 # Custom txt for given function and parameter. First check if param is NULL, then insert txt if not
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1276 custom_case_dict = { 'CreateInstance' : {'param': 'pAppInfo', 'txt': ['XGL_APPLICATION_INFO* pInfo = (XGL_APPLICATION_INFO*)pPacket->pAppInfo;\n',
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1277 'pInfo->pAppName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);\n',
1278 'pInfo->pEngineName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pEngineName);']},
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1279 'CreateShader' : {'param': 'pCreateInfo', 'txt': ['XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;\n',
1280 'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},
1281 'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['XGL_FRAMEBUFFER_CREATE_INFO* pInfo = (XGL_FRAMEBUFFER_CREATE_INFO*)pPacket->pCreateInfo;\n',
1282 'pInfo->pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',
1283 'pInfo->pDepthStencilAttachment = (XGL_DEPTH_STENCIL_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},
1284 'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': ['XGL_RENDER_PASS_CREATE_INFO* pInfo = (XGL_RENDER_PASS_CREATE_INFO*)pPacket->pCreateInfo;\n',
1285 'pInfo->pColorLoadOps = (XGL_ATTACHMENT_LOAD_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadOps);\n',
1286 'pInfo->pColorStoreOps = (XGL_ATTACHMENT_STORE_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorStoreOps);\n',
1287 'pInfo->pColorLoadClearValues = (XGL_CLEAR_COLOR*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadClearValues);\n']},
1288 'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['assert(pPacket->pBeginInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO);\n',
1289 '// 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 Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1290 'void** ppNextVoidPtr = (void**)&pPacket->pBeginInfo->pNext;\n',
1291 '*ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1292 'XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pPacket->pBeginInfo->pNext;\n',
1293 'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
1294 ' switch(pNext->sType)\n', ' {\n',
1295 ' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:\n',
1296 ' {\n',
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1297 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1298 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1299 ' break;\n',
1300 ' }\n',
1301 ' default:\n',
1302 ' assert(!"Encountered an unexpected type in begin command buffer list");\n',
1303 ' }\n',
1304 ' pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pNext->pNext;\n',
1305 '}']},
1306 'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['assert(pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);\n',
1307 '// 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 Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1308 'void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',
1309 '*ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]1310 'XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n',
1311 'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1312 ' switch(pNext->sType)\n', ' {\n',
1313 ' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',
1314 ' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',
1315 ' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1316 ' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1317 ' case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',
1318 ' case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',
1319 ' case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1320 ' {\n',
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1321 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1322 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1323 ' break;\n',
1324 ' }\n',
1325 ' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',
1326 ' {\n',
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1327 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
1328 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1329 ' interpret_pipeline_shader(pHeader, &pNext->shader);\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1330 ' break;\n',
1331 ' }\n',
1332 ' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',
1333 ' {\n',
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1334 ' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1335 ' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1336 ' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1337 ' pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',
1338 ' pVi->pVertexAttributeDescriptions = (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',
1339 ' break;\n',
1340 ' }\n',
1341 ' default:\n',
1342 ' assert(!"Encountered an unexpected type in pipeline state list");\n',
1343 ' }\n',
1344 ' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',
1345 '}']},
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]1346 'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));']}}
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1347 if_body = []
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]1348 if_body.append('typedef struct struct_xglApiVersion {')
1349 if_body.append(' glv_trace_packet_header* header;')
1350 if_body.append(' uint32_t version;')
1351 if_body.append('} struct_xglApiVersion;\n')
1352 if_body.append('static struct_xglApiVersion* interpret_body_as_xglApiVersion(glv_trace_packet_header* pHeader, BOOL check_version)')
1353 if_body.append('{')
1354 if_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)pHeader->pBody;')
1355 if_body.append(' pPacket->header = pHeader;')
1356 if_body.append(' if (check_version && pPacket->version != XGL_API_VERSION)')
1357 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);')
1358 if_body.append(' return pPacket;')
1359 if_body.append('}\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1360 for proto in self.protos:
1361 if 'Wsi' not in proto.name and 'Dbg' not in proto.name:
1362 if 'UnmapMemory' == proto.name:
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1363 proto.params.append(xgl.Param("void*", "pData"))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1364 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1365 if_body.append(' glv_trace_packet_header* header;')
1366 for p in proto.params:
1367 if '[4]' in p.ty:
1368 if_body.append(' %s %s[4];' % (p.ty.strip('[4]'), p.name))
1369 else:
1370 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1371 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1372 if_body.append(' %s result;' % proto.ret)
1373 if_body.append('} struct_xgl%s;\n' % proto.name)
1374 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1375 if_body.append('{')
1376 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1377 if_body.append(' pPacket->header = pHeader;')
1378 for p in proto.params:
1379 if '*' in p.ty:
1380 if 'DEVICE_CREATE_INFO' in p.ty:
1381 if_body.append(' pPacket->%s = interpret_XGL_DEVICE_CREATE_INFO(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))
1382 else:
1383 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
1384 if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:
1385 if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])
1386 if_body.append(' {')
1387 if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))
1388 if_body.append(' }')
1389 if_body.append(' return pPacket;')
1390 if_body.append('}\n')
1391 return "\n".join(if_body)
1392
1393 def _generate_interp_funcs_ext(self, func_class='Wsi'):
1394 if_body = []
1395 for proto in self.protos:
1396 if func_class in proto.name:
1397 if_body.append('typedef struct struct_xgl%s {' % proto.name)
1398 if_body.append(' glv_trace_packet_header* pHeader;')
1399 for p in proto.params:
1400 if_body.append(' %s %s;' % (p.ty, p.name))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1401 if 'void' != proto.ret:
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1402 if_body.append(' %s result;' % proto.ret)
1403 if_body.append('} struct_xgl%s;\n' % proto.name)
1404 if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))
1405 if_body.append('{')
1406 if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))
1407 if_body.append(' pPacket->pHeader = pHeader;')
1408 for p in proto.params:
1409 if '*' in p.ty:
1410 if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))
1411 if_body.append(' return pPacket;')
1412 if_body.append('}\n')
1413 return "\n".join(if_body)
1414
1415 def _generate_replay_class_decls(self):
1416 cd_body = []
1417 cd_body.append('class ApiReplay {')
1418 cd_body.append('public:')
1419 cd_body.append(' virtual ~ApiReplay() { }')
1420 cd_body.append(' virtual enum glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header * packet) = 0;')
1421 cd_body.append(' virtual int init(glv_replay::Display & disp) = 0;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1422 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 Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1423 cd_body.append(' virtual glv_replay::GLV_REPLAY_RESULT pop_validation_msgs() = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1424 cd_body.append('};\n')
1425 cd_body.append('class xglDisplay: public glv_replay::DisplayImp {')
1426 cd_body.append('friend class xglReplay;')
1427 cd_body.append('public:')
1428 cd_body.append(' xglDisplay();')
1429 cd_body.append(' ~xglDisplay();')
1430 cd_body.append(' int init(const unsigned int gpu_idx);')
1431 cd_body.append(' int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height);')
1432 cd_body.append(' int create_window(const unsigned int width, const unsigned int height);')
1433 cd_body.append(' void resize_window(const unsigned int width, const unsigned int height);')
1434 cd_body.append(' void process_event();')
1435 cd_body.append(' // XGL_DEVICE get_device() { return m_dev[m_gpuIdx];}')
1436 cd_body.append('#if defined(WIN32)')
1437 cd_body.append(' HWND get_window_handle() { return m_windowHandle; }')
1438 cd_body.append('#elif defined(PLATFORM_LINUX)')
1439 cd_body.append(' xcb_window_t get_window_handle() { return m_XcbWindow; }')
1440 cd_body.append('#endif')
1441 cd_body.append('private:')
1442 cd_body.append(' XGL_RESULT init_xgl(const unsigned int gpu_idx);')
1443 cd_body.append(' bool m_initedXGL;')
1444 cd_body.append('#if defined(WIN32)')
1445 cd_body.append(' HWND m_windowHandle;')
1446 cd_body.append('#elif defined(PLATFORM_LINUX)')
1447 cd_body.append(' XGL_WSI_X11_CONNECTION_INFO m_WsiConnection;')
1448 cd_body.append(' xcb_screen_t *m_pXcbScreen;')
1449 cd_body.append(' xcb_window_t m_XcbWindow;')
1450 cd_body.append('#endif')
1451 cd_body.append(' unsigned int m_windowWidth;')
1452 cd_body.append(' unsigned int m_windowHeight;')
1453 cd_body.append('#if 0')
1454 cd_body.append(' XGL_DEVICE m_dev[XGL_MAX_PHYSICAL_GPUS];')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1455 cd_body.append(' uint32_t m_gpuCount;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1456 cd_body.append(' unsigned int m_gpuIdx;')
1457 cd_body.append(' XGL_PHYSICAL_GPU m_gpus[XGL_MAX_PHYSICAL_GPUS];')
1458 cd_body.append(' XGL_PHYSICAL_GPU_PROPERTIES m_gpuProps[XGL_MAX_PHYSICAL_GPUS];')
1459 cd_body.append('#endif')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1460 cd_body.append(' std::vector<char *>m_extensions;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1461 cd_body.append('};\n')
1462 cd_body.append('typedef struct _XGLAllocInfo {')
1463 cd_body.append(' XGL_GPU_SIZE size;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1464 cd_body.append(' void *pData;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1465 cd_body.append('} XGLAllocInfo;')
1466 return "\n".join(cd_body)
1467
1468 def _generate_replay_func_ptrs(self):
1469 xf_body = []
1470 xf_body.append('struct xglFuncs {')
1471 xf_body.append(' void init_funcs(void * libHandle);')
1472 xf_body.append(' void *m_libHandle;\n')
1473 for proto in self.protos:
1474 xf_body.append(' typedef %s( XGLAPI * type_xgl%s)(' % (proto.ret, proto.name))
1475 for p in proto.params:
1476 if '[4]' in p.ty:
1477 xf_body.append(' %s %s[4],' % (p.ty.strip('[4]'), p.name))
1478 else:
1479 xf_body.append(' %s %s,' % (p.ty, p.name))
1480 xf_body[-1] = xf_body[-1].replace(',', ');')
1481 xf_body.append(' type_xgl%s real_xgl%s;' % (proto.name, proto.name))
1482 xf_body.append('};')
1483 return "\n".join(xf_body)
1484
1485 def _map_decl(self, type1, type2, name):
1486 return ' std::map<%s, %s> %s;' % (type1, type2, name)
1487
1488 def _add_to_map_decl(self, type1, type2, name):
1489 txt = ' void add_to_map(%s* pTraceVal, %s* pReplayVal)\n {\n' % (type1, type2)
1490 txt += ' assert(pTraceVal != NULL);\n'
1491 txt += ' assert(pReplayVal != NULL);\n'
1492 txt += ' %s[*pTraceVal] = *pReplayVal;\n }' % name
1493 return txt
1494
1495 def _rm_from_map_decl(self, ty, name):
1496 txt = ' void rm_from_map(const %s& key)\n {\n' % (ty)
1497 txt += ' %s.erase(key);\n }' % name
1498 return txt
1499
1500 def _remap_decl(self, ty, name):
1501 txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)
1502 txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)
1503 txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }' % name
1504 return txt
1505
1506 def _generate_replay_class(self):
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1507# obj_map_dict = {'m_gpus': 'XGL_PHYSICAL_GPU',
1508# 'm_devices': 'XGL_DEVICE',
1509# 'm_queues': 'XGL_QUEUE',
1510# 'm_memories': 'XGL_GPU_MEMORY',
1511# 'm_images': 'XGL_IMAGE',
1512# 'm_imageViews': 'XGL_IMAGE_VIEW',
1513# 'm_colorTargetViews': 'XGL_COLOR_ATTACHMENT_VIEW',
1514# 'm_depthStencilViews': 'XGL_DEPTH_STENCIL_VIEW',
1515# 'm_shader': 'XGL_SHADER',
1516# 'm_pipeline': 'XGL_PIPELINE',
1517# 'm_pipelineDelta': 'XGL_PIPELINE_DELTA',
1518# 'm_sampler': 'XGL_SAMPLER',
1519# 'm_descriptorSets': 'XGL_DESCRIPTOR_SET',
1520# 'm_viewportStates': 'XGL_DYNAMIC_VP_STATE_OBJECT',
1521# 'm_rasterStates': 'XGL_DYNAMIC_RS_STATE_OBJECT',
1522# 'm_colorBlendStates': 'XGL_DYNAMIC_CB_STATE_OBJECT',
1523# 'm_depthStencilStates': 'XGL_DYNAMIC_DS_STATE_OBJECT',
1524# 'm_cmdBuffers': 'XGL_CMD_BUFFER',
1525# 'm_fences': 'XGL_FENCE',
1526# 'm_queue_semaphores': 'XGL_QUEUE_SEMAPHORE',
1527# 'm_events': 'XGL_EVENT',
1528# 'm_queryPools': 'XGL_QUERY_POOL',
1529# }
1530 # Create dict mapping member var names to XGL type (i.e. 'm_imageViews' : 'XGL_IMAGE_VIEW')
1531 obj_map_dict = {}
1532 for ty in xgl.object_type_list:
1533 if ty in xgl.object_parent_list:
1534 continue
1535 mem_var = ty.replace('XGL_', '').lower()
1536 mem_var_list = mem_var.split('_')
1537# mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([x.title() for x in mem_var_list[1:]])
1538 mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))
1539 obj_map_dict[mem_var] = ty
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1540 rc_body = []
1541 rc_body.append('class xglReplay : public ApiReplay {')
1542 rc_body.append('public:')
1543 rc_body.append(' ~xglReplay();')
Peter Lohrmannbe24ff02015-01-08 19:47:03 -0800[diff] [blame]1544 rc_body.append(' xglReplay();\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1545 rc_body.append(' int init(glv_replay::Display & disp);')
1546 rc_body.append(' xglDisplay * get_display() {return m_display;}')
1547 rc_body.append(' glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);')
1548 rc_body.append(' glv_replay::GLV_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn);\n')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1549 rc_body.append(' void push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg);')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1550 rc_body.append(' glv_replay::GLV_REPLAY_RESULT pop_validation_msgs();')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1551 rc_body.append('private:')
1552 rc_body.append(' struct xglFuncs m_xglFuncs;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1553 rc_body.append(' xglDisplay *m_display;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1554 rc_body.append(' struct shaderPair {')
1555 rc_body.append(' XGL_SHADER *addr;')
1556 rc_body.append(' XGL_SHADER val;')
1557 rc_body.append(' };')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1558 rc_body.append(' struct validationMsg {')
1559 rc_body.append(' XGL_VALIDATION_LEVEL validationLevel;')
1560 rc_body.append(' XGL_BASE_OBJECT srcObject;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1561 rc_body.append(' size_t location;')
1562 rc_body.append(' int32_t msgCode;')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1563 rc_body.append(' char msg[256];')
1564 rc_body.append(' };')
1565 rc_body.append(' std::vector<struct validationMsg> m_validationMsgs;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1566 rc_body.append(self._map_decl('XGL_GPU_MEMORY', 'XGLAllocInfo', 'm_mapData'))
1567 # Custom code for 1-off memory mapping functions
1568 rc_body.append(' void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)')
1569 rc_body.append(' {')
1570 rc_body.append(' XGLAllocInfo info;')
1571 rc_body.append(' info.pData = NULL;')
1572 rc_body.append(' info.size = size;')
1573 rc_body.append(' m_mapData.insert(std::pair<XGL_GPU_MEMORY, XGLAllocInfo>(handle, info));')
1574 rc_body.append(' }')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1575 rc_body.append(' void add_mapping_to_mapData(XGL_GPU_MEMORY handle, void *pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1576 rc_body.append(' {')
1577 rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
1578 rc_body.append(' if (it == m_mapData.end())')
1579 rc_body.append(' {')
1580 rc_body.append(' glv_LogWarn("add_mapping_to_mapData() could not find entry\\n");')
1581 rc_body.append(' return;')
1582 rc_body.append(' }')
1583 rc_body.append(' XGLAllocInfo &info = it->second;')
1584 rc_body.append(' if (info.pData != NULL)')
1585 rc_body.append(' {')
1586 rc_body.append(' glv_LogWarn("add_mapping_to_mapData() data already mapped overwrite old mapping\\n");')
1587 rc_body.append(' }')
1588 rc_body.append(' info.pData = pData;')
1589 rc_body.append(' }')
1590 rc_body.append(' void rm_entry_from_mapData(XGL_GPU_MEMORY handle)')
1591 rc_body.append(' {')
1592 rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
1593 rc_body.append(' if (it == m_mapData.end())')
1594 rc_body.append(' return;')
1595 rc_body.append(' m_mapData.erase(it);')
1596 rc_body.append(' }')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1597 rc_body.append(' void rm_mapping_from_mapData(XGL_GPU_MEMORY handle, void* pData)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1598 rc_body.append(' {')
1599 rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')
1600 rc_body.append(' if (it == m_mapData.end())')
1601 rc_body.append(' return;\n')
1602 rc_body.append(' XGLAllocInfo &info = it->second;')
1603 rc_body.append(' if (!pData || !info.pData)')
1604 rc_body.append(' {')
1605 rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null src or dest pointers\\n");')
1606 rc_body.append(' info.pData = NULL;')
1607 rc_body.append(' return;')
1608 rc_body.append(' }')
1609 rc_body.append(' memcpy(info.pData, pData, info.size);')
1610 rc_body.append(' info.pData = NULL;')
1611 rc_body.append(' }\n')
1612 rc_body.append(' /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;')
1613 rc_body.append(' void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)')
1614 rc_body.append(' {')
1615 rc_body.append(' assert(pTraceGpu != NULL);')
1616 rc_body.append(' assert(pReplayGpu != NULL);')
1617 rc_body.append(' m_gpus[*pTraceGpu] = *pReplayGpu;')
1618 rc_body.append(' }\n')
1619 rc_body.append(' XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)')
1620 rc_body.append(' {')
1621 rc_body.append(' std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);')
1622 rc_body.append(' return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;')
1623 rc_body.append(' }*/\n')
1624 rc_body.append(' void clear_all_map_handles()\n {')
1625 for var in sorted(obj_map_dict):
1626 rc_body.append(' %s.clear();' % var)
1627 rc_body.append(' }')
1628 for var in sorted(obj_map_dict):
1629 rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))
1630 rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))
1631 rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))
1632 rc_body.append(self._remap_decl(obj_map_dict[var], var))
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1633 # XGL_DYNAMIC_STATE_OBJECT code
1634 state_obj_remap_types = xgl.object_dynamic_state_list
1635 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
1636 rc_body.append(' XGL_DYNAMIC_STATE_OBJECT obj;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1637 for t in state_obj_remap_types:
1638 rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != XGL_NULL_HANDLE)' % t)
1639 rc_body.append(' return obj;')
1640 rc_body.append(' return XGL_NULL_HANDLE;\n }')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1641 rc_body.append(' void rm_from_map(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1642 for t in state_obj_remap_types:
1643 rc_body.append(' rm_from_map(static_cast <%s> (state));' % t)
1644 rc_body.append(' }')
1645 # OBJECT code
1646 rc_body.append(' XGL_OBJECT remap(const XGL_OBJECT& object)\n {')
1647 rc_body.append(' XGL_OBJECT obj;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1648 obj_remap_types = xgl.object_list
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1649 for var in obj_remap_types:
1650 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % (var))
1651 rc_body.append(' return obj;')
1652 rc_body.append(' return XGL_NULL_HANDLE;\n }')
1653 rc_body.append(' void rm_from_map(const XGL_OBJECT & objKey)\n {')
1654 for var in obj_remap_types:
1655 rc_body.append(' rm_from_map(static_cast <%s> (objKey));' % (var))
1656 rc_body.append(' }')
1657 rc_body.append(' XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)\n {')
1658 rc_body.append(' XGL_BASE_OBJECT obj;')
1659 base_obj_remap_types = ['XGL_DEVICE', 'XGL_QUEUE', 'XGL_GPU_MEMORY', 'XGL_OBJECT']
1660 for t in base_obj_remap_types:
1661 rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % t)
1662 rc_body.append(' return obj;')
1663 rc_body.append(' return XGL_NULL_HANDLE;\n }')
1664 rc_body.append('};')
1665 return "\n".join(rc_body)
1666
1667 def _generate_replay_display_init_xgl(self):
1668 dix_body = []
1669 dix_body.append('XGL_RESULT xglDisplay::init_xgl(unsigned int gpu_idx)')
1670 dix_body.append('{')
1671 dix_body.append('#if 0')
1672 dix_body.append(' XGL_APPLICATION_INFO appInfo = {};')
1673 dix_body.append(' appInfo.pAppName = APP_NAME;')
1674 dix_body.append(' appInfo.pEngineName = "";')
1675 dix_body.append(' appInfo.apiVersion = XGL_API_VERSION;')
1676 dix_body.append(' XGL_RESULT res = xglInitAndEnumerateGpus(&appInfo, NULL, XGL_MAX_PHYSICAL_GPUS, &m_gpuCount, m_gpus);')
1677 dix_body.append(' if ( res == XGL_SUCCESS ) {')
1678 dix_body.append(' // retrieve the GPU information for all GPUs')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1679 dix_body.append(' for( uint32_t gpu = 0; gpu < m_gpuCount; gpu++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1680 dix_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1681 dix_body.append(' size_t gpuInfoSize = sizeof(m_gpuProps[0]);\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1682 dix_body.append(' // get the GPU physical properties:')
1683 dix_body.append(' res = xglGetGpuInfo( m_gpus[gpu], XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &gpuInfoSize, &m_gpuProps[gpu]);')
1684 dix_body.append(' if (res != XGL_SUCCESS)')
1685 dix_body.append(' glv_LogWarn("Failed to retrieve properties for gpu[%d] result %d\\n", gpu, res);')
1686 dix_body.append(' }')
1687 dix_body.append(' res = XGL_SUCCESS;')
1688 dix_body.append(' } else if ((gpu_idx + 1) > m_gpuCount) {')
1689 dix_body.append(' glv_LogError("xglInitAndEnumerate number of gpus does not include requested index: num %d, requested %d\\n", m_gpuCount, gpu_idx);')
1690 dix_body.append(' return -1;')
1691 dix_body.append(' } else {')
1692 dix_body.append(' glv_LogError("xglInitAndEnumerate failed\\n");')
1693 dix_body.append(' return res;')
1694 dix_body.append(' }')
1695 dix_body.append(' // TODO add multi-gpu support always use gpu[gpu_idx] for now')
1696 dix_body.append(' // get all extensions supported by this device gpu[gpu_idx]')
1697 dix_body.append(' // first check if extensions are available and save a list of them')
1698 dix_body.append(' bool foundWSIExt = false;')
1699 dix_body.append(' for( int ext = 0; ext < sizeof( extensions ) / sizeof( extensions[0] ); ext++)')
1700 dix_body.append(' {')
1701 dix_body.append(' res = xglGetExtensionSupport( m_gpus[gpu_idx], extensions[ext] );')
1702 dix_body.append(' if (res == XGL_SUCCESS) {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1703 dix_body.append(' m_extensions.push_back((char *) extensions[ext]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1704 dix_body.append(' if (!strcmp(extensions[ext], "XGL_WSI_WINDOWS"))')
1705 dix_body.append(' foundWSIExt = true;')
1706 dix_body.append(' }')
1707 dix_body.append(' }')
1708 dix_body.append(' if (!foundWSIExt) {')
1709 dix_body.append(' glv_LogError("XGL_WSI_WINDOWS extension not supported by gpu[%d]\\n", gpu_idx);')
1710 dix_body.append(' return XGL_ERROR_INCOMPATIBLE_DEVICE;')
1711 dix_body.append(' }')
1712 dix_body.append(' // TODO generalize this: use one universal queue for now')
1713 dix_body.append(' XGL_DEVICE_QUEUE_CREATE_INFO dqci = {};')
1714 dix_body.append(' dqci.queueCount = 1;')
1715 dix_body.append(' dqci.queueType = XGL_QUEUE_UNIVERSAL;')
1716 dix_body.append(' // create the device enabling validation level 4')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1717 dix_body.append(' const char * const * extNames = &m_extensions[0];')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1718 dix_body.append(' XGL_DEVICE_CREATE_INFO info = {};')
1719 dix_body.append(' info.queueRecordCount = 1;')
1720 dix_body.append(' info.pRequestedQueues = &dqci;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1721 dix_body.append(' info.extensionCount = static_cast <uint32_t> (m_extensions.size());')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1722 dix_body.append(' info.ppEnabledExtensionNames = extNames;')
1723 dix_body.append(' info.flags = XGL_DEVICE_CREATE_VALIDATION;')
1724 dix_body.append(' info.maxValidationLevel = XGL_VALIDATION_LEVEL_4;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1725 dix_body.append(' bool32_t xglTrue = XGL_TRUE;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1726 dix_body.append(' res = xglDbgSetGlobalOption( XGL_DBG_OPTION_BREAK_ON_ERROR, sizeof( xglTrue ), &xglTrue );')
1727 dix_body.append(' if (res != XGL_SUCCESS)')
1728 dix_body.append(' glv_LogWarn("Could not set debug option break on error\\n");')
1729 dix_body.append(' res = xglCreateDevice( m_gpus[0], &info, &m_dev[gpu_idx]);')
1730 dix_body.append(' return res;')
1731 dix_body.append('#else')
1732 dix_body.append(' return XGL_ERROR_INITIALIZATION_FAILED;')
1733 dix_body.append('#endif')
1734 dix_body.append('}')
1735 return "\n".join(dix_body)
1736
1737 def _generate_replay_display_init(self):
1738 di_body = []
1739 di_body.append('int xglDisplay::init(const unsigned int gpu_idx)')
1740 di_body.append('{')
1741 di_body.append(' //m_gpuIdx = gpu_idx;')
1742 di_body.append('#if 0')
1743 di_body.append(' XGL_RESULT result = init_xgl(gpu_idx);')
1744 di_body.append(' if (result != XGL_SUCCESS) {')
1745 di_body.append(' glv_LogError("could not init xgl library");')
1746 di_body.append(' return -1;')
1747 di_body.append(' } else {')
1748 di_body.append(' m_initedXGL = true;')
1749 di_body.append(' }')
1750 di_body.append('#endif')
1751 di_body.append('#if defined(PLATFORM_LINUX)')
1752 di_body.append(' const xcb_setup_t *setup;')
1753 di_body.append(' xcb_screen_iterator_t iter;')
1754 di_body.append(' int scr;')
1755 di_body.append(' xcb_connection_t *pConnection;')
1756 di_body.append(' pConnection = xcb_connect(NULL, &scr);')
1757 di_body.append(' setup = xcb_get_setup(pConnection);')
1758 di_body.append(' iter = xcb_setup_roots_iterator(setup);')
1759 di_body.append(' while (scr-- > 0)')
1760 di_body.append(' xcb_screen_next(&iter);')
1761 di_body.append(' m_pXcbScreen = iter.data;')
1762 di_body.append(' m_WsiConnection.pConnection = pConnection;')
1763 di_body.append(' m_WsiConnection.root = m_pXcbScreen->root;')
1764 di_body.append('#endif')
1765 di_body.append(' return 0;')
1766 di_body.append('}')
1767 return "\n".join(di_body)
1768
1769 def _generate_replay_display_structors(self):
1770 ds_body = []
1771 ds_body.append('xglDisplay::xglDisplay()')
1772 ds_body.append(' : m_initedXGL(false),')
1773 ds_body.append(' m_windowWidth(0),')
1774 ds_body.append(' m_windowHeight(0)')
1775 ds_body.append('{')
1776 ds_body.append('#if defined(WIN32)')
1777 ds_body.append(' m_windowHandle = NULL;')
1778 ds_body.append('#elif defined(PLATFORM_LINUX)')
1779 ds_body.append(' m_WsiConnection.pConnection = NULL;')
1780 ds_body.append(' m_WsiConnection.root = 0;')
1781 ds_body.append(' m_WsiConnection.provider = 0;')
1782 ds_body.append(' m_pXcbScreen = NULL;')
1783 ds_body.append(' m_XcbWindow = 0;')
1784 ds_body.append('#endif')
1785 ds_body.append('}')
1786 ds_body.append('xglDisplay::~xglDisplay()')
1787 ds_body.append('{')
1788 ds_body.append('#ifdef PLATFORM_LINUX')
1789 ds_body.append(' if (m_XcbWindow != 0)')
1790 ds_body.append(' {')
1791 ds_body.append(' xcb_destroy_window(m_WsiConnection.pConnection, m_XcbWindow);')
1792 ds_body.append(' }')
1793 ds_body.append(' if (m_WsiConnection.pConnection != NULL)')
1794 ds_body.append(' {')
1795 ds_body.append(' xcb_disconnect(m_WsiConnection.pConnection);')
1796 ds_body.append(' }')
1797 ds_body.append('#endif')
1798 ds_body.append('}')
1799 return "\n".join(ds_body)
1800
1801 def _generate_replay_display_window(self):
1802 dw_body = []
1803 dw_body.append('#if defined(WIN32)')
1804 dw_body.append('LRESULT WINAPI WindowProcXgl( HWND window, unsigned int msg, WPARAM wp, LPARAM lp)')
1805 dw_body.append('{')
1806 dw_body.append(' switch(msg)')
1807 dw_body.append(' {')
1808 dw_body.append(' case WM_CLOSE:')
1809 dw_body.append(' DestroyWindow( window);')
1810 dw_body.append(' // fall-thru')
1811 dw_body.append(' case WM_DESTROY:')
1812 dw_body.append(' PostQuitMessage(0) ;')
1813 dw_body.append(' return 0L ;')
1814 dw_body.append(' default:')
1815 dw_body.append(' return DefWindowProc( window, msg, wp, lp ) ;')
1816 dw_body.append(' }')
1817 dw_body.append('}')
1818 dw_body.append('#endif')
1819 dw_body.append('int xglDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)')
1820 dw_body.append('{')
1821 dw_body.append('#if defined(WIN32)')
1822 dw_body.append(' m_windowHandle = hWindow;')
1823 dw_body.append('#elif defined(PLATFORM_LINUX)')
1824 dw_body.append(' m_XcbWindow = hWindow;')
1825 dw_body.append('#endif')
1826 dw_body.append(' m_windowWidth = width;')
1827 dw_body.append(' m_windowHeight = height;')
1828 dw_body.append(' return 0;')
1829 dw_body.append('}\n')
1830 dw_body.append('int xglDisplay::create_window(const unsigned int width, const unsigned int height)')
1831 dw_body.append('{')
1832 dw_body.append('#if defined(WIN32)')
1833 dw_body.append(' // Register Window class')
1834 dw_body.append(' WNDCLASSEX wcex = {};')
1835 dw_body.append(' wcex.cbSize = sizeof( WNDCLASSEX);')
1836 dw_body.append(' wcex.style = CS_HREDRAW | CS_VREDRAW;')
1837 dw_body.append(' wcex.lpfnWndProc = WindowProcXgl;')
1838 dw_body.append(' wcex.cbClsExtra = 0;')
1839 dw_body.append(' wcex.cbWndExtra = 0;')
1840 dw_body.append(' wcex.hInstance = GetModuleHandle(0);')
1841 dw_body.append(' wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')
1842 dw_body.append(' wcex.hCursor = LoadCursor( NULL, IDC_ARROW);')
1843 dw_body.append(' wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1);')
1844 dw_body.append(' wcex.lpszMenuName = NULL;')
1845 dw_body.append(' wcex.lpszClassName = APP_NAME;')
1846 dw_body.append(' wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')
1847 dw_body.append(' if( !RegisterClassEx( &wcex))')
1848 dw_body.append(' {')
1849 dw_body.append(' glv_LogError("Failed to register windows class\\n");')
1850 dw_body.append(' return -1;')
1851 dw_body.append(' }\n')
1852 dw_body.append(' // create the window')
1853 dw_body.append(' m_windowHandle = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 0, 0,')
1854 dw_body.append(' width, height, NULL, NULL, wcex.hInstance, NULL);\n')
1855 dw_body.append(' if (m_windowHandle)')
1856 dw_body.append(' {')
1857 dw_body.append(' ShowWindow( m_windowHandle, SW_SHOWDEFAULT);')
1858 dw_body.append(' m_windowWidth = width;')
1859 dw_body.append(' m_windowHeight = height;')
1860 dw_body.append(' } else {')
1861 dw_body.append(' glv_LogError("Failed to create window\\n");')
1862 dw_body.append(' return -1;')
1863 dw_body.append(' }')
1864 dw_body.append(' return 0;')
1865 dw_body.append('#elif defined(PLATFORM_LINUX)\n')
1866 dw_body.append(' uint32_t value_mask, value_list[32];')
1867 dw_body.append(' m_XcbWindow = xcb_generate_id(m_WsiConnection.pConnection);\n')
1868 dw_body.append(' value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;')
1869 dw_body.append(' value_list[0] = m_pXcbScreen->black_pixel;')
1870 dw_body.append(' value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |')
1871 dw_body.append(' XCB_EVENT_MASK_EXPOSURE;\n')
1872 dw_body.append(' xcb_create_window(m_WsiConnection.pConnection,')
1873 dw_body.append(' XCB_COPY_FROM_PARENT,')
1874 dw_body.append(' m_XcbWindow, m_WsiConnection.root,')
1875 dw_body.append(' 0, 0, width, height, 0,')
1876 dw_body.append(' XCB_WINDOW_CLASS_INPUT_OUTPUT,')
1877 dw_body.append(' m_pXcbScreen->root_visual,')
1878 dw_body.append(' value_mask, value_list);\n')
1879 dw_body.append(' xcb_map_window(m_WsiConnection.pConnection, m_XcbWindow);')
1880 dw_body.append(' xcb_flush(m_WsiConnection.pConnection);')
1881 dw_body.append(' return 0;')
1882 dw_body.append('#endif')
1883 dw_body.append('}\n')
1884 dw_body.append('void xglDisplay::resize_window(const unsigned int width, const unsigned int height)')
1885 dw_body.append('{')
1886 dw_body.append('#if defined(WIN32)')
1887 dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')
1888 dw_body.append(' {')
1889 dw_body.append(' SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, width, height, SWP_NOMOVE);')
1890 dw_body.append(' m_windowWidth = width;')
1891 dw_body.append(' m_windowHeight = height;')
1892 dw_body.append(' }')
1893 dw_body.append('#elif defined(PLATFORM_LINUX)')
1894 dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')
1895 dw_body.append(' {')
1896 dw_body.append(' uint32_t values[2];')
1897 dw_body.append(' values[0] = width;')
1898 dw_body.append(' values[1] = height;')
1899 dw_body.append(' xcb_configure_window(m_WsiConnection.pConnection, m_XcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);')
1900 dw_body.append(' m_windowWidth = width;')
1901 dw_body.append(' m_windowHeight = height;')
1902 dw_body.append(' }')
1903 dw_body.append('#endif')
1904 dw_body.append('}\n')
1905 dw_body.append('void xglDisplay::process_event()')
1906 dw_body.append('{')
1907 dw_body.append('}')
1908 return "\n".join(dw_body)
1909
1910 def _generate_replay_structors(self):
1911 rs_body = []
Peter Lohrmannbe24ff02015-01-08 19:47:03 -0800[diff] [blame]1912 rs_body.append('xglReplay::xglReplay()')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1913 rs_body.append('{')
1914 rs_body.append(' m_display = new xglDisplay();')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1915 rs_body.append('}\n')
1916 rs_body.append('xglReplay::~xglReplay()')
1917 rs_body.append('{')
1918 rs_body.append(' delete m_display;')
1919 rs_body.append(' glv_platform_close_library(m_xglFuncs.m_libHandle);')
1920 rs_body.append('}')
1921 return "\n".join(rs_body)
1922
1923 def _generate_replay_init(self):
1924 ri_body = []
1925 ri_body.append('int xglReplay::init(glv_replay::Display & disp)')
1926 ri_body.append('{')
1927 ri_body.append(' int err;')
1928 ri_body.append('#if defined _WIN64')
1929 ri_body.append(' HMODULE handle = LoadLibrary("xgl64.dll" );')
1930 ri_body.append('#elif defined _WIN32')
1931 ri_body.append(' HMODULE handle = LoadLibrary("xgl32.dll" );')
1932 ri_body.append('#elif defined PLATFORM_LINUX')
1933 ri_body.append(' void * handle = dlopen("libXGL.so", RTLD_LAZY);')
1934 ri_body.append('#endif\n')
1935 ri_body.append(' if (handle == NULL) {')
1936 ri_body.append(' glv_LogError("Failed to open xgl library.\\n");')
1937 ri_body.append(' return -1;')
1938 ri_body.append(' }')
1939 ri_body.append(' m_xglFuncs.init_funcs(handle);')
1940 ri_body.append(' disp.set_implementation(m_display);')
1941 ri_body.append(' if ((err = m_display->init(disp.get_gpu())) != 0) {')
1942 ri_body.append(' glv_LogError("Failed to init XGL display.\\n");')
1943 ri_body.append(' return err;')
1944 ri_body.append(' }')
1945 ri_body.append(' if (disp.get_window_handle() == 0)')
1946 ri_body.append(' {')
1947 ri_body.append(' if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {')
1948 ri_body.append(' glv_LogError("Failed to create Window\\n");')
1949 ri_body.append(' return err;')
1950 ri_body.append(' }')
1951 ri_body.append(' }')
1952 ri_body.append(' else')
1953 ri_body.append(' {')
1954 ri_body.append(' if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)')
1955 ri_body.append(' {')
1956 ri_body.append(' glv_LogError("Failed to set Window\\n");')
1957 ri_body.append(' return err;')
1958 ri_body.append(' }')
1959 ri_body.append(' }')
1960 ri_body.append(' return 0;')
1961 ri_body.append('}')
1962 return "\n".join(ri_body)
1963
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1964 def _generate_replay_errors(self):
1965 re_body = []
1966 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)')
1967 re_body.append('{')
1968 re_body.append(' glv_replay::GLV_REPLAY_RESULT res = resIn;')
1969 re_body.append(' if (resCall != resTrace) {')
1970 re_body.append(' glv_LogWarn("Mismatched return from API call (%s) traced result %s, replay result %s\\n", entrypointName,')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]1971 re_body.append(' string_XGL_RESULT((XGL_RESULT)resTrace), string_XGL_RESULT((XGL_RESULT)resCall));')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]1972 re_body.append(' res = glv_replay::GLV_REPLAY_BAD_RETURN;')
1973 re_body.append(' }')
1974 re_body.append('#if 0')
1975 re_body.append(' if (resCall != XGL_SUCCESS) {')
1976 re_body.append(' glv_LogWarn("API call (%s) returned failed result %s\\n", entrypointName, string_XGL_RESULT(resCall));')
1977 re_body.append(' }')
1978 re_body.append('#endif')
1979 re_body.append(' return res;')
1980 re_body.append('}')
1981 return "\n".join(re_body)
1982
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1983 def _generate_replay_validation_funcs(self):
1984 rvf_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1985 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 Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]1986 rvf_body.append('{')
1987 rvf_body.append(' struct validationMsg msgObj;')
1988 rvf_body.append(' msgObj.validationLevel = validationLevel;')
1989 rvf_body.append(' msgObj.srcObject = srcObject;')
1990 rvf_body.append(' msgObj.location = location;')
1991 rvf_body.append(' msgObj.msgCode = msgCode;')
1992 rvf_body.append(' strncpy(msgObj.msg, pMsg, 256);')
1993 rvf_body.append(" msgObj.msg[255] = '\\0';")
1994 rvf_body.append(' m_validationMsgs.push_back(msgObj);')
1995 rvf_body.append('}\n')
1996 rvf_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::pop_validation_msgs()')
1997 rvf_body.append('{')
1998 rvf_body.append(' if (m_validationMsgs.size() == 0)')
1999 rvf_body.append(' return glv_replay::GLV_REPLAY_SUCCESS;')
2000 rvf_body.append(' m_validationMsgs.clear();')
2001 rvf_body.append(' return glv_replay::GLV_REPLAY_VALIDATION_ERROR;')
2002 rvf_body.append('}')
2003 return "\n".join(rvf_body)
2004
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2005 def _generate_replay_init_funcs(self):
2006 rif_body = []
2007 rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')
2008 for proto in self.protos:
2009 rif_body.append(' real_xgl%s = (type_xgl%s)(glv_platform_get_library_entrypoint(handle, "xgl%s"));' % (proto.name, proto.name, proto.name))
2010 rif_body.append('}')
2011 return "\n".join(rif_body)
2012
2013 def _get_packet_param(self, t, n):
2014 # list of types that require remapping
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2015 remap_list = xgl.object_type_list
2016#[
2017# 'XGL_PHYSICAL_GPU',
2018# 'XGL_DEVICE',
2019# 'XGL_QUEUE',
2020# 'XGL_GPU_MEMORY',
2021# 'XGL_IMAGE',
2022# 'XGL_IMAGE_VIEW',
2023# 'XGL_COLOR_ATTACHMENT_VIEW',
2024# 'XGL_DEPTH_STENCIL_VIEW',
2025# 'XGL_SHADER',
2026# 'XGL_PIPELINE',
2027# 'XGL_PIPELINE_DELTA',
2028# 'XGL_SAMPLER',
2029# 'XGL_DESCRIPTOR_SET',
2030# 'XGL_VIEWPORT_STATE_OBJECT',
2031# 'XGL_RASTER_STATE_OBJECT',
2032# 'XGL_MSAA_STATE_OBJECT',
2033# 'XGL_COLOR_BLEND_STATE_OBJECT',
2034# 'XGL_DEPTH_STENCIL_STATE_OBJECT',
2035# 'XGL_CMD_BUFFER',
2036# 'XGL_FENCE',
2037# 'XGL_QUEUE_SEMAPHORE',
2038# 'XGL_EVENT',
2039# 'XGL_QUERY_POOL',
2040# 'XGL_STATE_OBJECT',
2041# 'XGL_BASE_OBJECT',
2042# 'XGL_OBJECT',
2043# ]
2044 param_exclude_list = ['p1', 'p2', 'pGpus', 'pDescriptorSets']
2045 if t.strip('*').replace('const ', '') in remap_list and n not in param_exclude_list:
2046 if '*' in t:
2047 if 'const ' not in t:
2048 return 'remap(*pPacket->%s)' % (n)
2049 else: # TODO : Don't remap array ptrs?
2050 return 'pPacket->%s' % (n)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2051 return 'remap(pPacket->%s)' % (n)
2052 return 'pPacket->%s' % (n)
2053
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]2054 def _gen_replay_enum_gpus(self):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2055 ieg_body = []
2056 ieg_body.append(' if (!m_display->m_initedXGL)')
2057 ieg_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2058 ieg_body.append(' uint32_t gpuCount;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2059 ieg_body.append(' XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2060 ieg_body.append(' uint32_t maxGpus = (pPacket->maxGpus < XGL_MAX_PHYSICAL_GPUS) ? pPacket->maxGpus : XGL_MAX_PHYSICAL_GPUS;')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]2061 ieg_body.append(' replayResult = m_xglFuncs.real_xglEnumerateGpus(remap(pPacket->instance), maxGpus, &gpuCount, &gpus[0]);')
2062 ieg_body.append(' CHECK_RETURN_VALUE(xglEnumerateGpus);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2063 ieg_body.append(' //TODO handle different number of gpus in trace versus replay')
2064 ieg_body.append(' if (gpuCount != *(pPacket->pGpuCount))')
2065 ieg_body.append(' {')
2066 ieg_body.append(' glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\\n", gpuCount, *(pPacket->pGpuCount));')
2067 ieg_body.append(' }')
2068 ieg_body.append(' else if (gpuCount == 0)')
2069 ieg_body.append(' {')
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]2070 ieg_body.append(' glv_LogError("xglEnumerateGpus number of gpus is zero\\n");')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2071 ieg_body.append(' }')
2072 ieg_body.append(' else')
2073 ieg_body.append(' {')
2074 ieg_body.append(' glv_LogInfo("Enumerated %d GPUs in the system\\n", gpuCount);')
2075 ieg_body.append(' }')
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2076 ieg_body.append(' // Do we care about the instance handle? Need to keep from clearing it? Not sure it will be used again...')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2077 ieg_body.append(' clear_all_map_handles();')
2078 ieg_body.append(' // TODO handle enumeration results in a different order from trace to replay')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2079 ieg_body.append(' for (uint32_t i = 0; i < gpuCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2080 ieg_body.append(' {')
2081 ieg_body.append(' if (pPacket->pGpus)')
2082 ieg_body.append(' add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));')
2083 ieg_body.append(' }')
2084 ieg_body.append(' }')
2085 return "\n".join(ieg_body)
2086
2087 def _gen_replay_get_gpu_info(self):
2088 ggi_body = []
2089 ggi_body.append(' if (!m_display->m_initedXGL)')
2090 ggi_body.append(' {')
2091 ggi_body.append(' switch (pPacket->infoType) {')
2092 ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:')
2093 ggi_body.append(' {')
2094 ggi_body.append(' XGL_PHYSICAL_GPU_PROPERTIES gpuProps;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2095 ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2096 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
2097 ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuProps);')
2098 ggi_body.append(' if (pPacket->pData != NULL)')
2099 ggi_body.append(' {')
2100 ggi_body.append(' glv_LogInfo("Replay Gpu Properties\\n");')
2101 ggi_body.append(' glv_LogInfo("Vendor ID %x, Device ID %x, name %s\\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);')
2102 ggi_body.append(' glv_LogInfo("API version %u, Driver version %u, gpu Type %u\\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);')
2103 ggi_body.append(' }')
2104 ggi_body.append(' break;')
2105 ggi_body.append(' }')
2106 ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:')
2107 ggi_body.append(' {')
2108 ggi_body.append(' XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2109 ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2110 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
2111 ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuPerfs);')
2112 ggi_body.append(' if (pPacket->pData != NULL)')
2113 ggi_body.append(' {')
2114 ggi_body.append(' glv_LogInfo("Replay Gpu Performance\\n");')
2115 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);')
2116 ggi_body.append(' glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);')
2117 ggi_body.append(' }')
2118 ggi_body.append(' break;')
2119 ggi_body.append(' }')
2120 ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:')
2121 ggi_body.append(' {')
2122 ggi_body.append(' XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2123 ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);')
2124 ggi_body.append(' size_t numQueues = 1;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2125 ggi_body.append(' assert(pPacket->pDataSize);')
2126 ggi_body.append(' if ((*(pPacket->pDataSize) % dataSize) != 0)')
2127 ggi_body.append(' glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\\n");')
2128 ggi_body.append(' else')
2129 ggi_body.append(' numQueues = *(pPacket->pDataSize) / dataSize;')
2130 ggi_body.append(' dataSize = numQueues * dataSize;')
2131 ggi_body.append(' pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));')
2132 ggi_body.append(' pGpuQueue = pQ;')
2133 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')
2134 ggi_body.append(' (pPacket->pData == NULL) ? NULL : pGpuQueue);')
2135 ggi_body.append(' if (pPacket->pData != NULL)')
2136 ggi_body.append(' {')
2137 ggi_body.append(' for (unsigned int i = 0; i < numQueues; i++)')
2138 ggi_body.append(' {')
2139 ggi_body.append(' glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\\n", i, pGpuQueue->queueFlags);')
2140 ggi_body.append(' glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);')
2141 ggi_body.append(' pGpuQueue++;')
2142 ggi_body.append(' }')
2143 ggi_body.append(' }')
2144 ggi_body.append(' glv_free(pQ);')
2145 ggi_body.append(' break;')
2146 ggi_body.append(' }')
2147 ggi_body.append(' default:')
2148 ggi_body.append(' {')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2149 ggi_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2150 ggi_body.append(' void* pData = NULL;')
2151 ggi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2152 ggi_body.append(' {')
2153 ggi_body.append(' size = *pPacket->pDataSize;')
2154 ggi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2155 ggi_body.append(' }')
2156 ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &size, pData);')
2157 ggi_body.append(' if (replayResult == XGL_SUCCESS)')
2158 ggi_body.append(' {')
2159 ggi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')
2160 ggi_body.append(' {')
2161 ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2162 ggi_body.append(' }')
2163 ggi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2164 ggi_body.append(' {')
2165 ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\\n");')
2166 ggi_body.append(' }')
2167 ggi_body.append(' }')
2168 ggi_body.append(' glv_free(pData);')
2169 ggi_body.append(' break;')
2170 ggi_body.append(' }')
2171 ggi_body.append(' };')
2172 ggi_body.append(' CHECK_RETURN_VALUE(xglGetGpuInfo);')
2173 ggi_body.append(' }')
2174 return "\n".join(ggi_body)
2175
2176 def _gen_replay_create_device(self):
2177 cd_body = []
2178 cd_body.append(' if (!m_display->m_initedXGL)')
2179 cd_body.append(' {')
2180 cd_body.append(' XGL_DEVICE device;')
Peter Lohrmannbe24ff02015-01-08 19:47:03 -0800[diff] [blame]2181 cd_body.append(' if (g_xglReplaySettings.debugLevel > 0)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2182 cd_body.append(' {')
Jon Ashburn6cad43c2014-12-19 12:31:19 -0700[diff] [blame]2183 cd_body.append(' XGL_DEVICE_CREATE_INFO cInfo, *ci, *pCreateInfoSaved;')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2184 cd_body.append(' // TODO what is the real list of layers to be running with??')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2185# cd_body.append(' const char * layersStr[2] = {(char *) "DrawState", (char *) "ObjectTracker"};')
Peter Lohrmannd4451052015-01-09 12:34:50 -0800[diff] [blame]2186
2187 cd_body.append(' unsigned int numLayers = 0;')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2188 cd_body.append(' char ** layersStr = get_enableLayers_list(&numLayers);')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2189 cd_body.append(' XGL_LAYER_CREATE_INFO layerInfo;')
Jon Ashburn6cad43c2014-12-19 12:31:19 -0700[diff] [blame]2190 cd_body.append(' pCreateInfoSaved = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2191 cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')
Peter Lohrmannd4451052015-01-09 12:34:50 -0800[diff] [blame]2192
2193 cd_body.append(' if (layersStr != NULL && numLayers > 0)')
2194 cd_body.append(' {')
2195 cd_body.append(' while (ci->pNext != NULL)')
2196 cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) ci->pNext;')
2197 cd_body.append(' ci->pNext = &layerInfo;')
2198 cd_body.append(' layerInfo.sType = XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO;')
2199 cd_body.append(' layerInfo.pNext = 0;')
2200 cd_body.append(' layerInfo.layerCount = numLayers;')
2201 cd_body.append(' layerInfo.ppActiveLayerNames = layersStr;')
2202 cd_body.append(' }')
2203
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2204 cd_body.append(' memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));')
2205 cd_body.append(' cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2206 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 Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2207 cd_body.append(' pPacket->pCreateInfo = &cInfo;')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2208 cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')
Jon Ashburn6cad43c2014-12-19 12:31:19 -0700[diff] [blame]2209 cd_body.append(' // restore the packet for next replay')
2210 cd_body.append(' ci->pNext = NULL;')
2211 cd_body.append(' pPacket->pCreateInfo = pCreateInfoSaved;')
Peter Lohrmannd4451052015-01-09 12:34:50 -0800[diff] [blame]2212 cd_body.append(' release_enableLayer_list(layersStr);')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2213 cd_body.append(' if (xglDbgRegisterMsgCallback(g_fpDbgMsgCallback, NULL) != XGL_SUCCESS)')
2214 cd_body.append(' glv_LogError("Failed to register xgl callback for replayer error handling\\n");')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2215 cd_body.append(' }')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]2216 cd_body.append(' else ')
2217 cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2218 cd_body.append(' CHECK_RETURN_VALUE(xglCreateDevice);')
2219 cd_body.append(' if (replayResult == XGL_SUCCESS)')
2220 cd_body.append(' {')
2221 cd_body.append(' add_to_map(pPacket->pDevice, &device);')
2222 cd_body.append(' }')
2223 cd_body.append(' }')
2224 return "\n".join(cd_body)
2225
2226 def _gen_replay_get_extension_support(self):
2227 ges_body = []
2228 ges_body.append(' if (!m_display->m_initedXGL) {')
2229 ges_body.append(' replayResult = m_xglFuncs.real_xglGetExtensionSupport(remap(pPacket->gpu), pPacket->pExtName);')
2230 ges_body.append(' CHECK_RETURN_VALUE(xglGetExtensionSupport);')
2231 ges_body.append(' if (replayResult == XGL_SUCCESS) {')
2232 ges_body.append(' for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)')
2233 ges_body.append(' {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]2234 ges_body.append(' if (!strncmp(g_extensions[ext], pPacket->pExtName, strlen(g_extensions[ext]))) {')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2235 ges_body.append(' bool extInList = false;')
2236 ges_body.append(' for (unsigned int j = 0; j < m_display->m_extensions.size(); ++j) {')
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]2237 ges_body.append(' if (!strncmp(m_display->m_extensions[j], g_extensions[ext], strlen(g_extensions[ext])))')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2238 ges_body.append(' extInList = true;')
2239 ges_body.append(' break;')
2240 ges_body.append(' }')
2241 ges_body.append(' if (!extInList)')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2242 ges_body.append(' m_display->m_extensions.push_back((char *) g_extensions[ext]);')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2243 ges_body.append(' break;')
2244 ges_body.append(' }')
2245 ges_body.append(' }')
2246 ges_body.append(' }')
2247 ges_body.append(' }')
2248 return "\n".join(ges_body)
2249
2250 def _gen_replay_queue_submit(self):
2251 qs_body = []
2252 qs_body.append(' XGL_CMD_BUFFER *remappedBuffers = NULL;')
2253 qs_body.append(' if (pPacket->pCmdBuffers != NULL)')
2254 qs_body.append(' {')
2255 qs_body.append(' remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2256 qs_body.append(' for (uint32_t i = 0; i < pPacket->cmdBufferCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2257 qs_body.append(' {')
2258 qs_body.append(' *(remappedBuffers + i) = remap(*(pPacket->pCmdBuffers + i));')
2259 qs_body.append(' }')
2260 qs_body.append(' }')
2261 qs_body.append(' XGL_MEMORY_REF* memRefs = NULL;')
2262 qs_body.append(' if (pPacket->pMemRefs != NULL)')
2263 qs_body.append(' {')
2264 qs_body.append(' memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);')
2265 qs_body.append(' memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2266 qs_body.append(' for (uint32_t i = 0; i < pPacket->memRefCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2267 qs_body.append(' {')
2268 qs_body.append(' memRefs[i].mem = remap(pPacket->pMemRefs[i].mem);')
2269 qs_body.append(' }')
2270 qs_body.append(' }')
2271 qs_body.append(' replayResult = m_xglFuncs.real_xglQueueSubmit(remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,')
2272 qs_body.append(' memRefs, remap(pPacket->fence));')
2273 qs_body.append(' GLV_DELETE(remappedBuffers);')
2274 qs_body.append(' GLV_DELETE(memRefs);')
2275 return "\n".join(qs_body)
2276
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2277 def _gen_replay_get_object_info(self):
2278 goi_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2279 goi_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2280 goi_body.append(' void* pData = NULL;')
2281 goi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2282 goi_body.append(' {')
2283 goi_body.append(' size = *pPacket->pDataSize;')
2284 goi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2285 goi_body.append(' memcpy(pData, pPacket->pData, *pPacket->pDataSize);')
2286 goi_body.append(' }')
2287 goi_body.append(' replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);')
2288 goi_body.append(' if (replayResult == XGL_SUCCESS)')
2289 goi_body.append(' {')
2290 goi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')
2291 goi_body.append(' {')
2292 goi_body.append(' glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2293 goi_body.append(' }')
2294 goi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2295 goi_body.append(' {')
2296 goi_body.append(' glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\\n");')
2297 goi_body.append(' }')
2298 goi_body.append(' }')
2299 goi_body.append(' glv_free(pData);')
2300 return "\n".join(goi_body)
2301
2302 def _gen_replay_get_format_info(self):
2303 gfi_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2304 gfi_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2305 gfi_body.append(' void* pData = NULL;')
2306 gfi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2307 gfi_body.append(' {')
2308 gfi_body.append(' size = *pPacket->pDataSize;')
2309 gfi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2310 gfi_body.append(' }')
2311 gfi_body.append(' replayResult = m_xglFuncs.real_xglGetFormatInfo(remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);')
2312 gfi_body.append(' if (replayResult == XGL_SUCCESS)')
2313 gfi_body.append(' {')
2314 gfi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')
2315 gfi_body.append(' {')
2316 gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2317 gfi_body.append(' }')
2318 gfi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2319 gfi_body.append(' {')
2320 gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\\n");')
2321 gfi_body.append(' }')
2322 gfi_body.append(' }')
2323 gfi_body.append(' glv_free(pData);')
2324 return "\n".join(gfi_body)
2325
2326 def _gen_replay_get_image_subresource_info(self):
2327 isi_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2328 isi_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2329 isi_body.append(' void* pData = NULL;')
2330 isi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2331 isi_body.append(' {')
2332 isi_body.append(' size = *pPacket->pDataSize;')
2333 isi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2334 isi_body.append(' }')
2335 isi_body.append(' replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);')
2336 isi_body.append(' if (replayResult == XGL_SUCCESS)')
2337 isi_body.append(' {')
2338 isi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')
2339 isi_body.append(' {')
2340 isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2341 isi_body.append(' }')
2342 isi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2343 isi_body.append(' {')
2344 isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\\n");')
2345 isi_body.append(' }')
2346 isi_body.append(' }')
2347 isi_body.append(' glv_free(pData);')
2348 return "\n".join(isi_body)
2349
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2350 def _gen_replay_update_descriptors(self):
2351 ud_body = []
2352 # TODO : Add code here to read chain of update structs
2353
2354 def _gen_replay_create_descriptor_set_layout(self):
2355 cdsl_body = []
2356 # TODO : Add code here to read in chain of descriptor layout create infos from packet
2357
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2358 def _gen_replay_create_graphics_pipeline(self):
2359 cgp_body = []
2360 cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')
2361 cgp_body.append(' struct shaderPair saveShader[10];')
2362 cgp_body.append(' unsigned int idx = 0;')
2363 cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')
2364 cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')
2365 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')
2366 cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')
2367 cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')
2368 cgp_body.append(' {')
2369 cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')
2370 cgp_body.append(' {')
2371 cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')
2372 cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')
2373 cgp_body.append(' pNext->shader.shader = remap(pPacketNext->shader.shader);')
2374 cgp_body.append(' }')
2375 cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')
2376 cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')
2377 cgp_body.append(' }')
2378 cgp_body.append(' XGL_PIPELINE pipeline;')
2379 cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(remap(pPacket->device), &createInfo, &pipeline);')
2380 cgp_body.append(' if (replayResult == XGL_SUCCESS)')
2381 cgp_body.append(' {')
2382 cgp_body.append(' add_to_map(pPacket->pPipeline, &pipeline);')
2383 cgp_body.append(' }')
2384 cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')
2385 cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')
2386 return "\n".join(cgp_body)
2387
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]2388 def _gen_replay_create_framebuffer(self):
2389 cf_body = []
2390 cf_body.append(' XGL_FRAMEBUFFER_CREATE_INFO *pInfo = (XGL_FRAMEBUFFER_CREATE_INFO *) pPacket->pCreateInfo;')
2391 cf_body.append(' XGL_COLOR_ATTACHMENT_BIND_INFO *pColorAttachments, *pSavedColor = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pInfo->pColorAttachments;')
2392 cf_body.append(' bool allocatedColorAttachments = false;')
2393 cf_body.append(' if (pSavedColor != NULL)')
2394 cf_body.append(' {')
2395 cf_body.append(' allocatedColorAttachments = true;')
2396 cf_body.append(' pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pInfo->colorAttachmentCount);')
2397 cf_body.append(' memcpy(pColorAttachments, pSavedColor, sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) * pInfo->colorAttachmentCount);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2398 cf_body.append(' for (uint32_t i = 0; i < pInfo->colorAttachmentCount; i++)')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]2399 cf_body.append(' {')
2400 cf_body.append(' pColorAttachments[i].view = remap(pInfo->pColorAttachments[i].view);')
2401 cf_body.append(' }')
2402 cf_body.append(' pInfo->pColorAttachments = pColorAttachments;')
2403 cf_body.append(' }')
2404 cf_body.append(' // remap depth stencil target')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2405 cf_body.append(' const XGL_DEPTH_STENCIL_BIND_INFO *pSavedDS = pInfo->pDepthStencilAttachment;')
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]2406 cf_body.append(' XGL_DEPTH_STENCIL_BIND_INFO depthTarget;')
2407 cf_body.append(' if (pSavedDS != NULL)')
2408 cf_body.append(' {')
2409 cf_body.append(' memcpy(&depthTarget, pSavedDS, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));')
2410 cf_body.append(' depthTarget.view = remap(pSavedDS->view);')
2411 cf_body.append(' pInfo->pDepthStencilAttachment = &depthTarget;')
2412 cf_body.append(' }')
2413 cf_body.append(' XGL_FRAMEBUFFER local_framebuffer;')
2414 cf_body.append(' replayResult = m_xglFuncs.real_xglCreateFramebuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_framebuffer);')
2415 cf_body.append(' pInfo->pColorAttachments = pSavedColor;')
2416 cf_body.append(' pInfo->pDepthStencilAttachment = pSavedDS;')
2417 cf_body.append(' if (replayResult == XGL_SUCCESS)')
2418 cf_body.append(' {')
2419 cf_body.append(' add_to_map(pPacket->pFramebuffer, &local_framebuffer);')
2420 cf_body.append(' }')
2421 cf_body.append(' if (allocatedColorAttachments)')
2422 cf_body.append(' {')
2423 cf_body.append(' GLV_DELETE((void*)pColorAttachments);')
2424 cf_body.append(' }')
2425 return "\n".join(cf_body)
2426
2427 def _gen_replay_create_renderpass(self):
2428 cr_body = []
2429 cr_body.append(' XGL_RENDER_PASS_CREATE_INFO *pInfo = (XGL_RENDER_PASS_CREATE_INFO *) pPacket->pCreateInfo;')
2430 cr_body.append(' // remap framebuffer')
2431 cr_body.append(' XGL_FRAMEBUFFER savedFB, *pFB = &(pInfo->framebuffer);')
2432 cr_body.append(' if (*pFB != NULL)')
2433 cr_body.append(' {')
2434 cr_body.append(' savedFB = pInfo->framebuffer;')
2435 cr_body.append(' *pFB = remap(pInfo->framebuffer);')
2436 cr_body.append(' }')
2437 cr_body.append(' XGL_RENDER_PASS local_renderpass;')
2438 cr_body.append(' replayResult = m_xglFuncs.real_xglCreateRenderPass(remap(pPacket->device), pPacket->pCreateInfo, &local_renderpass);')
2439 cr_body.append(' pInfo->framebuffer = savedFB;')
2440 cr_body.append(' if (replayResult == XGL_SUCCESS)')
2441 cr_body.append(' {')
2442 cr_body.append(' add_to_map(pPacket->pRenderPass, &local_renderpass);')
2443 cr_body.append(' }')
2444 return "\n".join(cr_body)
2445
2446 def _gen_replay_begin_command_buffer(self):
2447 bcb_body = []
2448 bcb_body.append(' XGL_CMD_BUFFER_BEGIN_INFO* pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*)pPacket->pBeginInfo;')
2449 bcb_body.append(' // assume only zero or one graphics_begin_info in the chain')
2450 bcb_body.append(' XGL_RENDER_PASS savedRP, *pRP;')
2451 bcb_body.append(' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *pGInfo = NULL;')
2452 bcb_body.append(' while (pInfo != NULL)')
2453 bcb_body.append(' {')
2454 bcb_body.append('')
2455 bcb_body.append(' if (pInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO)')
2456 bcb_body.append(' {')
2457 bcb_body.append(' pGInfo = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *) pInfo;')
2458 bcb_body.append(' savedRP = pGInfo->renderPass;')
2459 bcb_body.append(' pRP = &(pGInfo->renderPass);')
2460 bcb_body.append(' *pRP = remap(pGInfo->renderPass);')
2461 bcb_body.append(' break;')
2462 bcb_body.append(' }')
2463 bcb_body.append(' pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*) pInfo->pNext;')
2464 bcb_body.append(' }')
2465 bcb_body.append(' replayResult = m_xglFuncs.real_xglBeginCommandBuffer(remap(pPacket->cmdBuffer), pPacket->pBeginInfo);')
2466 bcb_body.append(' if (pGInfo != NULL)')
2467 bcb_body.append(' pGInfo->renderPass = savedRP;')
2468 return "\n".join(bcb_body)
2469
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2470 def _gen_replay_store_pipeline(self):
2471 sp_body = []
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2472 sp_body.append(' size_t size = 0;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2473 sp_body.append(' void* pData = NULL;')
2474 sp_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')
2475 sp_body.append(' {')
2476 sp_body.append(' size = *pPacket->pDataSize;')
2477 sp_body.append(' pData = glv_malloc(*pPacket->pDataSize);')
2478 sp_body.append(' }')
2479 sp_body.append(' replayResult = m_xglFuncs.real_xglStorePipeline(remap(pPacket->pipeline), &size, pData);')
2480 sp_body.append(' if (replayResult == XGL_SUCCESS)')
2481 sp_body.append(' {')
2482 sp_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')
2483 sp_body.append(' {')
2484 sp_body.append(' glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')
2485 sp_body.append(' }')
2486 sp_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')
2487 sp_body.append(' {')
2488 sp_body.append(' glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\\n");')
2489 sp_body.append(' }')
2490 sp_body.append(' }')
2491 sp_body.append(' glv_free(pData);')
2492 return "\n".join(sp_body)
2493
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2494 def _gen_replay_get_multi_gpu_compatibility(self):
2495 gmgc_body = []
2496 gmgc_body.append(' XGL_GPU_COMPATIBILITY_INFO cInfo;')
2497 gmgc_body.append(' XGL_PHYSICAL_GPU handle0, handle1;')
2498 gmgc_body.append(' handle0 = remap(pPacket->gpu0);')
2499 gmgc_body.append(' handle1 = remap(pPacket->gpu1);')
2500 gmgc_body.append(' replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);')
2501 return "\n".join(gmgc_body)
2502
2503 def _gen_replay_destroy_object(self):
2504 do_body = []
2505 do_body.append(' XGL_OBJECT object = remap(pPacket->object);')
2506 do_body.append(' if (object != XGL_NULL_HANDLE)')
2507 do_body.append(' replayResult = m_xglFuncs.real_xglDestroyObject(object);')
2508 do_body.append(' if (replayResult == XGL_SUCCESS)')
2509 do_body.append(' rm_from_map(pPacket->object);')
2510 return "\n".join(do_body)
2511
2512 def _gen_replay_wait_for_fences(self):
2513 wf_body = []
2514 wf_body.append(' XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2515 wf_body.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2516 wf_body.append(' {')
2517 wf_body.append(' *(pFence + i) = remap(*(pPacket->pFences + i));')
2518 wf_body.append(' }')
2519 wf_body.append(' replayResult = m_xglFuncs.real_xglWaitForFences(remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);')
2520 wf_body.append(' GLV_DELETE(pFence);')
2521 return "\n".join(wf_body)
2522
2523 def _gen_replay_wsi_associate_connection(self):
2524 wac_body = []
2525 wac_body.append(' //associate with the replayers Wsi connection rather than tracers')
2526 wac_body.append(' replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')
2527 return "\n".join(wac_body)
2528
2529 def _gen_replay_wsi_get_msc(self):
2530 wgm_body = []
2531 wgm_body.append(' xcb_window_t window = m_display->m_XcbWindow;')
2532 wgm_body.append(' replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')
2533 return "\n".join(wgm_body)
2534
2535 def _gen_replay_wsi_create_presentable_image(self):
2536 cpi_body = []
2537 cpi_body.append(' XGL_IMAGE img;')
2538 cpi_body.append(' XGL_GPU_MEMORY mem;')
2539 cpi_body.append(' replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);')
2540 cpi_body.append(' if (replayResult == XGL_SUCCESS)')
2541 cpi_body.append(' {')
2542 cpi_body.append(' if (pPacket->pImage != NULL)')
2543 cpi_body.append(' add_to_map(pPacket->pImage, &img);')
2544 cpi_body.append(' if(pPacket->pMem != NULL)')
2545 cpi_body.append(' add_to_map(pPacket->pMem, &mem);')
2546 cpi_body.append(' }')
2547 return "\n".join(cpi_body)
2548
2549 def _gen_replay_wsi_queue_present(self):
2550 wqp_body = []
2551 wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')
2552 wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')
2553 wqp_body.append(' pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);')
2554 wqp_body.append(' // use replayers Xcb window')
2555 wqp_body.append(' pInfo.destWindow = m_display->m_XcbWindow;')
2556 wqp_body.append(' replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));')
2557 return "\n".join(wqp_body)
2558
2559 # I don't like making these 3 mem functions 'fully' custom, but just doing it for now to avoid being too cute
2560 def _gen_replay_free_memory(self):
2561 fm_body = []
2562 fm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')
2563 fm_body.append(' replayResult = m_xglFuncs.real_xglFreeMemory(handle);')
2564 fm_body.append(' if (replayResult == XGL_SUCCESS) ')
2565 fm_body.append(' {')
2566 fm_body.append(' rm_entry_from_mapData(handle);')
2567 fm_body.append(' rm_from_map(pPacket->mem);')
2568 fm_body.append(' }')
2569 return "\n".join(fm_body)
2570
2571 def _gen_replay_map_memory(self):
2572 mm_body = []
2573 mm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2574 mm_body.append(' void* pData;')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2575 mm_body.append(' replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);')
2576 mm_body.append(' if (replayResult == XGL_SUCCESS)')
2577 mm_body.append(' add_mapping_to_mapData(handle, pData);')
2578 return "\n".join(mm_body)
2579
2580 def _gen_replay_unmap_memory(self):
2581 um_body = []
2582 um_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')
2583 um_body.append(' rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer')
2584 um_body.append(' replayResult = m_xglFuncs.real_xglUnmapMemory(handle);')
2585 return "\n".join(um_body)
2586
2587 def _gen_replay_bind_dynamic_memory_view(self):
2588 bdmv_body = []
2589 bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')
2590 bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));')
2591 bdmv_body.append(' memView.mem = remap(pPacket->pMemView->mem);')
2592 bdmv_body.append(' m_xglFuncs.real_xglCmdBindDynamicMemoryView(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')
2593 return "\n".join(bdmv_body)
2594
2595 def _generate_replay(self):
2596 # map protos to custom functions if body is fully custom
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2597 # TODO : DescriptorUpdates and CreateSetLayout need to handle restoring chain of structs
2598 # Should have custom replay code similar to CreateGraphicsPipeline
Tobin Ehlis45bc7f82015-01-16 15:13:34 -0700[diff] [blame]2599 custom_body_dict = {'EnumerateGpus': self._gen_replay_enum_gpus,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2600 'GetGpuInfo': self._gen_replay_get_gpu_info,
2601 'CreateDevice': self._gen_replay_create_device,
2602 'GetExtensionSupport': self._gen_replay_get_extension_support,
2603 'QueueSubmit': self._gen_replay_queue_submit,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2604 'GetObjectInfo': self._gen_replay_get_object_info,
2605 'GetFormatInfo': self._gen_replay_get_format_info,
2606 'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,
2607 'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,
Jon Ashburna02bc242015-01-02 18:28:26 -0700[diff] [blame]2608 'CreateFramebuffer': self._gen_replay_create_framebuffer,
2609 'CreateRenderPass': self._gen_replay_create_renderpass,
2610 'BeginCommandBuffer': self._gen_replay_begin_command_buffer,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2611 'StorePipeline': self._gen_replay_store_pipeline,
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2612 'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,
2613 'DestroyObject': self._gen_replay_destroy_object,
2614 'WaitForFences': self._gen_replay_wait_for_fences,
2615 'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,
2616 'WsiX11GetMSC': self._gen_replay_wsi_get_msc,
2617 'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,
2618 'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,
2619 'FreeMemory': self._gen_replay_free_memory,
2620 'MapMemory': self._gen_replay_map_memory,
2621 'UnmapMemory': self._gen_replay_unmap_memory,
2622 'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view}
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2623 # TODO : Need to guard CreateInstance with "if (!m_display->m_initedXGL)" check
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2624 # Despite returning a value, don't check these funcs b/c custom code includes check already
2625 custom_check_ret_val = ['InitAndEnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport']
2626 # multi-gpu Open funcs w/ list of local params to create
2627 custom_open_params = {'OpenSharedMemory': (-1,),
2628 'OpenSharedQueueSemaphore': (-1,),
2629 'OpenPeerMemory': (-1,),
2630 'OpenPeerImage': (-1, -2,)}
2631 # Functions that create views are unique from other create functions
2632 create_view_list = ['CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']
2633 # Functions to treat as "Create' that don't have 'Create' in the name
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2634 special_create_list = ['LoadPipeline', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2635 # A couple funcs use do while loops
2636 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'}
2637 rbody = []
2638 rbody.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')
2639 rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')
2640 rbody.append('{')
2641 rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')
2642 rbody.append(' XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;')
2643 rbody.append(' switch (packet->packet_id)')
2644 rbody.append(' {')
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]2645 rbody.append(' case GLV_TPI_XGL_xglApiVersion:')
2646 rbody.append(' break; // nothing to replay on the version packet')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2647 for proto in self.protos:
2648 ret_value = False
2649 create_view = False
2650 create_func = False
2651 transitions = False
2652 ds_attach = False
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2653 # TODO : How to handle void* return of GetProcAddr?
2654 if ('void' not in proto.ret) and (proto.name not in custom_check_ret_val):
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2655 ret_value = True
2656 if proto.name in create_view_list:
2657 create_view = True
2658 elif 'Create' in proto.name or proto.name in special_create_list:
2659 create_func = True
2660 elif 'pStateTransitions' in [p.name for p in proto.params]:
2661 transitions = True
2662 elif proto.name.startswith('Attach'):
2663 ds_attach = True
2664 rbody.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)
2665 rbody.append(' {')
2666 rbody.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(packet->pBody);' % (proto.name, proto.name))
2667 if proto.name in custom_body_dict:
2668 rbody.append(custom_body_dict[proto.name]())
2669 else:
2670 if proto.name in custom_open_params:
2671 rbody.append(' XGL_DEVICE handle;')
2672 for pidx in custom_open_params[proto.name]:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2673 rbody.append(' %s local_%s;' % (proto.params[pidx].ty.replace('const ', '').strip('*'), proto.params[pidx].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2674 rbody.append(' handle = remap(pPacket->device);')
2675 elif create_view:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2676 rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').replace('const ', '')))
2677 rbody.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(%s));' % (proto.params[1].ty.strip('*').replace('const ', '')))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2678 if 'CreateComputePipeline' == proto.name:
2679 rbody.append(' createInfo.cs.shader = remap(pPacket->pCreateInfo->cs.shader);')
2680 else:
2681 rbody.append(' createInfo.image = remap(pPacket->pCreateInfo->image);')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2682 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2683 elif create_func: # Declare local var to store created handle into
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2684 rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2685 if 'AllocDescriptorSets' == proto.name:
2686 rbody.append(' %s* local_%s = NULL;' % (proto.params[-2].ty.strip('*').replace('const ', ''), proto.params[-2].name))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2687 elif transitions:
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2688 rbody.append(' %s pStateTransitions = (%s)pPacket->pStateTransitions;' % (proto.params[-1].ty.replace('const ', ''), proto.params[-1].ty.replace('const ', '')))
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2689 rbody.append(' bool allocatedMem = false;')
2690 rbody.append(' if (pStateTransitions != NULL)')
2691 rbody.append(' {')
2692 rbody.append(' allocatedMem = true;')
Tobin Ehlis2012fce2015-01-15 17:53:54 -0700[diff] [blame]2693 rbody.append(' pStateTransitions = GLV_NEW_ARRAY(%s, pPacket->transitionCount);' % (proto.params[-1].ty.strip('*').replace('const ', '')))
2694 rbody.append(' memcpy(pStateTransitions, pPacket->pStateTransitions, sizeof(%s) * pPacket->transitionCount);' % (proto.params[-1].ty.strip('*').replace('const ', '')))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2695 rbody.append(' for (uint32_t i = 0; i < pPacket->transitionCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2696 rbody.append(' {')
2697 if 'Memory' in proto.name:
2698 rbody.append(' pStateTransitions[i].mem = remap(pPacket->pStateTransitions[i].mem);')
2699 else:
2700 rbody.append(' pStateTransitions[i].image = remap(pPacket->pStateTransitions[i].image);')
2701 rbody.append(' }')
2702 rbody.append(' }')
2703 elif ds_attach:
2704 rbody.append(' %s %s = GLV_NEW_ARRAY(%s, pPacket->slotCount);' % (proto.params[-1].ty.strip('const '), proto.params[-1].name, proto.params[-1].ty.strip('const ').strip('*')))
2705 rbody.append(' memcpy(%s, pPacket->%s, pPacket->slotCount * sizeof(%s));' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].ty.strip('const ').strip('*')))
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2706 rbody.append(' for (uint32_t i = 0; i < pPacket->slotCount; i++)')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2707 rbody.append(' {')
2708 if 'Sampler' in proto.name:
2709 rbody.append(' %s[i] = remap(pPacket->%s[i]);' % (proto.params[-1].name, proto.params[-1].name))
2710 elif 'Image' in proto.name:
2711 rbody.append(' %s[i].view = remap(pPacket->%s[i].view);' % (proto.params[-1].name, proto.params[-1].name))
2712 elif 'Memory' in proto.name:
2713 rbody.append(' %s[i].mem = remap(pPacket->%s[i].mem);' % (proto.params[-1].name, proto.params[-1].name))
2714 else:
2715 rbody.append(' %s[i].descriptorSet = remap(pPacket->%s[i].descriptorSet);' % (proto.params[-1].name, proto.params[-1].name))
2716 rbody.append(' }')
2717 elif proto.name in do_while_dict:
2718 rbody.append(' do {')
2719 rr_string = ' '
2720 if ret_value:
2721 rr_string = ' replayResult = '
2722 rr_string += 'm_xglFuncs.real_xgl%s(' % proto.name
2723 for p in proto.params:
2724 # For last param of Create funcs, pass address of param
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2725 if create_func:
2726 if p.name == proto.params[-1].name:
2727 rr_string += '&local_%s, ' % p.name
2728 elif proto.name == 'AllocDescriptorSets' and p.name == proto.params[-2].name:
2729 rr_string += 'local_%s, ' % p.name
2730 else:
2731 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2732 else:
2733 rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)
2734 rr_string = '%s);' % rr_string[:-2]
2735 if transitions:
2736 rr_string = rr_string.replace('pPacket->pState', 'pState')
2737 elif ds_attach:
2738 rr_list = rr_string.split(', ')
2739 rr_list[-1] = '%s);' % proto.params[-1].name
2740 rr_string = ', '.join(rr_list)
2741 elif proto.name in custom_open_params:
2742 rr_list = rr_string.split(', ')
2743 rr_list[0] = rr_list[0].replace('remap(pPacket->device)', 'handle')
2744 for pidx in custom_open_params[proto.name]:
2745 rr_list[pidx] = '&local_%s' % proto.params[pidx].name
2746 rr_string = ', '.join(rr_list)
2747 rr_string += ');'
2748 elif create_view:
2749 rr_list = rr_string.split(', ')
2750 rr_list[-2] = '&createInfo'
2751 rr_list[-1] = '&local_%s);' % proto.params[-1].name
2752 rr_string = ', '.join(rr_list)
2753 # this is a sneaky shortcut to use generic create code below to add_to_map
2754 create_func = True
2755 rbody.append(rr_string)
2756 if 'DestroyDevice' in proto.name:
2757 rbody.append(' if (replayResult == XGL_SUCCESS)')
2758 rbody.append(' {')
2759 rbody.append(' rm_from_map(pPacket->device);')
2760 rbody.append(' m_display->m_initedXGL = false;')
2761 rbody.append(' }')
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2762 elif 'AllocDescriptorSets' in proto.name:
2763 rbody.append(' if (replayResult == XGL_SUCCESS)')
2764 rbody.append(' {')
2765 rbody.append(' for (uint32_t i = 0; i < local_pCount; i++) {')
Tobin Ehlisfc04b892015-01-22 12:29:31 -0700[diff] [blame]2766 rbody.append(' add_to_map(&pPacket->%s[i], &local_%s[i]);' % (proto.params[-2].name, proto.params[-2].name))
Tobin Ehlis377b4622015-01-20 13:50:59 -0700[diff] [blame]2767 rbody.append(' }')
2768 rbody.append(' }')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2769 elif create_func: # save handle mapping if create successful
2770 rbody.append(' if (replayResult == XGL_SUCCESS)')
2771 rbody.append(' {')
2772 rbody.append(' add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))
2773 if 'AllocMemory' == proto.name:
2774 rbody.append(' add_entry_to_mapData(local_%s, pPacket->pAllocInfo->allocationSize);' % (proto.params[-1].name))
2775 rbody.append(' }')
2776 elif transitions:
2777 rbody.append(' if (allocatedMem)')
2778 rbody.append(' {')
2779 rbody.append(' GLV_DELETE((void*)pStateTransitions);')
2780 rbody.append(' }')
2781 elif ds_attach:
2782 rbody.append(' GLV_DELETE(%s);' % proto.params[-1].name)
2783 elif proto.name in do_while_dict:
2784 rbody[-1] = ' %s' % rbody[-1]
2785 rbody.append(' } while (%s);' % do_while_dict[proto.name])
2786 if ret_value:
2787 rbody.append(' CHECK_RETURN_VALUE(xgl%s);' % proto.name)
2788 if 'MsgCallback' in proto.name:
2789 rbody.pop()
2790 rbody.pop()
2791 rbody.pop()
2792 rbody.append(' // Just eating these calls as no way to restore dbg func ptr.')
2793 rbody.append(' break;')
2794 rbody.append(' }')
2795 rbody.append(' default:')
2796 rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')
2797 rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')
2798 rbody.append(' break;')
2799 rbody.append(' }')
2800 rbody.append(' return returnValue;')
2801 rbody.append('}')
2802 return "\n".join(rbody)
2803
2804class GlaveTraceHeader(Subcommand):
2805 def generate_header(self):
2806 header_txt = []
2807 header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
2808 header_txt.append('#include "glvtrace_xgl_packet_id.h"\n')
2809 header_txt.append('void AttachHooks();')
2810 header_txt.append('void DetachHooks();')
2811 header_txt.append('void InitTracer();\n')
2812 return "\n".join(header_txt)
2813
2814 def generate_body(self):
2815 body = [self._generate_trace_func_ptrs(),
2816 self._generate_trace_func_protos()]
2817
2818 return "\n".join(body)
2819
2820class GlaveTraceC(Subcommand):
2821 def generate_header(self):
2822 header_txt = []
2823 header_txt.append('#include "glv_platform.h"')
2824 header_txt.append('#include "glv_common.h"')
2825 header_txt.append('#include "glvtrace_xgl_xgl.h"')
2826 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
2827 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
2828 header_txt.append('#include "glv_interconnect.h"')
2829 header_txt.append('#include "glv_filelike.h"')
2830 header_txt.append('#ifdef WIN32')
2831 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2832 header_txt.append('#endif')
2833 header_txt.append('#include "glv_trace_packet_utils.h"')
2834 header_txt.append('#include <stdio.h>\n')
2835 return "\n".join(header_txt)
2836
2837 def generate_body(self):
2838 body = [self._generate_func_ptr_assignments(),
2839 self._generate_attach_hooks(),
2840 self._generate_detach_hooks(),
Jon Ashburne2248392014-12-16 18:37:04 -0700[diff] [blame]2841 self._generate_init_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]2842 self._generate_helper_funcs(),
2843 self._generate_trace_funcs()]
2844
2845 return "\n".join(body)
2846
2847class GlavePacketID(Subcommand):
2848 def generate_header(self):
2849 header_txt = []
2850 header_txt.append('#pragma once\n')
2851 header_txt.append('#include "glv_trace_packet_utils.h"')
2852 header_txt.append('#include "glv_trace_packet_identifiers.h"')
2853 header_txt.append('#include "glv_interconnect.h"')
2854 header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
2855 header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
2856 header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
2857 header_txt.append('#include "xgl_enum_string_helper.h"')
2858 header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')
2859 header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\\n");\n')
2860 header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')
2861 header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')
2862 header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')
2863 header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);\n')
2864 header_txt.append('#define FINISH_TRACE_PACKET() \\')
2865 header_txt.append(' glv_finalize_trace_packet(pHeader); \\')
2866 header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')
2867 header_txt.append(' glv_delete_trace_packet(&pHeader);')
2868 return "\n".join(header_txt)
2869
2870 def generate_body(self):
2871 body = [self._generate_packet_id_enum(),
2872 self._generate_stringify_func(),
2873 self._generate_interp_func()]
2874
2875 return "\n".join(body)
2876
2877class GlaveCoreStructs(Subcommand):
2878 def generate_header(self):
2879 header_txt = []
2880 header_txt.append('#pragma once\n')
2881 header_txt.append('#include "xgl.h"')
2882 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2883 return "\n".join(header_txt)
2884
2885 def generate_body(self):
2886 body = [self._generate_struct_util_funcs(),
2887 self._generate_interp_funcs()]
2888
2889 return "\n".join(body)
2890
2891class GlaveWsiHeader(Subcommand):
2892 def generate_header(self):
2893 header_txt = []
2894 header_txt.append('#pragma once\n')
2895 header_txt.append('#include "xgl.h"')
2896 header_txt.append('#include "xglWsiX11Ext.h"\n')
2897 header_txt.append('void AttachHooks_xglwsix11ext();')
2898 header_txt.append('void DetachHooks_xglwsix11ext();')
2899 return "\n".join(header_txt)
2900
2901 def generate_body(self):
2902 body = [self._generate_trace_func_ptrs_ext(),
2903 self._generate_trace_func_protos_ext()]
2904
2905 return "\n".join(body)
2906
2907class GlaveWsiC(Subcommand):
2908 def generate_header(self):
2909 header_txt = []
2910 header_txt.append('#include "glv_platform.h"')
2911 header_txt.append('#include "glv_common.h"')
2912 header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
2913 header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
2914 header_txt.append('#include "glvtrace_xgl_packet_id.h"')
2915 header_txt.append('#ifdef WIN32')
2916 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2917 header_txt.append('#endif')
2918 return "\n".join(header_txt)
2919
2920 def generate_body(self):
2921 body = [self._generate_func_ptr_assignments_ext(),
2922 self._generate_attach_hooks_ext(),
2923 self._generate_detach_hooks_ext(),
2924 self._generate_trace_funcs_ext()]
2925
2926 return "\n".join(body)
2927
2928class GlaveWsiStructs(Subcommand):
2929 def generate_header(self):
2930 header_txt = []
2931 header_txt.append('#pragma once\n')
2932 header_txt.append('#include "xglWsiX11Ext.h"')
2933 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2934 return "\n".join(header_txt)
2935
2936 def generate_body(self):
2937 body = [self._generate_interp_funcs_ext()]
2938
2939 return "\n".join(body)
2940
2941class GlaveDbgHeader(Subcommand):
2942 def generate_header(self):
2943 header_txt = []
2944 header_txt.append('#pragma once\n')
2945 header_txt.append('#include "xgl.h"')
2946 header_txt.append('#include "xglDbg.h"\n')
2947 header_txt.append('void AttachHooks_xgldbg();')
2948 header_txt.append('void DetachHooks_xgldbg();')
2949 return "\n".join(header_txt)
2950
2951 def generate_body(self):
2952 body = [self._generate_trace_func_ptrs_ext('Dbg'),
2953 self._generate_trace_func_protos_ext('Dbg')]
2954
2955 return "\n".join(body)
2956
2957class GlaveDbgC(Subcommand):
2958 def generate_header(self):
2959 header_txt = []
2960 header_txt.append('#include "glv_platform.h"')
2961 header_txt.append('#include "glv_common.h"')
2962 header_txt.append('#include "glvtrace_xgl_xgl.h"')
2963 header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
2964 header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
2965 header_txt.append('#include "glvtrace_xgl_packet_id.h"')
2966 header_txt.append('#ifdef WIN32')
2967 header_txt.append('#include "mhook/mhook-lib/mhook.h"')
2968 header_txt.append('#endif')
2969 return "\n".join(header_txt)
2970
2971 def generate_body(self):
2972 body = [self._generate_func_ptr_assignments_ext('Dbg'),
2973 self._generate_attach_hooks_ext('Dbg'),
2974 self._generate_detach_hooks_ext('Dbg'),
2975 self._generate_trace_funcs_ext('Dbg')]
2976
2977 return "\n".join(body)
2978
2979class GlaveDbgStructs(Subcommand):
2980 def generate_header(self):
2981 header_txt = []
2982 header_txt.append('#pragma once\n')
2983 header_txt.append('#include "xglDbg.h"')
2984 header_txt.append('#include "glv_trace_packet_utils.h"\n')
2985 return "\n".join(header_txt)
2986
2987 def generate_body(self):
2988 body = [self._generate_interp_funcs_ext('Dbg')]
2989
2990 return "\n".join(body)
2991
2992class GlaveReplayHeader(Subcommand):
2993 def generate_header(self):
2994 header_txt = []
2995 header_txt.append('#pragma once\n')
2996 header_txt.append('#include <set>')
2997 header_txt.append('#include <map>')
2998 header_txt.append('#include <vector>')
2999 header_txt.append('#include <xcb/xcb.h>\n')
3000 header_txt.append('#include "glvreplay_window.h"')
3001 header_txt.append('#include "glvreplay_factory.h"')
3002 header_txt.append('#include "glv_trace_packet_identifiers.h"\n')
3003 header_txt.append('#include "xgl.h"')
3004 header_txt.append('#include "xglDbg.h"')
3005 header_txt.append('#include "xglWsiX11Ext.h"')
3006 return "\n".join(header_txt)
3007
3008 def generate_body(self):
3009 body = [self._generate_replay_class_decls(),
3010 self._generate_replay_func_ptrs(),
3011 self._generate_replay_class()]
3012
3013 return "\n".join(body)
3014
3015class GlaveReplayC(Subcommand):
3016 def generate_header(self):
3017 header_txt = []
3018 header_txt.append('#include "glvreplay_xgl_replay.h"\n')
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]3019 header_txt.append('#include "glvreplay_xgl.h"\n')
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3020 header_txt.append('extern "C" {')
3021 header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
3022 header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
3023 header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
3024 header_txt.append('#include "glvtrace_xgl_packet_id.h"')
3025 header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')
3026 header_txt.append('#define APP_NAME "glvreplay_xgl"')
3027 header_txt.append('#define IDI_ICON 101\n')
3028 header_txt.append('static const char* g_extensions[] =')
3029 header_txt.append('{')
3030 header_txt.append(' "XGL_WSI_WINDOWS",')
3031 header_txt.append(' "XGL_TIMER_QUEUE",')
3032 header_txt.append(' "XGL_GPU_TIMESTAMP_CALIBRATION",')
3033 header_txt.append(' "XGL_DMA_QUEUE",')
3034 header_txt.append(' "XGL_COMMAND_BUFFER_CONTROL_FLOW",')
3035 header_txt.append(' "XGL_COPY_OCCLUSION_QUERY_DATA",')
3036 header_txt.append(' "XGL_ADVANCED_MULTISAMPLING",')
3037 header_txt.append(' "XGL_BORDER_COLOR_PALETTE"')
3038 header_txt.append('};')
3039 return "\n".join(header_txt)
3040
3041 def generate_body(self):
3042 body = [self._generate_replay_display_init_xgl(),
3043 self._generate_replay_display_init(),
3044 self._generate_replay_display_structors(),
3045 self._generate_replay_display_window(),
3046 self._generate_replay_structors(),
3047 self._generate_replay_init(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3048 self._generate_replay_errors(),
Jon Ashburnb7b98a02014-12-18 17:03:34 -0700[diff] [blame]3049 self._generate_replay_validation_funcs(),
Tobin Ehlisf5e1fc52014-12-15 18:14:12 -0700[diff] [blame]3050 self._generate_replay_init_funcs(),
3051 self._generate_replay()]
3052
3053 return "\n".join(body)
3054
3055def main():
3056 subcommands = {
3057 "glave-trace-h" : GlaveTraceHeader,
3058 "glave-trace-c" : GlaveTraceC,
3059 "glave-packet-id" : GlavePacketID,
3060 "glave-core-structs" : GlaveCoreStructs,
3061 "glave-wsi-trace-h" : GlaveWsiHeader,
3062 "glave-wsi-trace-c" : GlaveWsiC,
3063 "glave-wsi-trace-structs" : GlaveWsiStructs,
3064 "glave-dbg-trace-h" : GlaveDbgHeader,
3065 "glave-dbg-trace-c" : GlaveDbgC,
3066 "glave-dbg-trace-structs" : GlaveDbgStructs,
3067 "glave-replay-h" : GlaveReplayHeader,
3068 "glave-replay-c" : GlaveReplayC,
3069 }
3070
3071 if len(sys.argv) < 2 or sys.argv[1] not in subcommands:
3072 print("Usage: %s <subcommand> [options]" % sys.argv[0])
3073 print
3074 print("Available sucommands are: %s" % " ".join(subcommands))
3075 exit(1)
3076
3077 subcmd = subcommands[sys.argv[1]](sys.argv[2:])
3078 subcmd.run()
3079
3080if __name__ == "__main__":
3081 main()