/* * Mesa 3-D graphics library * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. * Copyright (C) 2010 LunarG Inc. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * * Authors: * Chia-I Wu <olv@lunarg.com> */ #include <string.h> #include <stdlib.h> #include "glapi/glapi.h" #include "u_current.h" #include "table.h" /* for MAPI_TABLE_NUM_SLOTS */ #include "stub.h" /* * Global variables, _glapi_get_context, and _glapi_get_dispatch are defined in * u_current.c. */ #ifdef GLX_USE_TLS /* not used, but defined for compatibility */ const struct _glapi_table *_glapi_Dispatch; const void *_glapi_Context; #endif /* GLX_USE_TLS */ void _glapi_destroy_multithread(void) { u_current_destroy(); } void _glapi_check_multithread(void) { u_current_init(); } void _glapi_set_context(void *context) { u_current_set_context((const void *) context); } void _glapi_set_dispatch(struct _glapi_table *dispatch) { u_current_set_table((const struct mapi_table *) dispatch); } /** * Return size of dispatch table struct as number of functions (or * slots). */ unsigned int _glapi_get_dispatch_table_size(void) { return MAPI_TABLE_NUM_SLOTS; } /** * Fill-in the dispatch stub for the named function. * * This function is intended to be called by a hardware driver. When called, * a dispatch stub may be created created for the function. A pointer to this * dispatch function will be returned by glXGetProcAddress. * * \param function_names Array of pointers to function names that should * share a common dispatch offset. * \param parameter_signature String representing the types of the parameters * passed to the named function. Parameter types * are converted to characters using the following * rules: * - 'i' for \c GLint, \c GLuint, and \c GLenum * - 'p' for any pointer type * - 'f' for \c GLfloat and \c GLclampf * - 'd' for \c GLdouble and \c GLclampd * * \returns * The offset in the dispatch table of the named function. A pointer to the * driver's implementation of the named function should be stored at * \c dispatch_table[\c offset]. Return -1 if error/problem. * * \sa glXGetProcAddress * * \warning * This function can only handle up to 8 names at a time. As far as I know, * the maximum number of names ever associated with an existing GL function is * 4 (\c glPointParameterfSGIS, \c glPointParameterfEXT, * \c glPointParameterfARB, and \c glPointParameterf), so this should not be * too painful of a limitation. * * \todo * Check parameter_signature. */ int _glapi_add_dispatch( const char * const * function_names, const char * parameter_signature ) { const struct mapi_stub *function_stubs[8]; const struct mapi_stub *alias = NULL; unsigned i; (void) memset(function_stubs, 0, sizeof(function_stubs)); /* find the missing stubs, and decide the alias */ for (i = 0; function_names[i] != NULL && i < 8; i++) { const char * funcName = function_names[i]; const struct mapi_stub *stub; int slot; if (!funcName || funcName[0] != 'g' || funcName[1] != 'l') return -1; funcName += 2; stub = stub_find_public(funcName); if (!stub) stub = stub_find_dynamic(funcName, 0); slot = (stub) ? stub_get_slot(stub) : -1; if (slot >= 0) { if (alias && stub_get_slot(alias) != slot) return -1; /* use the first existing stub as the alias */ if (!alias) alias = stub; function_stubs[i] = stub; } } /* generate missing stubs */ for (i = 0; function_names[i] != NULL && i < 8; i++) { const char * funcName = function_names[i] + 2; struct mapi_stub *stub; if (function_stubs[i]) continue; stub = stub_find_dynamic(funcName, 1); if (!stub) return -1; stub_fix_dynamic(stub, alias); if (!alias) alias = stub; } return (alias) ? stub_get_slot(alias) : -1; } static const struct mapi_stub * _glapi_get_stub(const char *name, int generate) { const struct mapi_stub *stub; #ifdef USE_MGL_NAMESPACE if (name && name[0] == 'm') name++; #endif if (!name || name[0] != 'g' || name[1] != 'l') return NULL; name += 2; stub = stub_find_public(name); if (!stub) stub = stub_find_dynamic(name, generate); return stub; } /** * Return offset of entrypoint for named function within dispatch table. */ int _glapi_get_proc_offset(const char *funcName) { const struct mapi_stub *stub = _glapi_get_stub(funcName, 0); return (stub) ? stub_get_slot(stub) : -1; } /** * Return pointer to the named function. If the function name isn't found * in the name of static functions, try generating a new API entrypoint on * the fly with assembly language. */ _glapi_proc _glapi_get_proc_address(const char *funcName) { const struct mapi_stub *stub = _glapi_get_stub(funcName, 1); return (stub) ? (_glapi_proc) stub_get_addr(stub) : NULL; } /** * Return the name of the function at the given dispatch offset. * This is only intended for debugging. */ const char * _glapi_get_proc_name(unsigned int offset) { const struct mapi_stub *stub = stub_find_by_slot(offset); return stub ? stub_get_name(stub) : NULL; } /** Return pointer to new dispatch table filled with no-op functions */ struct _glapi_table * _glapi_new_nop_table(unsigned num_entries) { struct _glapi_table *table; if (num_entries > MAPI_TABLE_NUM_SLOTS) num_entries = MAPI_TABLE_NUM_SLOTS; table = malloc(num_entries * sizeof(mapi_func)); if (table) { memcpy(table, table_noop_array, num_entries * sizeof(mapi_func)); } return table; } void _glapi_set_nop_handler(_glapi_nop_handler_proc func) { table_set_noop_handler(func); } /** * This is a deprecated function which should not be used anymore. * It's only present to satisfy linking with older versions of libGL. */ unsigned long _glthread_GetID(void) { return 0; } void _glapi_noop_enable_warnings(unsigned char enable) { } void _glapi_set_warning_func(_glapi_proc func) { }