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);
150 for (uint ctype_iter = 0; ctype_iter < VOGL_NUM_CTYPES; ctype_iter++)
152 vogl_ctype_desc_t &desc = m_vogl_ctype_descs[ctype_iter];
153 if ((!desc.m_is_pointer) && (!desc.m_is_pointer_diff))
155 VOGL_ASSERT(!desc.m_is_opaque_pointer);
159 VOGL_ASSERT(desc.m_size == static_cast<int>(trace_ptr_size));
164 //----------------------------------------------------------------------------------------------------------------------
165 // vogl_ctypes::operator=
166 //----------------------------------------------------------------------------------------------------------------------
167 vogl_ctypes &vogl_ctypes::operator=(const vogl_ctypes &other)
171 memcpy(this, &other, sizeof(*this));
175 //----------------------------------------------------------------------------------------------------------------------
176 // vogl_dump_gl_ctypes
177 //----------------------------------------------------------------------------------------------------------------------
178 void vogl_dump_gl_ctypes()
180 printf("vogl_ctypes:\n");
181 for (int i = 0; i < VOGL_NUM_CTYPES; i++)
183 const vogl_ctype_desc_t &desc = g_vogl_ctype_descs[i];
185 printf("%u: %s \"%s\" is_pointer: %u size: %i, pointee type: %s, opaque pointer: %u, pointer diff type: %u, type flags: 0x%08X\n",
186 i, desc.m_pName, desc.m_pCType,
187 desc.m_is_pointer, desc.m_size,
188 (desc.m_pointee_ctype != VOGL_INVALID_CTYPE) ? g_vogl_ctype_descs[desc.m_pointee_ctype].m_pName : "N/A",
189 desc.m_is_opaque_pointer,
190 desc.m_is_pointer_diff,
191 desc.m_loki_type_flags);
196 //----------------------------------------------------------------------------------------------------------------------
197 // vogl_define_special_ctypes
198 // define opaque and pointer diff types
199 // Note: Opaque types may have different sizes in 32-bit vs 64-bit. We don't even try to get their ctype desc sizes
200 // right, because they can change.
201 //----------------------------------------------------------------------------------------------------------------------
202 static void vogl_define_special_ctypes()
204 // define opaque and opaque ptr types
205 #define DEF_OPAQUE_TYPE(type) \
206 VOGL_ASSERT(!g_vogl_ctype_descs[type].m_is_pointer); \
207 VOGL_ASSERT(!g_vogl_ctype_descs[type].m_is_opaque_type); \
208 g_vogl_ctype_descs[type].m_is_opaque_type = true;
210 #define DEF_OPAQUE_PTR_TYPE(type) \
212 VOGL_ASSERT(g_vogl_ctype_descs[type].m_is_pointer); \
213 VOGL_ASSERT(!g_vogl_ctype_descs[type].m_is_opaque_pointer); \
214 g_vogl_ctype_descs[type].m_is_opaque_pointer = true; \
215 if (g_vogl_ctype_descs[type].m_pointee_ctype != VOGL_VOID) \
216 g_vogl_ctype_descs[g_vogl_ctype_descs[type].m_pointee_ctype].m_is_opaque_type = true; \
219 DEF_OPAQUE_PTR_TYPE(VOGL_CONST_VOID_PTR)
220 DEF_OPAQUE_PTR_TYPE(VOGL_GLDEBUGPROC)
221 DEF_OPAQUE_PTR_TYPE(VOGL_GLDEBUGPROCAMD)
222 DEF_OPAQUE_PTR_TYPE(VOGL_GLDEBUGPROCARB)
223 DEF_OPAQUE_PTR_TYPE(VOGL_GLVOID_PTR)
224 DEF_OPAQUE_PTR_TYPE(VOGL_GLXEXTFUNCPTR)
225 DEF_OPAQUE_PTR_TYPE(VOGL_GLSYNC)
226 DEF_OPAQUE_PTR_TYPE(VOGL_GLXCONTEXT)
227 DEF_OPAQUE_PTR_TYPE(VOGL_CONST_GLXCONTEXT)
228 DEF_OPAQUE_PTR_TYPE(VOGL_GLXFBCONFIG)
229 DEF_OPAQUE_PTR_TYPE(VOGL_DISPLAY_PTR)
230 DEF_OPAQUE_PTR_TYPE(VOGL_STRUCT_CLCONTEXT_PTR)
231 DEF_OPAQUE_PTR_TYPE(VOGL_STRUCT_CLEVENT_PTR)
232 //DEF_OPAQUE_PTR_TYPE(VOGL_CONST_XVISUALINFO_PTR)
233 //DEF_OPAQUE_PTR_TYPE(VOGL_XVISUALINFO_PTR)
235 DEF_OPAQUE_TYPE(VOGL_VOID)
236 DEF_OPAQUE_TYPE(VOGL_WINDOW)
237 DEF_OPAQUE_TYPE(VOGL_XVISUALINFO)
238 DEF_OPAQUE_TYPE(VOGL_COLORMAP) // rg - added 11/14/13
240 #undef DEF_OPAQUE_PTR_TYPE
241 #undef DEF_OPAQUE_TYPE
243 // Define pointer diff types
244 #define DEF_POINTER_DIFF_TYPE(x) g_vogl_ctype_descs[x].m_is_pointer_diff = true;
245 DEF_POINTER_DIFF_TYPE(VOGL_GLVDPAUSURFACENV)
246 DEF_POINTER_DIFF_TYPE(VOGL_GLINTPTR)
247 DEF_POINTER_DIFF_TYPE(VOGL_GLINTPTRARB)
248 DEF_POINTER_DIFF_TYPE(VOGL_GLSIZEIPTR)
249 DEF_POINTER_DIFF_TYPE(VOGL_GLSIZEIPTRARB)
250 #undef DEF_POINTER_DIFF_TYPE
253 //----------------------------------------------------------------------------------------------------------------------
254 // vogl_init_gl_ctypes
255 //----------------------------------------------------------------------------------------------------------------------
256 void vogl_init_gl_ctypes()
259 #define DEF_TYPE(name, ctype) \
261 vogl_ctype_desc_t &desc = g_vogl_ctype_descs[name]; \
262 typedef Loki::TypeTraits<ctype> ctype_traits; \
263 desc.m_size = gl_ctype_sizeof<ctype>::size; \
264 desc.m_is_pointer = ctype_traits::isPointer; \
265 desc.m_loki_type_flags = ctype_traits::typeFlags; \
267 #include "gl_glx_ctypes.inc"
270 // Define ptr to pointee mappings
271 #define DEF_PTR_TO_POINTEE_TYPE(ptr_ctype, pointee_ctype) g_vogl_ctype_descs[ptr_ctype].m_pointee_ctype = pointee_ctype;
272 #include "gl_glx_ctypes_ptr_to_pointee.inc"
273 #undef DEF_PTR_TO_POINTEE_TYPE
275 vogl_define_special_ctypes();
277 for (int i = 0; i < VOGL_NUM_CTYPES; i++)
279 const vogl_ctype_desc_t &desc = g_vogl_ctype_descs[i];
280 bool has_pointee_ctype = (desc.m_pointee_ctype != VOGL_INVALID_CTYPE);
282 if (desc.m_is_pointer)
284 if (!has_pointee_ctype)
286 if (!desc.m_is_opaque_pointer)
287 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);
291 const vogl_ctype_desc_t &pointee_desc = g_vogl_ctype_descs[desc.m_pointee_ctype];
293 if ((desc.m_is_opaque_pointer) && (pointee_desc.m_size > 0))
295 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);
298 if ((!pointee_desc.m_size) && (desc.m_pointee_ctype != VOGL_GLVOID) && (desc.m_pointee_ctype != VOGL_VOID))
299 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);
302 else if (has_pointee_ctype)
303 vogl_warning_printf("%s: ctype %s is not a pointer, but has a pointee ctype!\n", VOGL_FUNCTION_NAME, desc.m_pName);
304 else if (desc.m_is_opaque_pointer)
305 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);
308 g_vogl_process_gl_ctypes.init();
310 if (vogl::check_for_command_line_param("--vogl_debug"))
311 vogl_dump_gl_ctypes();
314 for (uint ctype_iter = 0; ctype_iter < VOGL_NUM_CTYPES; ctype_iter++)
316 vogl_ctype_desc_t &desc = g_vogl_ctype_descs[ctype_iter];
317 if ((desc.m_is_pointer_diff) ||
318 (desc.m_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_POINTER)) ||
319 (desc.m_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_SIGNED_LONG)) ||
320 (desc.m_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_UNSIGNED_LONG)))
322 // This will fail on long long and unsigned long long, but GL/GLX don't use those types.
323 VOGL_ASSERT(desc.m_size == sizeof(void *));
327 VOGL_ASSERT(!desc.m_is_pointer && !desc.m_is_opaque_pointer);