1 /* $Id: glapi.c,v 1.62 2002/05/29 15:23:16 brianp Exp $ */
4 * Mesa 3-D graphics library
7 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 * This file manages the OpenGL API dispatch layer.
30 * The dispatch table (struct _glapi_table) is basically just a list
31 * of function pointers.
32 * There are functions to set/get the current dispatch table for the
33 * current thread and to manage registration/dispatch of dynamically
34 * added extension functions.
36 * It's intended that this file and the other glapi*.[ch] files are
37 * flexible enough to be reused in several places: XFree86, DRI-
38 * based libGL.so, and perhaps the SGI SI.
40 * There are no dependencies on Mesa in this code.
42 * Versions (API changes):
43 * 2000/02/23 - original version for Mesa 3.3 and XFree86 4.0
44 * 2001/01/16 - added dispatch override feature for Mesa 3.5
51 #include "glapioffsets.h"
52 #include "glapitable.h"
55 /***** BEGIN NO-OP DISPATCH *****/
57 static GLboolean WarnFlag
= GL_FALSE
;
60 _glapi_noop_enable_warnings(GLboolean enable
)
68 if (WarnFlag
|| getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG"))
75 #define KEYWORD1 static
77 #define NAME(func) NoOp##func
81 #define DISPATCH(func, args, msg) \
83 fprintf(stderr, "GL User Error: calling "); \
85 fprintf(stderr, " without a current context\n"); \
88 #define RETURN_DISPATCH(func, args, msg) \
90 fprintf(stderr, "GL User Error: calling "); \
92 fprintf(stderr, " without a current context\n"); \
96 #define DISPATCH_TABLE_NAME __glapi_noop_table
97 #define UNUSED_TABLE_NAME __usused_noop_functions
99 #define TABLE_ENTRY(name) (void *) NoOp##name
101 static int NoOpUnused(void)
104 fprintf(stderr
, "GL User Error: calling extension function without a current context\n");
109 #include "glapitemp.h"
111 /***** END NO-OP DISPATCH *****/
115 /***** BEGIN THREAD-SAFE DISPATCH *****/
116 /* if we support thread-safety, build a special dispatch table for use
117 * in thread-safety mode (ThreadSafe == GL_TRUE). Each entry in the
118 * dispatch table will call _glthread_GetTSD() to get the actual dispatch
119 * table bound to the current thread, then jump through that table.
124 static GLboolean ThreadSafe
= GL_FALSE
; /* In thread-safe mode? */
125 static _glthread_TSD DispatchTSD
; /* Per-thread dispatch pointer */
126 static _glthread_TSD RealDispatchTSD
; /* only when using override */
127 static _glthread_TSD ContextTSD
; /* Per-thread context pointer */
130 #define KEYWORD1 static
131 #define KEYWORD2 GLAPIENTRY
132 #define NAME(func) _ts_##func
134 #define DISPATCH(FUNC, ARGS, MESSAGE) \
135 struct _glapi_table *dispatch; \
136 dispatch = (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD); \
138 dispatch = (struct _glapi_table *) __glapi_noop_table; \
139 (dispatch->FUNC) ARGS
141 #define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) \
142 struct _glapi_table *dispatch; \
143 dispatch = (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD); \
145 dispatch = (struct _glapi_table *) __glapi_noop_table; \
146 return (dispatch->FUNC) ARGS
148 #define DISPATCH_TABLE_NAME __glapi_threadsafe_table
149 #define UNUSED_TABLE_NAME __usused_threadsafe_functions
151 #define TABLE_ENTRY(name) (void *) _ts_##name
153 static int _ts_Unused(void)
158 #include "glapitemp.h"
162 /***** END THREAD-SAFE DISPATCH *****/
166 struct _glapi_table
*_glapi_Dispatch
= (struct _glapi_table
*) __glapi_noop_table
;
167 struct _glapi_table
*_glapi_RealDispatch
= (struct _glapi_table
*) __glapi_noop_table
;
169 /* Used when thread safety disabled */
170 void *_glapi_Context
= NULL
;
173 static GLuint MaxDispatchOffset
= sizeof(struct _glapi_table
) / sizeof(void *) - 1;
174 static GLboolean GetSizeCalled
= GL_FALSE
;
176 static GLboolean DispatchOverride
= GL_FALSE
;
179 /* strdup() is actually not a standard ANSI C or POSIX routine.
180 * Irix will not define it if ANSI mode is in effect.
183 str_dup(const char *str
)
186 copy
= (char*) malloc(strlen(str
) + 1);
196 * We should call this periodically from a function such as glXMakeCurrent
197 * in order to test if multiple threads are being used.
200 _glapi_check_multithread(void)
204 static unsigned long knownID
;
205 static GLboolean firstCall
= GL_TRUE
;
207 knownID
= _glthread_GetID();
208 firstCall
= GL_FALSE
;
210 else if (knownID
!= _glthread_GetID()) {
211 ThreadSafe
= GL_TRUE
;
215 /* make sure that this thread's dispatch pointer isn't null */
216 if (!_glapi_get_dispatch()) {
217 _glapi_set_dispatch(NULL
);
226 * Set the current context pointer for this thread.
227 * The context pointer is an opaque type which should be cast to
228 * void from the real context pointer type.
231 _glapi_set_context(void *context
)
234 _glthread_SetTSD(&ContextTSD
, context
);
236 _glapi_Context
= NULL
;
238 _glapi_Context
= context
;
240 _glapi_Context
= context
;
247 * Get the current context pointer for this thread.
248 * The context pointer is an opaque type which should be cast from
249 * void to the real context pointer type.
252 _glapi_get_context(void)
256 return _glthread_GetTSD(&ContextTSD
);
259 return _glapi_Context
;
262 return _glapi_Context
;
269 * Set the global or per-thread dispatch table pointer.
272 _glapi_set_dispatch(struct _glapi_table
*dispatch
)
275 /* use the no-op functions */
276 dispatch
= (struct _glapi_table
*) __glapi_noop_table
;
280 _glapi_check_table(dispatch
);
285 if (DispatchOverride
) {
286 _glthread_SetTSD(&RealDispatchTSD
, (void *) dispatch
);
288 _glapi_RealDispatch
= (struct _glapi_table
*) __glapi_threadsafe_table
;
290 _glapi_RealDispatch
= dispatch
;
293 /* normal operation */
294 _glthread_SetTSD(&DispatchTSD
, (void *) dispatch
);
296 _glapi_Dispatch
= (struct _glapi_table
*) __glapi_threadsafe_table
;
298 _glapi_Dispatch
= dispatch
;
301 if (DispatchOverride
) {
302 _glapi_RealDispatch
= dispatch
;
305 _glapi_Dispatch
= dispatch
;
313 * Return pointer to current dispatch table for calling thread.
315 struct _glapi_table
*
316 _glapi_get_dispatch(void)
320 if (DispatchOverride
) {
321 return (struct _glapi_table
*) _glthread_GetTSD(&RealDispatchTSD
);
324 return (struct _glapi_table
*) _glthread_GetTSD(&DispatchTSD
);
328 if (DispatchOverride
) {
329 assert(_glapi_RealDispatch
);
330 return _glapi_RealDispatch
;
333 assert(_glapi_Dispatch
);
334 return _glapi_Dispatch
;
338 return _glapi_Dispatch
;
344 * Notes on dispatch overrride:
346 * Dispatch override allows an external agent to hook into the GL dispatch
347 * mechanism before execution goes into the core rendering library. For
348 * example, a trace mechanism would insert itself as an overrider, print
349 * logging info for each GL function, then dispatch to the real GL function.
351 * libGLS (GL Stream library) is another agent that might use override.
353 * We don't allow more than one layer of overriding at this time.
354 * In the future we may allow nested/layered override. In that case
355 * _glapi_begin_dispatch_override() will return an override layer,
356 * _glapi_end_dispatch_override(layer) will remove an override layer
357 * and _glapi_get_override_dispatch(layer) will return the dispatch
358 * table for a given override layer. layer = 0 will be the "real"
363 * Return: dispatch override layer number.
366 _glapi_begin_dispatch_override(struct _glapi_table
*override
)
368 struct _glapi_table
*real
= _glapi_get_dispatch();
370 assert(!DispatchOverride
); /* can't nest at this time */
371 DispatchOverride
= GL_TRUE
;
373 _glapi_set_dispatch(real
);
376 _glthread_SetTSD(&DispatchTSD
, (void *) override
);
378 _glapi_Dispatch
= (struct _glapi_table
*) __glapi_threadsafe_table
;
380 _glapi_Dispatch
= override
;
382 _glapi_Dispatch
= override
;
389 _glapi_end_dispatch_override(int layer
)
391 struct _glapi_table
*real
= _glapi_get_dispatch();
393 DispatchOverride
= GL_FALSE
;
394 _glapi_set_dispatch(real
);
395 /* the rest of this isn't needed, just play it safe */
397 _glthread_SetTSD(&RealDispatchTSD
, NULL
);
399 _glapi_RealDispatch
= NULL
;
403 struct _glapi_table
*
404 _glapi_get_override_dispatch(int layer
)
407 return _glapi_get_dispatch();
410 if (DispatchOverride
) {
412 return (struct _glapi_table
*) _glthread_GetTSD(&DispatchTSD
);
414 return _glapi_Dispatch
;
426 * Return size of dispatch table struct as number of functions (or
430 _glapi_get_dispatch_table_size(void)
432 /* return sizeof(struct _glapi_table) / sizeof(void *);*/
433 GetSizeCalled
= GL_TRUE
;
434 return MaxDispatchOffset
+ 1;
440 * Get API dispatcher version string.
443 _glapi_get_version(void)
445 return "20010116"; /* YYYYMMDD */
449 struct name_address_offset
{
456 /* The code in this file is auto-generated */
462 * Return dispatch table offset of the named static (built-in) function.
463 * Return -1 if function not found.
466 get_static_proc_offset(const char *funcName
)
469 for (i
= 0; static_functions
[i
].Name
; i
++) {
470 if (strcmp(static_functions
[i
].Name
, funcName
) == 0) {
471 return static_functions
[i
].Offset
;
479 * Return dispatch function address the named static (built-in) function.
480 * Return NULL if function not found.
483 get_static_proc_address(const char *funcName
)
486 for (i
= 0; static_functions
[i
].Name
; i
++) {
487 if (strcmp(static_functions
[i
].Name
, funcName
) == 0) {
488 return static_functions
[i
].Address
;
496 /**********************************************************************
497 * Extension function management.
501 #define MAX_EXTENSION_FUNCS 1000
503 static struct name_address_offset ExtEntryTable
[MAX_EXTENSION_FUNCS
];
504 static GLuint NumExtEntryPoints
= 0;
507 extern void __glapi_sparc_icache_flush(unsigned int *);
511 * Generate a dispatch function (entrypoint) which jumps through
512 * the given slot number (offset) in the current dispatch table.
513 * We need assembly language in order to accomplish this.
516 generate_entrypoint(GLuint functionOffset
)
518 #if defined(USE_X86_ASM)
520 * This x86 code contributed by Josh Vanderhoof.
522 * 0: a1 10 32 54 76 movl __glapi_Dispatch,%eax
524 * 5: 85 c0 testl %eax,%eax
526 * 7: 74 06 je f <entrypoint+0xf>
528 * 9: ff a0 10 32 54 76 jmp *0x76543210(%eax)
530 * f: e8 fc ff ff ff call __glapi_get_dispatch
532 * 14: ff a0 10 32 54 76 jmp *0x76543210(%eax)
535 static const unsigned char temp
[] = {
536 0xa1, 0x00, 0x00, 0x00, 0x00,
539 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00,
540 0xe8, 0x00, 0x00, 0x00, 0x00,
541 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00
543 unsigned char *code
= malloc(sizeof(temp
));
544 unsigned int next_insn
;
546 memcpy(code
, temp
, sizeof(temp
));
548 *(unsigned int *)(code
+ 0x01) = (unsigned int)&_glapi_Dispatch
;
549 *(unsigned int *)(code
+ 0x0b) = (unsigned int)functionOffset
* 4;
550 next_insn
= (unsigned int)(code
+ 0x14);
551 *(unsigned int *)(code
+ 0x10) = (unsigned int)_glapi_get_dispatch
- next_insn
;
552 *(unsigned int *)(code
+ 0x16) = (unsigned int)functionOffset
* 4;
555 #elif defined(USE_SPARC_ASM)
558 static const unsigned int insn_template
[] = {
559 0x05000000, /* sethi %uhi(_glapi_Dispatch), %g2 */
560 0x03000000, /* sethi %hi(_glapi_Dispatch), %g1 */
561 0x8410a000, /* or %g2, %ulo(_glapi_Dispatch), %g2 */
562 0x82106000, /* or %g1, %lo(_glapi_Dispatch), %g1 */
563 0x8528b020, /* sllx %g2, 32, %g2 */
564 0xc2584002, /* ldx [%g1 + %g2], %g1 */
565 0x05000000, /* sethi %hi(8 * glapioffset), %g2 */
566 0x8410a000, /* or %g2, %lo(8 * glapioffset), %g2 */
567 0xc6584002, /* ldx [%g1 + %g2], %g3 */
568 0x81c0c000, /* jmpl %g3, %g0 */
572 static const unsigned int insn_template
[] = {
573 0x03000000, /* sethi %hi(_glapi_Dispatch), %g1 */
574 0xc2006000, /* ld [%g1 + %lo(_glapi_Dispatch)], %g1 */
575 0xc6006000, /* ld [%g1 + %lo(4*glapioffset)], %g3 */
576 0x81c0c000, /* jmpl %g3, %g0 */
580 unsigned int *code
= malloc(sizeof(insn_template
));
581 unsigned long glapi_addr
= (unsigned long) &_glapi_Dispatch
;
583 memcpy(code
, insn_template
, sizeof(insn_template
));
586 code
[0] |= (glapi_addr
>> (32 + 10));
587 code
[1] |= ((glapi_addr
& 0xffffffff) >> 10);
588 __glapi_sparc_icache_flush(&code
[0]);
589 code
[2] |= ((glapi_addr
>> 32) & ((1 << 10) - 1));
590 code
[3] |= (glapi_addr
& ((1 << 10) - 1));
591 __glapi_sparc_icache_flush(&code
[2]);
592 code
[6] |= ((functionOffset
* 8) >> 10);
593 code
[7] |= ((functionOffset
* 8) & ((1 << 10) - 1));
594 __glapi_sparc_icache_flush(&code
[6]);
596 code
[0] |= (glapi_addr
>> 10);
597 code
[1] |= (glapi_addr
& ((1 << 10) - 1));
598 __glapi_sparc_icache_flush(&code
[0]);
599 code
[2] |= (functionOffset
* 4);
600 __glapi_sparc_icache_flush(&code
[2]);
612 * Add a new extension function entrypoint.
613 * Return: GL_TRUE = success or GL_FALSE = failure
616 _glapi_add_entrypoint(const char *funcName
, GLuint offset
)
618 /* first check if the named function is already statically present */
620 GLint index
= get_static_proc_offset(funcName
);
622 return (GLboolean
) ((GLuint
) index
== offset
); /* bad offset! */
627 /* make sure this offset/name pair is legal */
628 const char *name
= _glapi_get_proc_name(offset
);
629 if (name
&& strcmp(name
, funcName
) != 0)
630 return GL_FALSE
; /* bad name! */
634 /* be sure index and name match known data */
636 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
637 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
638 /* function already registered with api */
639 if (ExtEntryTable
[i
].Offset
== offset
) {
640 return GL_TRUE
; /* offsets match */
643 return GL_FALSE
; /* bad offset! */
648 /* Make sure we don't try to add a new entrypoint after someone
649 * has already called _glapi_get_dispatch_table_size()! If that's
650 * happened the caller's information would become out of date.
655 /* make sure we have space */
656 if (NumExtEntryPoints
>= MAX_EXTENSION_FUNCS
) {
660 void *entrypoint
= generate_entrypoint(offset
);
664 ExtEntryTable
[NumExtEntryPoints
].Name
= str_dup(funcName
);
665 ExtEntryTable
[NumExtEntryPoints
].Offset
= offset
;
666 ExtEntryTable
[NumExtEntryPoints
].Address
= entrypoint
;
669 if (offset
> MaxDispatchOffset
)
670 MaxDispatchOffset
= offset
;
672 return GL_TRUE
; /* success */
676 /* should never get here, but play it safe */
682 #if 0000 /* prototype code for dynamic extension slot allocation */
684 static int NextFreeOffset
= 409; /*XXX*/
685 #define MAX_DISPATCH_TABLE_SIZE 1000
688 * Dynamically allocate a dispatch slot for an extension entrypoint
689 * and generate the assembly language dispatch stub.
690 * Return the dispatch offset for the function or -1 if no room or error.
693 _glapi_add_entrypoint2(const char *funcName
)
697 /* first see if extension func is already known */
698 offset
= _glapi_get_proc_offset(funcName
);
702 if (NumExtEntryPoints
< MAX_EXTENSION_FUNCS
703 && NextFreeOffset
< MAX_DISPATCH_TABLE_SIZE
) {
705 offset
= NextFreeOffset
;
706 entryPoint
= generate_entrypoint(offset
);
709 ExtEntryTable
[NumExtEntryPoints
].Name
= str_dup(funcName
);
710 ExtEntryTable
[NumExtEntryPoints
].Offset
= offset
;
711 ExtEntryTable
[NumExtEntryPoints
].Address
= entryPoint
;
724 * Return offset of entrypoint for named function within dispatch table.
727 _glapi_get_proc_offset(const char *funcName
)
729 /* search extension functions first */
731 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
732 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
733 return ExtEntryTable
[i
].Offset
;
737 /* search static functions */
738 return get_static_proc_offset(funcName
);
744 * Return entrypoint for named function.
747 _glapi_get_proc_address(const char *funcName
)
749 /* search extension functions first */
751 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
752 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
753 return ExtEntryTable
[i
].Address
;
757 /* search static functions */
758 return get_static_proc_address(funcName
);
765 * Return the name of the function at the given dispatch offset.
766 * This is only intended for debugging.
769 _glapi_get_proc_name(GLuint offset
)
771 const GLuint n
= sizeof(static_functions
) / sizeof(struct name_address_offset
);
773 for (i
= 0; i
< n
; i
++) {
774 if (static_functions
[i
].Offset
== offset
)
775 return static_functions
[i
].Name
;
778 /* search added extension functions */
779 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
780 if (ExtEntryTable
[i
].Offset
== offset
) {
781 return ExtEntryTable
[i
].Name
;
790 * Make sure there are no NULL pointers in the given dispatch table.
791 * Intended for debugging purposes.
794 _glapi_check_table(const struct _glapi_table
*table
)
797 const GLuint entries
= _glapi_get_dispatch_table_size();
798 const void **tab
= (const void **) table
;
800 for (i
= 1; i
< entries
; i
++) {
804 /* Do some spot checks to be sure that the dispatch table
805 * slots are assigned correctly.
808 GLuint BeginOffset
= _glapi_get_proc_offset("glBegin");
809 char *BeginFunc
= (char*) &table
->Begin
;
810 GLuint offset
= (BeginFunc
- (char *) table
) / sizeof(void *);
811 assert(BeginOffset
== _gloffset_Begin
);
812 assert(BeginOffset
== offset
);
815 GLuint viewportOffset
= _glapi_get_proc_offset("glViewport");
816 char *viewportFunc
= (char*) &table
->Viewport
;
817 GLuint offset
= (viewportFunc
- (char *) table
) / sizeof(void *);
818 assert(viewportOffset
== _gloffset_Viewport
);
819 assert(viewportOffset
== offset
);
822 GLuint VertexPointerOffset
= _glapi_get_proc_offset("glVertexPointer");
823 char *VertexPointerFunc
= (char*) &table
->VertexPointer
;
824 GLuint offset
= (VertexPointerFunc
- (char *) table
) / sizeof(void *);
825 assert(VertexPointerOffset
== _gloffset_VertexPointer
);
826 assert(VertexPointerOffset
== offset
);
829 GLuint ResetMinMaxOffset
= _glapi_get_proc_offset("glResetMinmax");
830 char *ResetMinMaxFunc
= (char*) &table
->ResetMinmax
;
831 GLuint offset
= (ResetMinMaxFunc
- (char *) table
) / sizeof(void *);
832 assert(ResetMinMaxOffset
== _gloffset_ResetMinmax
);
833 assert(ResetMinMaxOffset
== offset
);
836 GLuint blendColorOffset
= _glapi_get_proc_offset("glBlendColor");
837 char *blendColorFunc
= (char*) &table
->BlendColor
;
838 GLuint offset
= (blendColorFunc
- (char *) table
) / sizeof(void *);
839 assert(blendColorOffset
== _gloffset_BlendColor
);
840 assert(blendColorOffset
== offset
);
843 GLuint istextureOffset
= _glapi_get_proc_offset("glIsTextureEXT");
844 char *istextureFunc
= (char*) &table
->IsTextureEXT
;
845 GLuint offset
= (istextureFunc
- (char *) table
) / sizeof(void *);
846 assert(istextureOffset
== _gloffset_IsTextureEXT
);
847 assert(istextureOffset
== offset
);
850 GLuint secondaryColor3fOffset
= _glapi_get_proc_offset("glSecondaryColor3fEXT");
851 char *secondaryColor3fFunc
= (char*) &table
->SecondaryColor3fEXT
;
852 GLuint offset
= (secondaryColor3fFunc
- (char *) table
) / sizeof(void *);
853 assert(secondaryColor3fOffset
== _gloffset_SecondaryColor3fEXT
);
854 assert(secondaryColor3fOffset
== offset
);
855 assert(_glapi_get_proc_address("glSecondaryColor3fEXT") == (void *) &glSecondaryColor3fEXT
);
858 GLuint pointParameterivOffset
= _glapi_get_proc_offset("glPointParameterivNV");
859 char *pointParameterivFunc
= (char*) &table
->PointParameterivNV
;
860 GLuint offset
= (pointParameterivFunc
- (char *) table
) / sizeof(void *);
861 assert(pointParameterivOffset
== _gloffset_PointParameterivNV
);
862 assert(pointParameterivOffset
== offset
);
863 assert(_glapi_get_proc_address("glPointParameterivNV") == (void *) &glPointParameterivNV
);