1 /**************************************************************************
3 * Copyright 2013-2014 RAD Game Tools and Valve Software
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 **************************************************************************/
26 // File: vogl_ctypes.cpp
29 Linux x86 is ILP32, x64 is LP64:
31 ILP32 LP64 LLP64 ILP64
40 #include "vogl_common.h"
41 #include "vogl_console.h"
42 #include "vogl_command_line_params.h"
45 #include "TypeTraits.h"
47 //----------------------------------------------------------------------------------------------------------------------
48 // global array mapping gl/glx type enums to descriptions, valid for the current process (not necessarily the trace)
49 //----------------------------------------------------------------------------------------------------------------------
50 static vogl_ctype_desc_t g_vogl_ctype_descs[] =
52 #define DEF_TYPE(name, ctype) \
54 name, VOGL_INVALID_CTYPE, #name, #ctype, 0, false, false, false, false, false \
57 #include "gl_glx_ctypes.inc"
61 //----------------------------------------------------------------------------------------------------------------------
62 // Global process vogl_ctypes object
63 //----------------------------------------------------------------------------------------------------------------------
64 vogl_ctypes g_vogl_process_gl_ctypes;
66 //----------------------------------------------------------------------------------------------------------------------
67 // vogl_ctypes::vogl_ctypes
68 //----------------------------------------------------------------------------------------------------------------------
69 vogl_ctypes::vogl_ctypes()
71 // purposely do nothing here, because this object is initialized before global construction time
74 //----------------------------------------------------------------------------------------------------------------------
76 //----------------------------------------------------------------------------------------------------------------------
77 void vogl_ctypes::init()
79 m_pointer_size = sizeof(void *);
81 memcpy(m_vogl_ctype_descs, g_vogl_ctype_descs, sizeof(m_vogl_ctype_descs));
84 VOGL_ASSERT(m_vogl_ctype_descs[VOGL_GLVOID_PTR].m_is_pointer == true);
85 VOGL_ASSERT(m_vogl_ctype_descs[VOGL_GLVOID_PTR].m_is_opaque_pointer == true);
86 VOGL_ASSERT(m_vogl_ctype_descs[VOGL_GLVOID_PTR].m_size == static_cast<int>(m_pointer_size));
89 //----------------------------------------------------------------------------------------------------------------------
91 //----------------------------------------------------------------------------------------------------------------------
92 void vogl_ctypes::init(uint trace_ptr_size)
94 m_pointer_size = trace_ptr_size;
96 change_pointer_sizes(trace_ptr_size);
99 //----------------------------------------------------------------------------------------------------------------------
100 // vogl_ctypes::change_pointer_sizes
101 // This code attempts to programmatically change the ctype sizes depending on the platform (x86 vs. x64).
102 //----------------------------------------------------------------------------------------------------------------------
103 void vogl_ctypes::change_pointer_sizes(uint trace_ptr_size)
105 VOGL_ASSUME(sizeof(intptr_t) == sizeof(void *));
106 VOGL_ASSUME(sizeof(ptrdiff_t) == sizeof(void *));
107 VOGL_ASSUME(sizeof(long) == sizeof(void *));
108 VOGL_ASSUME(sizeof(long long) == sizeof(uint64_t));
110 VOGL_ASSERT((trace_ptr_size == sizeof(uint32)) || (trace_ptr_size == sizeof(uint64_t)));
112 m_pointer_size = trace_ptr_size;
114 memcpy(m_vogl_ctype_descs, g_vogl_ctype_descs, sizeof(m_vogl_ctype_descs));
116 for (uint ctype_iter = 0; ctype_iter < VOGL_NUM_CTYPES; ctype_iter++)
118 vogl_ctype_desc_t &desc = m_vogl_ctype_descs[ctype_iter];
119 if ((desc.m_is_pointer_diff) || (desc.m_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_POINTER)))
121 desc.m_size = trace_ptr_size;
126 VOGL_ASSERT(!desc.m_is_pointer && !desc.m_is_opaque_pointer);
130 // Mark up long and XID types, which are unsigned longs
131 #define DEF_LONG_TYPE(x) m_vogl_ctype_descs[x].m_size = trace_ptr_size;
132 DEF_LONG_TYPE(VOGL_LONG);
133 DEF_LONG_TYPE(VOGL_UNSIGNED_LONG);
134 DEF_LONG_TYPE(VOGL_GLXPIXMAP);
135 DEF_LONG_TYPE(VOGL_GLXDRAWABLE);
136 DEF_LONG_TYPE(VOGL_GLXCONTEXTID);
137 DEF_LONG_TYPE(VOGL_GLXWINDOW);
138 DEF_LONG_TYPE(VOGL_GLXPBUFFER);
139 DEF_LONG_TYPE(VOGL_GLXVIDEOCAPTUREDEVICENV);
140 DEF_LONG_TYPE(VOGL_COLORMAP);
141 DEF_LONG_TYPE(VOGL_WINDOW);
142 DEF_LONG_TYPE(VOGL_FONT);
143 //DEF_LONG_TYPE(VOGL_DRAWABLE);
144 DEF_LONG_TYPE(VOGL_PIXMAP);
145 //DEF_LONG_TYPE(VOGL_CURSOR);
148 // Special case the XVisualInfo struct because its size differs between 32-bit and 64-bit - argh this sucks and we need a MUCH cleaner way of handling this.
149 // In practice this only fixes an assertion, because the packets always describe the exact length of objects.
150 m_vogl_ctype_descs[VOGL_XVISUALINFO].m_size = (trace_ptr_size == 8) ? 64 : 40;
154 for (uint ctype_iter = 0; ctype_iter < VOGL_NUM_CTYPES; ctype_iter++)
156 vogl_ctype_desc_t &desc = m_vogl_ctype_descs[ctype_iter];
157 if ((!desc.m_is_pointer) && (!desc.m_is_pointer_diff))
159 VOGL_ASSERT(!desc.m_is_opaque_pointer);
163 VOGL_ASSERT(desc.m_size == static_cast<int>(trace_ptr_size));
168 //----------------------------------------------------------------------------------------------------------------------
169 // vogl_ctypes::operator=
170 //----------------------------------------------------------------------------------------------------------------------
171 vogl_ctypes &vogl_ctypes::operator=(const vogl_ctypes &other)
175 memcpy(this, &other, sizeof(*this));
179 //----------------------------------------------------------------------------------------------------------------------
180 // vogl_dump_gl_ctypes
181 //----------------------------------------------------------------------------------------------------------------------
182 void vogl_dump_gl_ctypes()
184 printf("vogl_ctypes:\n");
185 for (int i = 0; i < VOGL_NUM_CTYPES; i++)
187 const vogl_ctype_desc_t &desc = g_vogl_ctype_descs[i];
189 printf("%u: %s \"%s\" is_pointer: %u size: %i, pointee type: %s, opaque pointer: %u, pointer diff type: %u, type flags: 0x%08X\n",
190 i, desc.m_pName, desc.m_pCType,
191 desc.m_is_pointer, desc.m_size,
192 (desc.m_pointee_ctype != VOGL_INVALID_CTYPE) ? g_vogl_ctype_descs[desc.m_pointee_ctype].m_pName : "N/A",
193 desc.m_is_opaque_pointer,
194 desc.m_is_pointer_diff,
195 desc.m_loki_type_flags);
200 //----------------------------------------------------------------------------------------------------------------------
201 // vogl_define_special_ctypes
202 // define opaque and pointer diff types
203 // Note: Opaque types may have different sizes in 32-bit vs 64-bit. We don't even try to get their ctype desc sizes
204 // right, because they can change.
205 //----------------------------------------------------------------------------------------------------------------------
206 static void vogl_define_special_ctypes()
208 // define opaque and opaque ptr types
209 #define DEF_OPAQUE_TYPE(type) \
210 VOGL_ASSERT(!g_vogl_ctype_descs[type].m_is_pointer); \
211 VOGL_ASSERT(!g_vogl_ctype_descs[type].m_is_opaque_type); \
212 g_vogl_ctype_descs[type].m_is_opaque_type = true;
214 #define DEF_OPAQUE_PTR_TYPE(type) \
216 VOGL_ASSERT(g_vogl_ctype_descs[type].m_is_pointer); \
217 VOGL_ASSERT(!g_vogl_ctype_descs[type].m_is_opaque_pointer); \
218 g_vogl_ctype_descs[type].m_is_opaque_pointer = true; \
219 if (g_vogl_ctype_descs[type].m_pointee_ctype != VOGL_VOID) \
220 g_vogl_ctype_descs[g_vogl_ctype_descs[type].m_pointee_ctype].m_is_opaque_type = true; \
223 DEF_OPAQUE_PTR_TYPE(VOGL_CONST_VOID_PTR)
224 DEF_OPAQUE_PTR_TYPE(VOGL_GLDEBUGPROC)
225 DEF_OPAQUE_PTR_TYPE(VOGL_GLDEBUGPROCAMD)
226 DEF_OPAQUE_PTR_TYPE(VOGL_GLDEBUGPROCARB)
227 DEF_OPAQUE_PTR_TYPE(VOGL_GLVOID_PTR)
228 DEF_OPAQUE_PTR_TYPE(VOGL_GLXEXTFUNCPTR)
229 DEF_OPAQUE_PTR_TYPE(VOGL_GLSYNC)
230 DEF_OPAQUE_PTR_TYPE(VOGL_GLXCONTEXT)
231 DEF_OPAQUE_PTR_TYPE(VOGL_CONST_GLXCONTEXT)
232 DEF_OPAQUE_PTR_TYPE(VOGL_GLXFBCONFIG)
233 DEF_OPAQUE_PTR_TYPE(VOGL_DISPLAY_PTR)
234 DEF_OPAQUE_PTR_TYPE(VOGL_STRUCT_CLCONTEXT_PTR)
235 DEF_OPAQUE_PTR_TYPE(VOGL_STRUCT_CLEVENT_PTR)
236 //DEF_OPAQUE_PTR_TYPE(VOGL_CONST_XVISUALINFO_PTR)
237 //DEF_OPAQUE_PTR_TYPE(VOGL_XVISUALINFO_PTR)
239 DEF_OPAQUE_TYPE(VOGL_VOID)
240 DEF_OPAQUE_TYPE(VOGL_WINDOW)
241 DEF_OPAQUE_TYPE(VOGL_XVISUALINFO)
242 DEF_OPAQUE_TYPE(VOGL_COLORMAP) // rg - added 11/14/13
244 #undef DEF_OPAQUE_PTR_TYPE
245 #undef DEF_OPAQUE_TYPE
247 // Define pointer diff types
248 #define DEF_POINTER_DIFF_TYPE(x) g_vogl_ctype_descs[x].m_is_pointer_diff = true;
249 DEF_POINTER_DIFF_TYPE(VOGL_GLVDPAUSURFACENV)
250 DEF_POINTER_DIFF_TYPE(VOGL_GLINTPTR)
251 DEF_POINTER_DIFF_TYPE(VOGL_GLINTPTRARB)
252 DEF_POINTER_DIFF_TYPE(VOGL_GLSIZEIPTR)
253 DEF_POINTER_DIFF_TYPE(VOGL_GLSIZEIPTRARB)
254 #undef DEF_POINTER_DIFF_TYPE
257 //----------------------------------------------------------------------------------------------------------------------
258 // vogl_init_gl_ctypes
259 //----------------------------------------------------------------------------------------------------------------------
260 void vogl_init_gl_ctypes()
263 #define DEF_TYPE(name, ctype) \
265 vogl_ctype_desc_t &desc = g_vogl_ctype_descs[name]; \
266 typedef Loki::TypeTraits<ctype> ctype_traits; \
267 desc.m_size = gl_ctype_sizeof<ctype>::size; \
268 desc.m_is_pointer = ctype_traits::isPointer; \
269 desc.m_loki_type_flags = ctype_traits::typeFlags; \
271 #include "gl_glx_ctypes.inc"
274 // Define ptr to pointee mappings
275 #define DEF_PTR_TO_POINTEE_TYPE(ptr_ctype, pointee_ctype) g_vogl_ctype_descs[ptr_ctype].m_pointee_ctype = pointee_ctype;
276 #include "gl_glx_ctypes_ptr_to_pointee.inc"
277 #undef DEF_PTR_TO_POINTEE_TYPE
279 vogl_define_special_ctypes();
281 for (int i = 0; i < VOGL_NUM_CTYPES; i++)
283 const vogl_ctype_desc_t &desc = g_vogl_ctype_descs[i];
284 bool has_pointee_ctype = (desc.m_pointee_ctype != VOGL_INVALID_CTYPE);
286 if (desc.m_is_pointer)
288 if (!has_pointee_ctype)
290 if (!desc.m_is_opaque_pointer)
291 vogl_warning_printf("%s: ctype %s is a non-opaque pointer, but does not have a valid pointee ctype!\n", VOGL_FUNCTION_NAME, desc.m_pName);
295 const vogl_ctype_desc_t &pointee_desc = g_vogl_ctype_descs[desc.m_pointee_ctype];
297 if ((desc.m_is_opaque_pointer) && (pointee_desc.m_size > 0))
299 vogl_warning_printf("%s: ctype %s is a pointer with a valid pointee ctype %s size %i, but has been marked as an opaque ptr!\n", VOGL_FUNCTION_NAME, desc.m_pName, g_vogl_ctype_descs[desc.m_pointee_ctype].m_pName, pointee_desc.m_size);
302 if ((!pointee_desc.m_size) && (desc.m_pointee_ctype != VOGL_GLVOID) && (desc.m_pointee_ctype != VOGL_VOID))
303 vogl_warning_printf("%s: ctype %s is a pointer with a valid pointee ctype, but the pointee type has a size of zero\n", VOGL_FUNCTION_NAME, desc.m_pName);
306 else if (has_pointee_ctype)
307 vogl_warning_printf("%s: ctype %s is not a pointer, but has a pointee ctype!\n", VOGL_FUNCTION_NAME, desc.m_pName);
308 else if (desc.m_is_opaque_pointer)
309 vogl_warning_printf("%s: ctype %s is not a pointer, but has been marked as an opaque pointer!\n", VOGL_FUNCTION_NAME, desc.m_pName);
312 g_vogl_process_gl_ctypes.init();
314 if (vogl::check_for_command_line_param("--vogl_debug"))
315 vogl_dump_gl_ctypes();
318 for (uint ctype_iter = 0; ctype_iter < VOGL_NUM_CTYPES; ctype_iter++)
320 vogl_ctype_desc_t &desc = g_vogl_ctype_descs[ctype_iter];
321 if ((desc.m_is_pointer_diff) ||
322 (desc.m_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_POINTER)) ||
323 (desc.m_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_SIGNED_LONG)) ||
324 (desc.m_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_UNSIGNED_LONG)))
326 // This will fail on long long and unsigned long long, but GL/GLX don't use those types.
327 VOGL_ASSERT(desc.m_size == sizeof(void *));
331 VOGL_ASSERT(!desc.m_is_pointer && !desc.m_is_opaque_pointer);