src/mesa/main/remap.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.7
   4  *
   5  * Copyright (C) 2009 Chia-I Wu <olv@0xlab.org>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23  * DEALINGS IN THE SOFTWARE.
  24  */
  25
  26
  27 /**
  28  * \file remap.c
  29  * Remap table management.
  30  *
  31  * Entries in the dispatch table are either static or dynamic.  The
  32  * dispatch table is shared by mesa core and glapi.  When they are
  33  * built separately, it is possible that a static entry in mesa core
  34  * is dynamic, or assigned a different static offset, in glapi.  The
  35  * remap table is in charge of mapping a static entry in mesa core to
  36  * a dynamic entry, or the corresponding static entry, in glapi.
  37  */
  38
  39 #include "mfeatures.h"
  40
  41 #if FEATURE_remap_table
  42
  43 #include "remap.h"
  44 #include "imports.h"
  45 #include "glapi/glapi.h"
  46
  47 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
  48 #define MAX_ENTRY_POINTS 16
  49
  50 static const char *_mesa_function_pool;
  51
  52 /**
  53  * Return the spec string associated with the given function index.
  54  * The index is available from including remap_helper.h.
  55  *
  56  * \param func_index an opaque function index.
  57  *
  58  * \return the spec string associated with the function index, or NULL.
  59  */
  60 const char *
  61 _mesa_get_function_spec(GLint func_index)
  62 {
  63    return _mesa_function_pool + func_index;
  64 }
  65
  66
  67 /**
  68  * Map a function by its spec.  The function will be added to glapi,
  69  * and the dispatch offset will be returned.
  70  *
  71  * \param spec a '\0'-separated string array specifying a function.
  72  *        It begins with the parameter signature of the function,
  73  *        followed by the names of the entry points.  An empty entry
  74  *        point name terminates the array.
  75  *
  76  * \return the offset of the (re-)mapped function in the dispatch
  77  *         table, or -1.
  78  */
  79 GLint
  80 _mesa_map_function_spec(const char *spec)
  81 {
  82    const char *signature;
  83    const char *names[MAX_ENTRY_POINTS + 1];
  84    GLint num_names = 0;
  85
  86    if (!spec)
  87       return -1;
  88
  89    signature = spec;
  90    spec += strlen(spec) + 1;
  91
  92    /* spec is terminated by an empty string */
  93    while (*spec) {
  94       names[num_names] = spec;
  95       num_names++;
  96       if (num_names >= MAX_ENTRY_POINTS)
  97          break;
  98       spec += strlen(spec) + 1;
  99    }
 100    if (!num_names)
 101       return -1;
 102
 103    names[num_names] = NULL;
 104
 105    /* add the entry points to the dispatch table */
 106    return _glapi_add_dispatch(names, signature);
 107 }
 108
 109
 110 /**
 111  * Map an array of functions.  This is a convenient function for
 112  * use with arrays available from including remap_helper.h.
 113  *
 114  * Note that the dispatch offsets of the functions are not returned.
 115  * If they are needed, _mesa_map_function_spec() should be used.
 116  *
 117  * \param func_array an array of function remaps.
 118  */
 119 void
 120 _mesa_map_function_array(const struct gl_function_remap *func_array)
 121 {
 122    GLint i;
 123
 124    if (!func_array)
 125       return;
 126
 127    for (i = 0; func_array[i].func_index != -1; i++) {
 128       const char *spec;
 129       GLint offset;
 130
 131       spec = _mesa_get_function_spec(func_array[i].func_index);
 132       if (!spec) {
 133          _mesa_problem(NULL, "invalid function index %d",
 134                        func_array[i].func_index);
 135          continue;
 136       }
 137
 138       offset = _mesa_map_function_spec(spec);
 139       /* error checks */
 140       if (offset < 0) {
 141          const char *name = spec + strlen(spec) + 1;
 142          _mesa_warning(NULL, "failed to remap %s", name);
 143       }
 144       else if (func_array[i].dispatch_offset >= 0 &&
 145                offset != func_array[i].dispatch_offset) {
 146          const char *name = spec + strlen(spec) + 1;
 147          _mesa_problem(NULL, "%s should be mapped to %d, not %d",
 148                        name, func_array[i].dispatch_offset, offset);
 149       }
 150    }
 151 }
 152
 153
 154 /**
 155  * Initialize the remap table.  This is called in one_time_init().
 156  * The remap table needs to be initialized before calling the
 157  * CALL/GET/SET macros defined in main/dispatch.h.
 158  */
 159 void
 160 _mesa_do_init_remap_table(const char *pool,
 161                           int size,
 162                           const struct gl_function_pool_remap *remap)
 163 {
 164    static GLboolean initialized = GL_FALSE;
 165    GLint i;
 166
 167    if (initialized)
 168       return;
 169    initialized = GL_TRUE;
 170    _mesa_function_pool = pool;
 171
 172    /* initialize the remap table */
 173    for (i = 0; i < size; i++) {
 174       GLint offset;
 175       const char *spec;
 176
 177       /* sanity check */
 178       ASSERT(i == remap[i].remap_index);
 179       spec = _mesa_function_pool + remap[i].pool_index;
 180
 181       offset = _mesa_map_function_spec(spec);
 182       /* store the dispatch offset in the remap table */
 183       driDispatchRemapTable[i] = offset;
 184       if (offset < 0)
 185          _mesa_warning(NULL, "failed to remap index %d", i);
 186    }
 187 }
 188
 189
 190 #endif /* FEATURE_remap_table */