git.cworth.org Git - glaze/blob - glaze-gl.c

   1 /* Copyright © 2013, Intel Corporation
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  */
  21
  22 #define _GNU_SOURCE
  23 #include <dlfcn.h>
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include <fcntl.h>
  30
  31 void *libgl_handle;
  32 void *wrapper_handle;
  33
  34 #define STRNCMP_LITERAL(str, literal) strncmp (str, literal, sizeof (literal) - 1)
  35
  36 static void
  37 open_libgl_handle (void)
  38 {
  39         const char *libgl_path;
  40
  41         if (libgl_handle)
  42                 return;
  43
  44         libgl_path = getenv ("GLAZE_LIBGL");
  45
  46         if (libgl_path == NULL) {
  47
  48 #if GLAZE_BITS == 32
  49                 libgl_path = getenv ("GLAZE_LIBGL_32_AUTO");
  50 #elif GLAZE_BITS == 64
  51                 libgl_path = getenv ("GLAZE_LIBGL_64_AUTO");
  52 #endif
  53
  54                 if (libgl_path == NULL) {
  55                         fprintf (stderr,
  56                                  "Error: Failed to detect OpenGL library.\n"
  57                                  "Please set GLAZE_LIBGL to path of real libGL.so\n");
  58                         exit (1);
  59                 }
  60
  61                 setenv ("GLAZE_LIBGL", libgl_path, 1);
  62         }
  63
  64         dlerror();
  65         libgl_handle = dlopen (libgl_path, RTLD_LAZY | RTLD_GLOBAL);
  66         if (libgl_handle == NULL) {
  67                 fprintf (stderr, "glaze_init: Error: Failed to dlopen %s: %s\n",
  68                          libgl_path, dlerror());
  69                 exit (1);
  70         }
  71 }
  72
  73 static void
  74 open_wrapper_handle (void)
  75 {
  76         const char *path;
  77
  78         if (wrapper_handle)
  79                 return;
  80
  81         path = getenv ("GLAZE_WRAPPER");
  82         if (path == NULL) {
  83                 fprintf (stderr, "GLAZE_WRAPPER unset. Please set to path of Glaze-using wrapper library.\n");
  84                 exit (1);
  85         }
  86
  87         dlerror ();
  88         wrapper_handle = dlopen (path, RTLD_LAZY);
  89         if (wrapper_handle == NULL) {
  90                 const char *error = dlerror();
  91                 fprintf (stderr, "Error: Failed to dlopen %s: %s\n", path, error);
  92                 exit (1);
  93         }
  94 }
  95
  96 static void
  97 glaze_init (void) __attribute__((constructor));
  98
  99 static void
 100 glaze_init (void)
 101 {
 102         open_libgl_handle ();
 103         open_wrapper_handle ();
 104 }
 105
 106 static void *
 107 resolve (const char *name)
 108 {
 109         static int before_first_gl_call = 1;
 110         void *symbol;
 111
 112         if (before_first_gl_call &&
 113             STRNCMP_LITERAL (name, "gl") == 0 &&
 114             STRNCMP_LITERAL (name, "glX") != 0)
 115         {
 116                 char *callback_name = getenv ("GLAZE_FIRST_GL_CALL_CALLBACK");
 117                 if (callback_name) {
 118                         void (*callback) (void) = dlsym (wrapper_handle,
 119                                                          callback_name);
 120                         if (callback) {
 121                                 (callback) ();
 122                         } else {
 123                                 fprintf (stderr,
 124                                          "Error: Failed to find function %s "
 125                                          "in GLAZE_WRAPPER library.\n",
 126                                          callback_name);
 127                         }
 128                 }
 129                 before_first_gl_call = 0;
 130         }
 131
 132         /* The wrapper gets first choice on all symbols. */
 133         symbol = dlsym (wrapper_handle, name);
 134         if (symbol)
 135                 return symbol;
 136
 137         return dlsym (libgl_handle, name);
 138 }
 139
 140 void
 141 (*glXGetProcAddress (const unsigned char *name))(void);
 142
 143 void
 144 (*glXGetProcAddress (const unsigned char *name))(void)
 145 {
 146         static int first_call = 1;
 147         static typeof (&glXGetProcAddress) wrapper_glXGetProcAddress;
 148         static typeof (&glXGetProcAddress) libgl_glXGetProcAddress;
 149         void *symbol;
 150
 151         /* On the first call, check if the wrapper provides an
 152          * implementation of this function. */
 153         if (first_call) {
 154                 wrapper_glXGetProcAddress = dlsym (wrapper_handle,
 155                                                    "glXGetProcAddress");
 156                 libgl_glXGetProcAddress = dlsym (libgl_handle,
 157                                                  "glXGetProcAddress");
 158                 first_call = 0;
 159         }
 160
 161         /* If the wrapper implements glXGetProcAddress itself, then it
 162          * had better know best what to do. Just let it. */
 163         if (wrapper_glXGetProcAddress)
 164                 return wrapper_glXGetProcAddress (name);
 165
 166         /* Otherwise, we need to resolve the name.
 167          *
 168          * The wrapper gets first choice on all symbols. */
 169         symbol = dlsym (wrapper_handle, (char *) name);
 170         if (symbol)
 171                 return symbol;
 172
 173         /* The wrapper doesn't care, so defer to the underlying
 174          * glXGetProcAddress */
 175         return libgl_glXGetProcAddress (name);
 176
 177 }
 178
 179 void
 180 (*glXGetProcAddressARB (const unsigned char *name))(void);
 181
 182 void
 183 (*glXGetProcAddressARB (const unsigned char *name))(void)
 184 {
 185         static int first_call = 1;
 186         static typeof (&glXGetProcAddressARB) wrapper_glXGetProcAddressARB;
 187         static typeof (&glXGetProcAddressARB) libgl_glXGetProcAddressARB;
 188         void *symbol;
 189
 190         /* On the first call, check if the wrapper provides an
 191          * implementation of this function. */
 192         if (first_call) {
 193                 wrapper_glXGetProcAddressARB = dlsym (wrapper_handle,
 194                                                       "glXGetProcAddressARB");
 195                 libgl_glXGetProcAddressARB = dlsym (libgl_handle,
 196                                                     "glXGetProcAddressARB");
 197                 first_call = 0;
 198         }
 199
 200         /* If the wrapper implements glXGetProcAddressARB itself, then
 201          * it had better know best what to do. Just let it. */
 202         if (wrapper_glXGetProcAddressARB)
 203                 return wrapper_glXGetProcAddressARB (name);
 204
 205         /* Otherwise, we need to resolve the name.
 206          *
 207          * The wrapper gets first choice on all symbols. */
 208         symbol = dlsym (wrapper_handle, (char *) name);
 209         if (symbol)
 210                 return symbol;
 211
 212         /* The wrapper doesn't care, so defer to the underlying
 213          * glXGetProcAddressARB */
 214         return libgl_glXGetProcAddressARB (name);
 215
 216 }
 217
 218 #define GLAZE_API(name)                                                 \
 219 void * name() __attribute__((ifunc(#name "_resolver")));                \
 220 static void *                                                           \
 221 name ## _resolver (void) { return resolve (#name); }
 222
 223 #include "specs/gl.def"
 224 #include "specs/glx.def"