3 * Mesa 3-D graphics library
6 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 * This file manages the OpenGL API dispatch layer.
29 * The dispatch table (struct _glapi_table) is basically just a list
30 * of function pointers.
31 * There are functions to set/get the current dispatch table for the
32 * current thread and to manage registration/dispatch of dynamically
33 * added extension functions.
35 * It's intended that this file and the other glapi*.[ch] files are
36 * flexible enough to be reused in several places: XFree86, DRI-
37 * based libGL.so, and perhaps the SGI SI.
39 * NOTE: There are no dependencies on Mesa in this code.
41 * Versions (API changes):
42 * 2000/02/23 - original version for Mesa 3.3 and XFree86 4.0
43 * 2001/01/16 - added dispatch override feature for Mesa 3.5
44 * 2002/06/28 - added _glapi_set_warning_func(), Mesa 4.1.
45 * 2002/10/01 - _glapi_get_proc_address() will now generate new entrypoints
46 * itself (using offset ~0). _glapi_add_entrypoint() can be
47 * called afterward and it'll fill in the correct dispatch
48 * offset. This allows DRI libGL to avoid probing for DRI
49 * drivers! No changes to the public glapi interface.
56 #include "glapioffsets.h"
57 #include "glapitable.h"
60 /***** BEGIN NO-OP DISPATCH *****/
62 static GLboolean WarnFlag
= GL_FALSE
;
63 static _glapi_warning_func warning_func
;
67 * Enable/disable printing of warning messages.
70 _glapi_noop_enable_warnings(GLboolean enable
)
76 * Register a callback function for reporting errors.
79 _glapi_set_warning_func( _glapi_warning_func func
)
87 if ((WarnFlag
|| getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG"))
97 #define KEYWORD1 static
98 #define KEYWORD2 GLAPIENTRY
99 #define NAME(func) NoOp##func
103 #define DISPATCH(func, args, msg) \
105 warning_func(NULL, "GL User Error: called without context:"); \
109 #define RETURN_DISPATCH(func, args, msg) \
111 warning_func(NULL, "GL User Error: called without context:"); \
116 #define DISPATCH_TABLE_NAME __glapi_noop_table
117 #define UNUSED_TABLE_NAME __usused_noop_functions
119 #define TABLE_ENTRY(name) (void *) NoOp##name
121 static int NoOpUnused(void)
124 warning_func(NULL
, "GL User Error: calling extension function without a current context\n");
129 #include "glapitemp.h"
131 /***** END NO-OP DISPATCH *****/
135 /***** BEGIN THREAD-SAFE DISPATCH *****/
140 * \name Multi-threaded control support variables
142 * If thread-safety is supported, there are two potential mechanisms that can
143 * be used. The old-style mechanism would set \c _glapi_Dispatch to a special
144 * thread-safe dispatch table. These dispatch routines would call
145 * \c _glapi_get_dispatch to get the actual dispatch pointer. In this
146 * setup \c _glapi_Dispatch could never be \c NULL. This dual layered
147 * dispatch setup performed great for single-threaded apps, but didn't
148 * perform well for multithreaded apps.
150 * In the new mechansim, there are two variables. The first is
151 * \c _glapi_DispatchTSD. In the single-threaded case, this variable points
152 * to the dispatch table. In the multi-threaded case, this variable is
153 * \c NULL, and thread-specific variable \c _gl_DispatchTSD points to the
154 * actual dispatch table. \c _glapi_DispatchTSD is used to signal to the
155 * static dispatch functions to call \c _glapi_get_dispatch to get the real
158 * Throughout the code \c _glapi_DispatchTSD == \c NULL is used to determine
159 * whether or not the application is multi-threaded.
162 _glthread_TSD _gl_DispatchTSD
; /**< Per-thread dispatch pointer */
163 static _glthread_TSD RealDispatchTSD
; /**< only when using override */
164 static _glthread_TSD ContextTSD
; /**< Per-thread context pointer */
168 #define DISPATCH_TABLE_NAME __glapi_threadsafe_table
169 #define UNUSED_TABLE_NAME __usused_threadsafe_functions
171 #define TABLE_ENTRY(name) (void *) gl##name
173 static int glUnused(void)
178 #include "glapitemp.h"
182 /***** END THREAD-SAFE DISPATCH *****/
186 struct _glapi_table
*_glapi_Dispatch
= (struct _glapi_table
*) __glapi_noop_table
;
187 struct _glapi_table
*_glapi_DispatchTSD
= (struct _glapi_table
*) __glapi_noop_table
;
188 struct _glapi_table
*_glapi_RealDispatch
= (struct _glapi_table
*) __glapi_noop_table
;
190 /* Used when thread safety disabled */
191 void *_glapi_Context
= NULL
;
194 static GLboolean DispatchOverride
= GL_FALSE
;
198 /* strdup() is actually not a standard ANSI C or POSIX routine.
199 * Irix will not define it if ANSI mode is in effect.
202 str_dup(const char *str
)
205 copy
= (char*) malloc(strlen(str
) + 1);
215 * We should call this periodically from a function such as glXMakeCurrent
216 * in order to test if multiple threads are being used.
219 _glapi_check_multithread(void)
222 if ( _glapi_DispatchTSD
!= NULL
) {
223 static unsigned long knownID
;
224 static GLboolean firstCall
= GL_TRUE
;
226 knownID
= _glthread_GetID();
227 firstCall
= GL_FALSE
;
229 else if (knownID
!= _glthread_GetID()) {
230 _glapi_set_dispatch(NULL
);
233 else if (!_glapi_get_dispatch()) {
234 /* make sure that this thread's dispatch pointer isn't null */
235 _glapi_set_dispatch(NULL
);
243 * Set the current context pointer for this thread.
244 * The context pointer is an opaque type which should be cast to
245 * void from the real context pointer type.
248 _glapi_set_context(void *context
)
251 _glthread_SetTSD(&ContextTSD
, context
);
252 _glapi_Context
= (_glapi_DispatchTSD
== NULL
) ? NULL
: context
;
254 _glapi_Context
= context
;
261 * Get the current context pointer for this thread.
262 * The context pointer is an opaque type which should be cast from
263 * void to the real context pointer type.
266 _glapi_get_context(void)
269 if ( _glapi_DispatchTSD
== NULL
) {
270 return _glthread_GetTSD(&ContextTSD
);
273 return _glapi_Context
;
276 return _glapi_Context
;
283 * Set the global or per-thread dispatch table pointer.
286 _glapi_set_dispatch(struct _glapi_table
*dispatch
)
288 struct _glapi_table
* old_style_dispatch
;
291 /* Use the no-op functions if a NULL dispatch table was requested.
294 old_style_dispatch
= (struct _glapi_table
*) (dispatch
== NULL
)
295 ? __glapi_noop_table
: dispatch
;
298 if (dispatch
!= NULL
) {
299 _glapi_check_table(dispatch
);
304 if (DispatchOverride
) {
305 _glthread_SetTSD(&RealDispatchTSD
, (void *) old_style_dispatch
);
306 if ( dispatch
== NULL
)
307 _glapi_RealDispatch
= (struct _glapi_table
*) __glapi_threadsafe_table
;
309 _glapi_RealDispatch
= dispatch
;
312 /* normal operation */
313 _glthread_SetTSD(&_gl_DispatchTSD
, (void *) old_style_dispatch
);
314 _glapi_DispatchTSD
= dispatch
;
316 _glapi_Dispatch
= (dispatch
== NULL
)
317 ? (struct _glapi_table
*) __glapi_threadsafe_table
318 : old_style_dispatch
;
321 if (DispatchOverride
) {
322 _glapi_RealDispatch
= dispatch
;
325 _glapi_Dispatch
= dispatch
;
333 * Return pointer to current dispatch table for calling thread.
335 struct _glapi_table
*
336 _glapi_get_dispatch(void)
339 if ( _glapi_DispatchTSD
== NULL
) {
340 if (DispatchOverride
) {
341 return (struct _glapi_table
*) _glthread_GetTSD(&RealDispatchTSD
);
344 return (struct _glapi_table
*) _glthread_GetTSD(&_gl_DispatchTSD
);
348 if (DispatchOverride
) {
349 assert(_glapi_RealDispatch
);
350 return _glapi_RealDispatch
;
353 assert(_glapi_DispatchTSD
);
354 return _glapi_DispatchTSD
;
358 return _glapi_Dispatch
;
364 * Notes on dispatch overrride:
366 * Dispatch override allows an external agent to hook into the GL dispatch
367 * mechanism before execution goes into the core rendering library. For
368 * example, a trace mechanism would insert itself as an overrider, print
369 * logging info for each GL function, then dispatch to the real GL function.
371 * libGLS (GL Stream library) is another agent that might use override.
373 * We don't allow more than one layer of overriding at this time.
374 * In the future we may allow nested/layered override. In that case
375 * _glapi_begin_dispatch_override() will return an override layer,
376 * _glapi_end_dispatch_override(layer) will remove an override layer
377 * and _glapi_get_override_dispatch(layer) will return the dispatch
378 * table for a given override layer. layer = 0 will be the "real"
383 * Return: dispatch override layer number.
386 _glapi_begin_dispatch_override(struct _glapi_table
*override
)
388 struct _glapi_table
*real
= _glapi_get_dispatch();
390 assert(!DispatchOverride
); /* can't nest at this time */
391 DispatchOverride
= GL_TRUE
;
393 _glapi_set_dispatch(real
);
396 _glthread_SetTSD(&_gl_DispatchTSD
, (void *) override
);
397 if ( _glapi_DispatchTSD
== NULL
) {
398 _glapi_Dispatch
= (struct _glapi_table
*) __glapi_threadsafe_table
;
401 _glapi_Dispatch
= override
;
402 _glapi_DispatchTSD
= override
;
405 _glapi_Dispatch
= override
;
412 _glapi_end_dispatch_override(int layer
)
414 struct _glapi_table
*real
= _glapi_get_dispatch();
416 DispatchOverride
= GL_FALSE
;
417 _glapi_set_dispatch(real
);
418 /* the rest of this isn't needed, just play it safe */
420 _glthread_SetTSD(&RealDispatchTSD
, NULL
);
422 _glapi_RealDispatch
= NULL
;
426 struct _glapi_table
*
427 _glapi_get_override_dispatch(int layer
)
430 return _glapi_get_dispatch();
433 if (DispatchOverride
) {
435 return (struct _glapi_table
*) _glthread_GetTSD(&_gl_DispatchTSD
);
437 return _glapi_Dispatch
;
447 struct name_address_offset
{
454 #if !defined( USE_X86_ASM )
455 #define NEED_FUNCTION_POINTER
458 /* The code in this file is auto-generated with Python */
462 static const glprocs_table_t
*
463 find_entry( const char * n
)
467 for ( i
= 0 ; static_functions
[i
].Name_offset
>= 0 ; i
++ ) {
468 const char * test_name
;
470 test_name
= gl_string_table
+ static_functions
[i
].Name_offset
;
471 if (strcmp(test_name
, n
) == 0) {
472 return & static_functions
[i
];
479 * Return dispatch table offset of the named static (built-in) function.
480 * Return -1 if function not found.
483 get_static_proc_offset(const char *funcName
)
485 const glprocs_table_t
* const f
= find_entry( funcName
);
495 extern const GLubyte gl_dispatch_functions_start
[];
497 # if defined(PTHREADS)
498 # define X86_DISPATCH_FUNCTION_SIZE 32
500 # define X86_DISPATCH_FUNCTION_SIZE 16
505 * Return dispatch function address the named static (built-in) function.
506 * Return NULL if function not found.
508 static const GLvoid
*
509 get_static_proc_address(const char *funcName
)
511 const glprocs_table_t
* const f
= find_entry( funcName
);
514 return gl_dispatch_functions_start
515 + (X86_DISPATCH_FUNCTION_SIZE
* f
->Offset
);
526 * Return dispatch function address the named static (built-in) function.
527 * Return NULL if function not found.
529 static const GLvoid
*
530 get_static_proc_address(const char *funcName
)
532 const glprocs_table_t
* const f
= find_entry( funcName
);
533 return ( f
!= NULL
) ? f
->Address
: NULL
;
536 #endif /* USE_X86_ASM */
540 get_static_proc_name( GLuint offset
)
544 for ( i
= 0 ; static_functions
[i
].Name_offset
>= 0 ; i
++ ) {
545 if (static_functions
[i
].Offset
== offset
) {
546 return gl_string_table
+ static_functions
[i
].Name_offset
;
554 /**********************************************************************
555 * Extension function management.
559 * Number of extension functions which we can dynamically add at runtime.
561 #define MAX_EXTENSION_FUNCS 300
565 * The disptach table size (number of entries) is the sizeof the
566 * _glapi_table struct plus the number of dynamic entries we can add.
567 * The extra slots can be filled in by DRI drivers that register new extension
570 #define DISPATCH_TABLE_SIZE (sizeof(struct _glapi_table) / sizeof(void *) + MAX_EXTENSION_FUNCS)
573 static struct name_address_offset ExtEntryTable
[MAX_EXTENSION_FUNCS
];
574 static GLuint NumExtEntryPoints
= 0;
577 extern void __glapi_sparc_icache_flush(unsigned int *);
581 * Generate a dispatch function (entrypoint) which jumps through
582 * the given slot number (offset) in the current dispatch table.
583 * We need assembly language in order to accomplish this.
586 generate_entrypoint(GLuint functionOffset
)
588 #if defined(USE_X86_ASM)
590 * This x86 code contributed by Josh Vanderhoof.
592 * 0: a1 10 32 54 76 movl __glapi_Dispatch,%eax
594 * 5: 85 c0 testl %eax,%eax
596 * 7: 74 06 je f <entrypoint+0xf>
598 * 9: ff a0 10 32 54 76 jmp *0x76543210(%eax)
600 * f: e8 fc ff ff ff call __glapi_get_dispatch
602 * 14: ff a0 10 32 54 76 jmp *0x76543210(%eax)
605 static const unsigned char insn_template
[] = {
606 0xa1, 0x00, 0x00, 0x00, 0x00,
609 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00,
610 0xe8, 0x00, 0x00, 0x00, 0x00,
611 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00
613 unsigned char *code
= (unsigned char *) malloc(sizeof(insn_template
));
614 unsigned int next_insn
;
616 memcpy(code
, insn_template
, sizeof(insn_template
));
618 *(unsigned int *)(code
+ 0x01) = (unsigned int)&_glapi_DispatchTSD
;
619 *(unsigned int *)(code
+ 0x0b) = (unsigned int)functionOffset
* 4;
620 next_insn
= (unsigned int)(code
+ 0x14);
621 *(unsigned int *)(code
+ 0x10) = (unsigned int)_glapi_get_dispatch
- next_insn
;
622 *(unsigned int *)(code
+ 0x16) = (unsigned int)functionOffset
* 4;
625 #elif defined(USE_SPARC_ASM)
627 #if defined(__sparc_v9__) && !defined(__linux__)
628 static const unsigned int insn_template
[] = {
629 0x05000000, /* sethi %uhi(_glapi_Dispatch), %g2 */
630 0x03000000, /* sethi %hi(_glapi_Dispatch), %g1 */
631 0x8410a000, /* or %g2, %ulo(_glapi_Dispatch), %g2 */
632 0x82106000, /* or %g1, %lo(_glapi_Dispatch), %g1 */
633 0x8528b020, /* sllx %g2, 32, %g2 */
634 0xc2584002, /* ldx [%g1 + %g2], %g1 */
635 0x05000000, /* sethi %hi(8 * glapioffset), %g2 */
636 0x8410a000, /* or %g2, %lo(8 * glapioffset), %g2 */
637 0xc6584002, /* ldx [%g1 + %g2], %g3 */
638 0x81c0c000, /* jmpl %g3, %g0 */
642 static const unsigned int insn_template
[] = {
643 0x03000000, /* sethi %hi(_glapi_Dispatch), %g1 */
644 0xc2006000, /* ld [%g1 + %lo(_glapi_Dispatch)], %g1 */
645 0xc6006000, /* ld [%g1 + %lo(4*glapioffset)], %g3 */
646 0x81c0c000, /* jmpl %g3, %g0 */
650 unsigned int *code
= (unsigned int *) malloc(sizeof(insn_template
));
651 unsigned long glapi_addr
= (unsigned long) &_glapi_Dispatch
;
653 memcpy(code
, insn_template
, sizeof(insn_template
));
655 #if defined(__sparc_v9__) && !defined(__linux__)
656 code
[0] |= (glapi_addr
>> (32 + 10));
657 code
[1] |= ((glapi_addr
& 0xffffffff) >> 10);
658 __glapi_sparc_icache_flush(&code
[0]);
659 code
[2] |= ((glapi_addr
>> 32) & ((1 << 10) - 1));
660 code
[3] |= (glapi_addr
& ((1 << 10) - 1));
661 __glapi_sparc_icache_flush(&code
[2]);
662 code
[6] |= ((functionOffset
* 8) >> 10);
663 code
[7] |= ((functionOffset
* 8) & ((1 << 10) - 1));
664 __glapi_sparc_icache_flush(&code
[6]);
666 code
[0] |= (glapi_addr
>> 10);
667 code
[1] |= (glapi_addr
& ((1 << 10) - 1));
668 __glapi_sparc_icache_flush(&code
[0]);
669 code
[2] |= (functionOffset
* 4);
670 __glapi_sparc_icache_flush(&code
[2]);
676 #endif /* USE_*_ASM */
681 * This function inserts a new dispatch offset into the assembly language
682 * stub that was generated with the preceeding function.
685 fill_in_entrypoint_offset(void *entrypoint
, GLuint offset
)
687 #if defined(USE_X86_ASM)
689 unsigned char *code
= (unsigned char *) entrypoint
;
690 *(unsigned int *)(code
+ 0x0b) = offset
* 4;
691 *(unsigned int *)(code
+ 0x16) = offset
* 4;
693 #elif defined(USE_SPARC_ASM)
695 /* XXX this hasn't been tested! */
696 unsigned int *code
= (unsigned int *) entrypoint
;
697 #if defined(__sparc_v9__) && !defined(__linux__)
698 code
[6] = 0x05000000; /* sethi %hi(8 * glapioffset), %g2 */
699 code
[7] = 0x8410a000; /* or %g2, %lo(8 * glapioffset), %g2 */
700 code
[6] |= ((offset
* 8) >> 10);
701 code
[7] |= ((offset
* 8) & ((1 << 10) - 1));
702 __glapi_sparc_icache_flush(&code
[6]);
703 #else /* __sparc_v9__ && !linux */
704 code
[2] = 0xc6006000; /* ld [%g1 + %lo(4*glapioffset)], %g3 */
705 code
[2] |= (offset
* 4);
706 __glapi_sparc_icache_flush(&code
[2]);
707 #endif /* __sparc_v9__ && !linux */
709 #endif /* USE_*_ASM */
714 * Add a new extension function entrypoint.
715 * Return: GL_TRUE = success or GL_FALSE = failure
718 _glapi_add_entrypoint(const char *funcName
, GLuint offset
)
720 /* trivial rejection test */
722 if (!funcName
|| funcName
[0] != 'm' || funcName
[1] != 'g' || funcName
[2] != 'l')
725 if (!funcName
|| funcName
[0] != 'g' || funcName
[1] != 'l')
729 /* first check if the named function is already statically present */
731 GLint index
= get_static_proc_offset(funcName
);
733 return (GLboolean
) ((GLuint
) index
== offset
); /* bad offset! */
737 /* See if this function has already been dynamically added */
740 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
741 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
742 /* function already registered */
743 if (ExtEntryTable
[i
].Offset
== offset
) {
744 return GL_TRUE
; /* offsets match */
746 else if (ExtEntryTable
[i
].Offset
== (GLuint
) ~0
747 && offset
< DISPATCH_TABLE_SIZE
) {
748 /* need to patch-up the dispatch code */
749 if (offset
!= (GLuint
) ~0) {
750 fill_in_entrypoint_offset(ExtEntryTable
[i
].Address
, offset
);
751 ExtEntryTable
[i
].Offset
= offset
;
756 return GL_FALSE
; /* bad offset! */
762 /* This is a new function, try to add it. */
763 if (NumExtEntryPoints
>= MAX_EXTENSION_FUNCS
||
764 offset
>= DISPATCH_TABLE_SIZE
) {
769 void *entrypoint
= generate_entrypoint(offset
);
771 return GL_FALSE
; /* couldn't generate assembly */
774 ExtEntryTable
[NumExtEntryPoints
].Name
= str_dup(funcName
);
775 ExtEntryTable
[NumExtEntryPoints
].Offset
= offset
;
776 ExtEntryTable
[NumExtEntryPoints
].Address
= entrypoint
;
779 return GL_TRUE
; /* success */
782 /* should never get here, silence compiler warnings */
788 * Return offset of entrypoint for named function within dispatch table.
791 _glapi_get_proc_offset(const char *funcName
)
793 /* search extension functions first */
795 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
796 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
797 return ExtEntryTable
[i
].Offset
;
801 /* search static functions */
802 return get_static_proc_offset(funcName
);
808 * Return entrypoint for named function.
811 _glapi_get_proc_address(const char *funcName
)
816 if (funcName
[0] != 'm' || funcName
[1] != 'g' || funcName
[2] != 'l')
819 if (funcName
[0] != 'g' || funcName
[1] != 'l')
823 /* search extension functions first */
824 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
825 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
826 return ExtEntryTable
[i
].Address
;
830 /* search static functions */
832 const GLvoid
*func
= get_static_proc_address(funcName
);
837 /* generate new entrypoint - use a temporary dispatch offset of
838 * ~0 (i.e. -1). Later, when the driver calls _glapi_add_entrypoint()
839 * we'll put in the proper offset. If that never happens, and the
840 * user calls this function, he'll segfault. That's what you get
841 * when you try calling a GL function that doesn't really exist.
843 if (NumExtEntryPoints
< MAX_EXTENSION_FUNCS
) {
844 GLvoid
*entrypoint
= generate_entrypoint(~0);
848 ExtEntryTable
[NumExtEntryPoints
].Name
= str_dup(funcName
);
849 ExtEntryTable
[NumExtEntryPoints
].Offset
= ~0;
850 ExtEntryTable
[NumExtEntryPoints
].Address
= entrypoint
;
856 /* no space for new functions! */
864 * Return the name of the function at the given dispatch offset.
865 * This is only intended for debugging.
868 _glapi_get_proc_name(GLuint offset
)
873 /* search built-in functions */
874 n
= get_static_proc_name(offset
);
879 /* search added extension functions */
880 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
881 if (ExtEntryTable
[i
].Offset
== offset
) {
882 return ExtEntryTable
[i
].Name
;
891 * Return size of dispatch table struct as number of functions (or
895 _glapi_get_dispatch_table_size(void)
897 return DISPATCH_TABLE_SIZE
;
903 * Get API dispatcher version string.
906 _glapi_get_version(void)
908 return "20021001"; /* YYYYMMDD */
914 * Make sure there are no NULL pointers in the given dispatch table.
915 * Intended for debugging purposes.
918 _glapi_check_table(const struct _glapi_table
*table
)
921 const GLuint entries
= _glapi_get_dispatch_table_size();
922 const void **tab
= (const void **) table
;
924 for (i
= 1; i
< entries
; i
++) {
928 /* Do some spot checks to be sure that the dispatch table
929 * slots are assigned correctly.
932 GLuint BeginOffset
= _glapi_get_proc_offset("glBegin");
933 char *BeginFunc
= (char*) &table
->Begin
;
934 GLuint offset
= (BeginFunc
- (char *) table
) / sizeof(void *);
935 assert(BeginOffset
== _gloffset_Begin
);
936 assert(BeginOffset
== offset
);
939 GLuint viewportOffset
= _glapi_get_proc_offset("glViewport");
940 char *viewportFunc
= (char*) &table
->Viewport
;
941 GLuint offset
= (viewportFunc
- (char *) table
) / sizeof(void *);
942 assert(viewportOffset
== _gloffset_Viewport
);
943 assert(viewportOffset
== offset
);
946 GLuint VertexPointerOffset
= _glapi_get_proc_offset("glVertexPointer");
947 char *VertexPointerFunc
= (char*) &table
->VertexPointer
;
948 GLuint offset
= (VertexPointerFunc
- (char *) table
) / sizeof(void *);
949 assert(VertexPointerOffset
== _gloffset_VertexPointer
);
950 assert(VertexPointerOffset
== offset
);
953 GLuint ResetMinMaxOffset
= _glapi_get_proc_offset("glResetMinmax");
954 char *ResetMinMaxFunc
= (char*) &table
->ResetMinmax
;
955 GLuint offset
= (ResetMinMaxFunc
- (char *) table
) / sizeof(void *);
956 assert(ResetMinMaxOffset
== _gloffset_ResetMinmax
);
957 assert(ResetMinMaxOffset
== offset
);
960 GLuint blendColorOffset
= _glapi_get_proc_offset("glBlendColor");
961 char *blendColorFunc
= (char*) &table
->BlendColor
;
962 GLuint offset
= (blendColorFunc
- (char *) table
) / sizeof(void *);
963 assert(blendColorOffset
== _gloffset_BlendColor
);
964 assert(blendColorOffset
== offset
);
967 GLuint istextureOffset
= _glapi_get_proc_offset("glIsTextureEXT");
968 char *istextureFunc
= (char*) &table
->IsTextureEXT
;
969 GLuint offset
= (istextureFunc
- (char *) table
) / sizeof(void *);
970 assert(istextureOffset
== _gloffset_IsTextureEXT
);
971 assert(istextureOffset
== offset
);
974 GLuint secondaryColor3fOffset
= _glapi_get_proc_offset("glSecondaryColor3fEXT");
975 char *secondaryColor3fFunc
= (char*) &table
->SecondaryColor3fEXT
;
976 GLuint offset
= (secondaryColor3fFunc
- (char *) table
) / sizeof(void *);
977 assert(secondaryColor3fOffset
== _gloffset_SecondaryColor3fEXT
);
978 assert(secondaryColor3fOffset
== offset
);
979 assert(_glapi_get_proc_address("glSecondaryColor3fEXT") == (void *) &glSecondaryColor3fEXT
);
982 GLuint pointParameterivOffset
= _glapi_get_proc_offset("glPointParameterivNV");
983 char *pointParameterivFunc
= (char*) &table
->PointParameterivNV
;
984 GLuint offset
= (pointParameterivFunc
- (char *) table
) / sizeof(void *);
985 assert(pointParameterivOffset
== _gloffset_PointParameterivNV
);
986 assert(pointParameterivOffset
== offset
);
987 assert(_glapi_get_proc_address("glPointParameterivNV") == (void *) &glPointParameterivNV
);
990 GLuint setFenceOffset
= _glapi_get_proc_offset("glSetFenceNV");
991 char *setFenceFunc
= (char*) &table
->SetFenceNV
;
992 GLuint offset
= (setFenceFunc
- (char *) table
) / sizeof(void *);
993 assert(setFenceOffset
== _gloffset_SetFenceNV
);
994 assert(setFenceOffset
== offset
);
995 assert(_glapi_get_proc_address("glSetFenceNV") == (void *) &glSetFenceNV
);