libxtrans fontconfig glproto libX11 libxcb xcbproto mesa xserver pixman xkeyboard-config git update 22 Dec 2013

xserver          commit a68df147421da21528b5be2d34678383922fa352
libxcb           commit f653464554469b5767f1c99abced25a76bace047
libxcb/xcb-proto commit 4087fc682c5ceb849b74442e17a6b73176e5eecb
xkeyboard-config commit a224a636139d22e1dc7ca7d23782cd656e87bcf5
libX11           commit 3d69b0a83e62f8f6fbdd952fc49cdbdf8825e1e6
libXdmcp         commit 089081dca4ba3598c6f9bf401c029378943b5854
libXext          commit bb24f2970f2e425f4df90c9b73d078ad15a73fbb
libfontenc       commit 3acba630d8b57084f7e92c15732408711ed5137a
libXinerama      commit edd95182b26eb5d576d4878c559e0f17dddaa909
libXau           commit 304a11be4727c5a7feeb2501e8e001466f8ce84e
xkbcomp          commit e3e6e938535532bfad175c1635256ab7fb3ac943
pixman           commit 945ab7a6f3eb6241f07e8f094dc0e647d1f10d9d
xextproto        commit 3f355f138d6df57e067458a20f47307883048adb
randrproto       commit e7526e6b5fe0966929cda10b2ded0258413744db
glproto          commit f84853d97d5749308992412a215fa518b6536eb3
mkfontscale      commit 880a0c4733e62e54e6a0f1238c7430727d23657b
xwininfo         commit ba0d1b0da21d2dbdd81098ed5778f3792b472e13
libXft           commit 4acfdaf95adb0a05c2a25550bdde036c865902f4
libXmu           commit 22d9c590901e121936f50dee97dc60c4f7defb63
libxtrans        commit 2c0a7840a28ae696e80e73157856d7a049fdf6c7
fontconfig       commit 5c725f2f5829238d16116f782d00d8bb0defaf08
mesa             commit 2efe7927d38983029784825fc4897e9b77aa237e

13 files changed, 1180 insertions, 692 deletions

diff --git a/xorg-server/glx/Makefile.am b/xorg-server/glx/Makefile.am
index 5f28e87da..54e81406d 100644
--- a/xorg-server/glx/Makefile.am
+++ b/xorg-server/glx/Makefile.am
@@ -20,7 +20,8 @@ AM_CPPFLAGS = \
 	-I$(top_srcdir)/hw/xfree86/os-support/bus \
 	-I$(top_srcdir)/hw/xfree86/common \
 	-I$(top_srcdir)/hw/xfree86/dri \
-	-I$(top_srcdir)/mi
+	-I$(top_srcdir)/mi \
+	-I$(top_srcdir)/present
 
 if DRI2_AIGLX
 AM_CPPFLAGS += -I$(top_srcdir)/hw/xfree86/dri2
@@ -69,7 +70,6 @@ libglx_la_SOURCES = \
         glxscreens.c \
         glxscreens.h \
         glxserver.h \
-        glxstubs.c \
         glxutil.h \
         render2.c \
         render2swap.c \
diff --git a/xorg-server/glx/glxcmds.c b/xorg-server/glx/glxcmds.c
index efa4aecb2..b8da04882 100644
--- a/xorg-server/glx/glxcmds.c
+++ b/xorg-server/glx/glxcmds.c
@@ -2468,3 +2468,64 @@ __glXDisp_ClientInfo(__GLXclientState * cl, GLbyte * pc)
 
     return Success;
 }
+
+#include <GL/glxtokens.h>
+
+void
+__glXsendSwapEvent(__GLXdrawable *drawable, int type, CARD64 ust,
+                   CARD64 msc, CARD32 sbc)
+{
+    ClientPtr client = clients[CLIENT_ID(drawable->drawId)];
+
+    xGLXBufferSwapComplete2 wire =  {
+        .type = __glXEventBase + GLX_BufferSwapComplete
+    };
+
+    if (!client)
+        return;
+
+    if (!(drawable->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
+        return;
+
+    wire.event_type = type;
+    wire.drawable = drawable->drawId;
+    wire.ust_hi = ust >> 32;
+    wire.ust_lo = ust & 0xffffffff;
+    wire.msc_hi = msc >> 32;
+    wire.msc_lo = msc & 0xffffffff;
+    wire.sbc = sbc;
+
+    WriteEventsToClient(client, 1, (xEvent *) &wire);
+}
+
+#if PRESENT
+static void
+__glXpresentCompleteNotify(WindowPtr window, CARD8 present_mode, CARD32 serial,
+                           uint64_t ust, uint64_t msc)
+{
+    __GLXdrawable *drawable;
+    int glx_type;
+    int rc;
+
+    rc = dixLookupResourceByType((pointer *) &drawable, window->drawable.id,
+                                 __glXDrawableRes, serverClient, DixGetAttrAccess);
+
+    if (rc != Success)
+        return;
+
+    if (present_mode == PresentCompleteModeFlip)
+        glx_type = GLX_FLIP_COMPLETE_INTEL;
+    else
+        glx_type = GLX_BLIT_COMPLETE_INTEL;
+        
+    __glXsendSwapEvent(drawable, glx_type, ust, msc, serial);
+}
+
+#include <present.h>
+
+void
+__glXregisterPresentCompleteNotify(void)
+{
+    present_register_complete_notify(__glXpresentCompleteNotify);
+}
+#endif
diff --git a/xorg-server/glx/glxdri2.c b/xorg-server/glx/glxdri2.c
index fbbd1fd95..b2f3d6ee8 100644
--- a/xorg-server/glx/glxdri2.c
+++ b/xorg-server/glx/glxdri2.c
@@ -55,7 +55,6 @@ typedef struct __GLXDRIscreen __GLXDRIscreen;
 typedef struct __GLXDRIcontext __GLXDRIcontext;
 typedef struct __GLXDRIdrawable __GLXDRIdrawable;
 
-
 #ifdef __DRI2_ROBUSTNESS
 #define ALL_DRI_CTX_FLAGS (__DRI_CTX_FLAG_DEBUG                         \
                            | __DRI_CTX_FLAG_FORWARD_COMPATIBLE          \
@@ -177,36 +176,25 @@ __glXdriSwapEvent(ClientPtr client, void *data, int type, CARD64 ust,
                   CARD64 msc, CARD32 sbc)
 {
     __GLXdrawable *drawable = data;
-    xGLXBufferSwapComplete2 wire =  {
-        .type = __glXEventBase + GLX_BufferSwapComplete
-    };
-
-    if (!(drawable->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
-        return;
-
+    int glx_type;
     switch (type) {
     case DRI2_EXCHANGE_COMPLETE:
-        wire.event_type = GLX_EXCHANGE_COMPLETE_INTEL;
+        glx_type = GLX_EXCHANGE_COMPLETE_INTEL;
         break;
+    default:
+        /* unknown swap completion type,
+         * BLIT is a reasonable default, so
+         * fall through ...
+         */
     case DRI2_BLIT_COMPLETE:
-        wire.event_type = GLX_BLIT_COMPLETE_INTEL;
+        glx_type = GLX_BLIT_COMPLETE_INTEL;
         break;
     case DRI2_FLIP_COMPLETE:
-        wire.event_type = GLX_FLIP_COMPLETE_INTEL;
-        break;
-    default:
-        /* unknown swap completion type */
-        wire.event_type = 0;
+        glx_type = GLX_FLIP_COMPLETE_INTEL;
         break;
     }
-    wire.drawable = drawable->drawId;
-    wire.ust_hi = ust >> 32;
-    wire.ust_lo = ust & 0xffffffff;
-    wire.msc_hi = msc >> 32;
-    wire.msc_lo = msc & 0xffffffff;
-    wire.sbc = sbc;
-
-    WriteEventsToClient(client, 1, (xEvent *) &wire);
+    
+    __glXsendSwapEvent(drawable, glx_type, ust, msc, sbc);
 }
 
 /*
@@ -784,7 +772,7 @@ dri2FlushFrontBuffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 }
 
 static const __DRIdri2LoaderExtension loaderExtension = {
-    {__DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION},
+    {__DRI_DRI2_LOADER, 3},
     dri2GetBuffers,
     dri2FlushFrontBuffer,
     dri2GetBuffersWithFormat,
@@ -792,7 +780,7 @@ static const __DRIdri2LoaderExtension loaderExtension = {
 
 #ifdef __DRI_USE_INVALIDATE
 static const __DRIuseInvalidateExtension dri2UseInvalidate = {
-    {__DRI_USE_INVALIDATE, __DRI_USE_INVALIDATE_VERSION}
+    {__DRI_USE_INVALIDATE, 1}
 };
 #endif
 
@@ -940,6 +928,9 @@ initializeExtensions(__GLXDRIscreen * screen)
     }
 }
 
+/* white lie */
+extern glx_func_ptr glXGetProcAddressARB(const char *);
+
 static __GLXscreen *
 __glXDRIscreenProbe(ScreenPtr pScreen)
 {
@@ -1024,6 +1015,8 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
     screen->leaveVT = pScrn->LeaveVT;
     pScrn->LeaveVT = glxDRILeaveVT;
 
+    __glXsetGetProcAddress(glXGetProcAddressARB);
+
     LogMessage(X_INFO, "AIGLX: Loaded and initialized %s\n", driverName);
 
     return &screen->base;
diff --git a/xorg-server/glx/glxdricommon.c b/xorg-server/glx/glxdricommon.c
index 1022c0075..fc902729d 100644
--- a/xorg-server/glx/glxdricommon.c
+++ b/xorg-server/glx/glxdricommon.c
@@ -59,7 +59,7 @@ getUST(int64_t * ust)
 }
 
 const __DRIsystemTimeExtension systemTimeExtension = {
-    {__DRI_SYSTEM_TIME, __DRI_SYSTEM_TIME_VERSION},
+    {__DRI_SYSTEM_TIME, 1},
     getUST,
     NULL,
 };
diff --git a/xorg-server/glx/glxdriswrast.c b/xorg-server/glx/glxdriswrast.c
index c9962dc81..cbc109a6d 100644
--- a/xorg-server/glx/glxdriswrast.c
+++ b/xorg-server/glx/glxdriswrast.c
@@ -386,7 +386,7 @@ swrastGetImage(__DRIdrawable * draw,
 }
 
 static const __DRIswrastLoaderExtension swrastLoaderExtension = {
-    {__DRI_SWRAST_LOADER, __DRI_SWRAST_LOADER_VERSION},
+    {__DRI_SWRAST_LOADER, 1},
     swrastGetDrawableInfo,
     swrastPutImage,
     swrastGetImage
@@ -425,6 +425,9 @@ initializeExtensions(__GLXDRIscreen * screen)
     }
 }
 
+/* white lie */
+extern glx_func_ptr glXGetProcAddressARB(const char *);
+
 static __GLXscreen *
 __glXDRIscreenProbe(ScreenPtr pScreen)
 {
@@ -443,9 +446,9 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
 
     screen->driver = glxProbeDriver(driverName,
                                     (void **) &screen->core,
-                                    __DRI_CORE, __DRI_CORE_VERSION,
+                                    __DRI_CORE, 1,
                                     (void **) &screen->swrast,
-                                    __DRI_SWRAST, __DRI_SWRAST_VERSION);
+                                    __DRI_SWRAST, 1);
     if (screen->driver == NULL) {
         goto handle_error;
     }
@@ -472,6 +475,8 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
     screen->base.GLXmajor = 1;
     screen->base.GLXminor = 4;
 
+    __glXsetGetProcAddress(glXGetProcAddressARB);
+
     LogMessage(X_INFO, "AIGLX: Loaded and initialized %s\n", driverName);
 
     return &screen->base;
diff --git a/xorg-server/glx/glxext.c b/xorg-server/glx/glxext.c
index 3a7de28fb..316b4f6e8 100644
--- a/xorg-server/glx/glxext.c
+++ b/xorg-server/glx/glxext.c
@@ -399,6 +399,9 @@ GlxExtensionInit(void)
 
     __glXErrorBase = extEntry->errorBase;
     __glXEventBase = extEntry->eventBase;
+#if PRESENT
+    __glXregisterPresentCompleteNotify();
+#endif
 }
 
 /************************************************************************/
@@ -541,17 +544,19 @@ __glXleaveServer(GLboolean rendering)
     glxServerLeaveCount++;
 }
 
-static void (*(*_get_proc_address)(const char *))(void);
+static glx_gpa_proc _get_proc_address;
 
 void
-__glXsetGetProcAddress(void (*(*get_proc_address) (const char *))(void))
+__glXsetGetProcAddress(glx_gpa_proc get_proc_address)
 {
     _get_proc_address = get_proc_address;
 }
 
 void *__glGetProcAddress(const char *proc)
 {
-    return _get_proc_address(proc);
+    void *ret = _get_proc_address(proc);
+
+    return ret ? ret : NoopDDA;
 }
 
 /*
diff --git a/xorg-server/glx/glxserver.h b/xorg-server/glx/glxserver.h
index 5e29abb28..7f36e5f5e 100644
--- a/xorg-server/glx/glxserver.h
+++ b/xorg-server/glx/glxserver.h
@@ -117,9 +117,20 @@ void __glXleaveServer(GLboolean rendering);
 void glxSuspendClients(void);
 void glxResumeClients(void);
 
-void __glXsetGetProcAddress(void (*(*get_proc_address) (const char *)) (void));
+typedef void (*glx_func_ptr)(void);
+typedef glx_func_ptr (*glx_gpa_proc)(const char *);
+void __glXsetGetProcAddress(glx_gpa_proc get_proc_address);
 void *__glGetProcAddress(const char *);
 
+void
+__glXsendSwapEvent(__GLXdrawable *drawable, int type, CARD64 ust,
+                   CARD64 msc, CARD32 sbc);
+
+#if PRESENT
+void
+__glXregisterPresentCompleteNotify(void);
+#endif
+
 /*
 ** State kept per client.
 */
diff --git a/xorg-server/glx/glxstubs.c b/xorg-server/glx/glxstubs.c
deleted file mode 100644
index 69bc00480..000000000
--- a/xorg-server/glx/glxstubs.c
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright © 2013 Red Hat, 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 (including the next
- * paragraph) 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:
- *	Adam Jackson <ajax@redhat.com>
- */
-
-/*
- * Redirection stubs for things that we call by name but that aren't exported
- * from libGL by name.  Strictly speaking this list should be a lot longer,
- * but this is enough to get us linking against contemporary Mesa.
- */
-
-#include <inttypes.h>
-#include "glxserver.h"
-
-#define thunk(name, type, call_args, ...) \
-    _X_HIDDEN void name(__VA_ARGS__) { \
-	static type proc; \
-	if (!proc) proc = __glGetProcAddress(#name); \
-	proc call_args; \
-    }
-
-thunk(glSampleMaskSGIS, PFNGLSAMPLEMASKSGISPROC,
-      (value, invert), GLclampf value, GLboolean invert)
-
-thunk(glSamplePatternSGIS, PFNGLSAMPLEPATTERNSGISPROC,
-      (pattern), GLenum pattern)
-
-thunk(glActiveStencilFaceEXT, PFNGLACTIVESTENCILFACEEXTPROC,
-      (face), GLenum face)
diff --git a/xorg-server/glx/indirect_dispatch.c b/xorg-server/glx/indirect_dispatch.c
index 1eee79a52..329b2e61e 100644
--- a/xorg-server/glx/indirect_dispatch.c
+++ b/xorg-server/glx/indirect_dispatch.c
@@ -3460,7 +3460,7 @@ __glXDisp_CopyTexSubImage3D(GLbyte * pc)
 void
 __glXDisp_ActiveTexture(GLbyte * pc)
 {
-    glActiveTexture(*(GLenum *) (pc + 0));
+    glActiveTextureARB(*(GLenum *) (pc + 0));
 }
 
 void
@@ -3473,7 +3473,7 @@ __glXDisp_MultiTexCoord1dv(GLbyte * pc)
     }
 #endif
 
-    glMultiTexCoord1dv(*(GLenum *) (pc + 8), (const GLdouble *) (pc + 0));
+    glMultiTexCoord1dvARB(*(GLenum *) (pc + 8), (const GLdouble *) (pc + 0));
 }
 
 void
@@ -3485,13 +3485,13 @@ __glXDisp_MultiTexCoord1fvARB(GLbyte * pc)
 void
 __glXDisp_MultiTexCoord1iv(GLbyte * pc)
 {
-    glMultiTexCoord1iv(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
+    glMultiTexCoord1ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
 }
 
 void
 __glXDisp_MultiTexCoord1sv(GLbyte * pc)
 {
-    glMultiTexCoord1sv(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
+    glMultiTexCoord1svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
@@ -3504,7 +3504,7 @@ __glXDisp_MultiTexCoord2dv(GLbyte * pc)
     }
 #endif
 
-    glMultiTexCoord2dv(*(GLenum *) (pc + 16), (const GLdouble *) (pc + 0));
+    glMultiTexCoord2dvARB(*(GLenum *) (pc + 16), (const GLdouble *) (pc + 0));
 }
 
 void
@@ -3516,13 +3516,13 @@ __glXDisp_MultiTexCoord2fvARB(GLbyte * pc)
 void
 __glXDisp_MultiTexCoord2iv(GLbyte * pc)
 {
-    glMultiTexCoord2iv(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
+    glMultiTexCoord2ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
 }
 
 void
 __glXDisp_MultiTexCoord2sv(GLbyte * pc)
 {
-    glMultiTexCoord2sv(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
+    glMultiTexCoord2svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
@@ -3535,7 +3535,7 @@ __glXDisp_MultiTexCoord3dv(GLbyte * pc)
     }
 #endif
 
-    glMultiTexCoord3dv(*(GLenum *) (pc + 24), (const GLdouble *) (pc + 0));
+    glMultiTexCoord3dvARB(*(GLenum *) (pc + 24), (const GLdouble *) (pc + 0));
 }
 
 void
@@ -3547,13 +3547,13 @@ __glXDisp_MultiTexCoord3fvARB(GLbyte * pc)
 void
 __glXDisp_MultiTexCoord3iv(GLbyte * pc)
 {
-    glMultiTexCoord3iv(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
+    glMultiTexCoord3ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
 }
 
 void
 __glXDisp_MultiTexCoord3sv(GLbyte * pc)
 {
-    glMultiTexCoord3sv(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
+    glMultiTexCoord3svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
@@ -3566,7 +3566,7 @@ __glXDisp_MultiTexCoord4dv(GLbyte * pc)
     }
 #endif
 
-    glMultiTexCoord4dv(*(GLenum *) (pc + 32), (const GLdouble *) (pc + 0));
+    glMultiTexCoord4dvARB(*(GLenum *) (pc + 32), (const GLdouble *) (pc + 0));
 }
 
 void
@@ -3578,119 +3578,136 @@ __glXDisp_MultiTexCoord4fvARB(GLbyte * pc)
 void
 __glXDisp_MultiTexCoord4iv(GLbyte * pc)
 {
-    glMultiTexCoord4iv(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
+    glMultiTexCoord4ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
 }
 
 void
 __glXDisp_MultiTexCoord4sv(GLbyte * pc)
 {
-    glMultiTexCoord4sv(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
+    glMultiTexCoord4svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_CompressedTexImage1D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D =
+        __glGetProcAddress("glCompressedTexImage1D");
     const GLsizei imageSize = *(GLsizei *) (pc + 20);
 
-    glCompressedTexImage1D(*(GLenum *) (pc + 0),
-                           *(GLint *) (pc + 4),
-                           *(GLenum *) (pc + 8),
-                           *(GLsizei *) (pc + 12),
-                           *(GLint *) (pc + 16),
-                           imageSize, (const GLvoid *) (pc + 24));
+    CompressedTexImage1D(*(GLenum *) (pc + 0),
+                         *(GLint *) (pc + 4),
+                         *(GLenum *) (pc + 8),
+                         *(GLsizei *) (pc + 12),
+                         *(GLint *) (pc + 16),
+                         imageSize, (const GLvoid *) (pc + 24));
 }
 
 void
 __glXDisp_CompressedTexImage2D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D =
+        __glGetProcAddress("glCompressedTexImage2D");
     const GLsizei imageSize = *(GLsizei *) (pc + 24);
 
-    glCompressedTexImage2D(*(GLenum *) (pc + 0),
-                           *(GLint *) (pc + 4),
-                           *(GLenum *) (pc + 8),
-                           *(GLsizei *) (pc + 12),
-                           *(GLsizei *) (pc + 16),
-                           *(GLint *) (pc + 20),
-                           imageSize, (const GLvoid *) (pc + 28));
+    CompressedTexImage2D(*(GLenum *) (pc + 0),
+                         *(GLint *) (pc + 4),
+                         *(GLenum *) (pc + 8),
+                         *(GLsizei *) (pc + 12),
+                         *(GLsizei *) (pc + 16),
+                         *(GLint *) (pc + 20),
+                         imageSize, (const GLvoid *) (pc + 28));
 }
 
 void
 __glXDisp_CompressedTexImage3D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D =
+        __glGetProcAddress("glCompressedTexImage3D");
     const GLsizei imageSize = *(GLsizei *) (pc + 28);
 
-    glCompressedTexImage3D(*(GLenum *) (pc + 0),
-                           *(GLint *) (pc + 4),
-                           *(GLenum *) (pc + 8),
-                           *(GLsizei *) (pc + 12),
-                           *(GLsizei *) (pc + 16),
-                           *(GLsizei *) (pc + 20),
-                           *(GLint *) (pc + 24),
-                           imageSize, (const GLvoid *) (pc + 32));
+    CompressedTexImage3D(*(GLenum *) (pc + 0),
+                         *(GLint *) (pc + 4),
+                         *(GLenum *) (pc + 8),
+                         *(GLsizei *) (pc + 12),
+                         *(GLsizei *) (pc + 16),
+                         *(GLsizei *) (pc + 20),
+                         *(GLint *) (pc + 24),
+                         imageSize, (const GLvoid *) (pc + 32));
 }
 
 void
 __glXDisp_CompressedTexSubImage1D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D =
+        __glGetProcAddress("glCompressedTexSubImage1D");
     const GLsizei imageSize = *(GLsizei *) (pc + 20);
 
-    glCompressedTexSubImage1D(*(GLenum *) (pc + 0),
-                              *(GLint *) (pc + 4),
-                              *(GLint *) (pc + 8),
-                              *(GLsizei *) (pc + 12),
-                              *(GLenum *) (pc + 16),
-                              imageSize, (const GLvoid *) (pc + 24));
+    CompressedTexSubImage1D(*(GLenum *) (pc + 0),
+                            *(GLint *) (pc + 4),
+                            *(GLint *) (pc + 8),
+                            *(GLsizei *) (pc + 12),
+                            *(GLenum *) (pc + 16),
+                            imageSize, (const GLvoid *) (pc + 24));
 }
 
 void
 __glXDisp_CompressedTexSubImage2D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D =
+        __glGetProcAddress("glCompressedTexSubImage2D");
     const GLsizei imageSize = *(GLsizei *) (pc + 28);
 
-    glCompressedTexSubImage2D(*(GLenum *) (pc + 0),
-                              *(GLint *) (pc + 4),
-                              *(GLint *) (pc + 8),
-                              *(GLint *) (pc + 12),
-                              *(GLsizei *) (pc + 16),
-                              *(GLsizei *) (pc + 20),
-                              *(GLenum *) (pc + 24),
-                              imageSize, (const GLvoid *) (pc + 32));
+    CompressedTexSubImage2D(*(GLenum *) (pc + 0),
+                            *(GLint *) (pc + 4),
+                            *(GLint *) (pc + 8),
+                            *(GLint *) (pc + 12),
+                            *(GLsizei *) (pc + 16),
+                            *(GLsizei *) (pc + 20),
+                            *(GLenum *) (pc + 24),
+                            imageSize, (const GLvoid *) (pc + 32));
 }
 
 void
 __glXDisp_CompressedTexSubImage3D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D =
+        __glGetProcAddress("glCompressedTexSubImage3D");
     const GLsizei imageSize = *(GLsizei *) (pc + 36);
 
-    glCompressedTexSubImage3D(*(GLenum *) (pc + 0),
-                              *(GLint *) (pc + 4),
-                              *(GLint *) (pc + 8),
-                              *(GLint *) (pc + 12),
-                              *(GLint *) (pc + 16),
-                              *(GLsizei *) (pc + 20),
-                              *(GLsizei *) (pc + 24),
-                              *(GLsizei *) (pc + 28),
-                              *(GLenum *) (pc + 32),
-                              imageSize, (const GLvoid *) (pc + 40));
+    CompressedTexSubImage3D(*(GLenum *) (pc + 0),
+                            *(GLint *) (pc + 4),
+                            *(GLint *) (pc + 8),
+                            *(GLint *) (pc + 12),
+                            *(GLint *) (pc + 16),
+                            *(GLsizei *) (pc + 20),
+                            *(GLsizei *) (pc + 24),
+                            *(GLsizei *) (pc + 28),
+                            *(GLenum *) (pc + 32),
+                            imageSize, (const GLvoid *) (pc + 40));
 }
 
 void
 __glXDisp_SampleCoverage(GLbyte * pc)
 {
-    glSampleCoverage(*(GLclampf *) (pc + 0), *(GLboolean *) (pc + 4));
+    PFNGLSAMPLECOVERAGEPROC SampleCoverage =
+        __glGetProcAddress("glSampleCoverage");
+    SampleCoverage(*(GLclampf *) (pc + 0), *(GLboolean *) (pc + 4));
 }
 
 void
 __glXDisp_BlendFuncSeparate(GLbyte * pc)
 {
-    glBlendFuncSeparate(*(GLenum *) (pc + 0),
-                        *(GLenum *) (pc + 4),
-                        *(GLenum *) (pc + 8), *(GLenum *) (pc + 12));
+    PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate =
+        __glGetProcAddress("glBlendFuncSeparate");
+    BlendFuncSeparate(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                      *(GLenum *) (pc + 8), *(GLenum *) (pc + 12));
 }
 
 void
 __glXDisp_FogCoorddv(GLbyte * pc)
 {
+    PFNGLFOGCOORDDVPROC FogCoorddv = __glGetProcAddress("glFogCoorddv");
+
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 8);
@@ -3698,52 +3715,64 @@ __glXDisp_FogCoorddv(GLbyte * pc)
     }
 #endif
 
-    glFogCoorddv((const GLdouble *) (pc + 0));
+    FogCoorddv((const GLdouble *) (pc + 0));
 }
 
 void
 __glXDisp_PointParameterf(GLbyte * pc)
 {
-    glPointParameterf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
+    PFNGLPOINTPARAMETERFPROC PointParameterf =
+        __glGetProcAddress("glPointParameterf");
+    PointParameterf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
 }
 
 void
 __glXDisp_PointParameterfv(GLbyte * pc)
 {
+    PFNGLPOINTPARAMETERFVPROC PointParameterfv =
+        __glGetProcAddress("glPointParameterfv");
     const GLenum pname = *(GLenum *) (pc + 0);
     const GLfloat *params;
 
     params = (const GLfloat *) (pc + 4);
 
-    glPointParameterfv(pname, params);
+    PointParameterfv(pname, params);
 }
 
 void
 __glXDisp_PointParameteri(GLbyte * pc)
 {
-    glPointParameteri(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
+    PFNGLPOINTPARAMETERIPROC PointParameteri =
+        __glGetProcAddress("glPointParameteri");
+    PointParameteri(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
 }
 
 void
 __glXDisp_PointParameteriv(GLbyte * pc)
 {
+    PFNGLPOINTPARAMETERIVPROC PointParameteriv =
+        __glGetProcAddress("glPointParameteriv");
     const GLenum pname = *(GLenum *) (pc + 0);
     const GLint *params;
 
     params = (const GLint *) (pc + 4);
 
-    glPointParameteriv(pname, params);
+    PointParameteriv(pname, params);
 }
 
 void
 __glXDisp_SecondaryColor3bv(GLbyte * pc)
 {
-    glSecondaryColor3bv((const GLbyte *) (pc + 0));
+    PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv =
+        __glGetProcAddress("glSecondaryColor3bv");
+    SecondaryColor3bv((const GLbyte *) (pc + 0));
 }
 
 void
 __glXDisp_SecondaryColor3dv(GLbyte * pc)
 {
+    PFNGLSECONDARYCOLOR3DVPROC SecondaryColor3dv =
+        __glGetProcAddress("glSecondaryColor3dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 24);
@@ -3751,54 +3780,70 @@ __glXDisp_SecondaryColor3dv(GLbyte * pc)
     }
 #endif
 
-    glSecondaryColor3dv((const GLdouble *) (pc + 0));
+    SecondaryColor3dv((const GLdouble *) (pc + 0));
 }
 
 void
 __glXDisp_SecondaryColor3iv(GLbyte * pc)
 {
-    glSecondaryColor3iv((const GLint *) (pc + 0));
+    PFNGLSECONDARYCOLOR3IVPROC SecondaryColor3iv =
+        __glGetProcAddress("glSecondaryColor3iv");
+    SecondaryColor3iv((const GLint *) (pc + 0));
 }
 
 void
 __glXDisp_SecondaryColor3sv(GLbyte * pc)
 {
-    glSecondaryColor3sv((const GLshort *) (pc + 0));
+    PFNGLSECONDARYCOLOR3SVPROC SecondaryColor3sv =
+        __glGetProcAddress("glSecondaryColor3sv");
+    SecondaryColor3sv((const GLshort *) (pc + 0));
 }
 
 void
 __glXDisp_SecondaryColor3ubv(GLbyte * pc)
 {
-    glSecondaryColor3ubv((const GLubyte *) (pc + 0));
+    PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv =
+        __glGetProcAddress("glSecondaryColor3ubv");
+    SecondaryColor3ubv((const GLubyte *) (pc + 0));
 }
 
 void
 __glXDisp_SecondaryColor3uiv(GLbyte * pc)
 {
-    glSecondaryColor3uiv((const GLuint *) (pc + 0));
+    PFNGLSECONDARYCOLOR3UIVPROC SecondaryColor3uiv =
+        __glGetProcAddress("glSecondaryColor3uiv");
+    SecondaryColor3uiv((const GLuint *) (pc + 0));
 }
 
 void
 __glXDisp_SecondaryColor3usv(GLbyte * pc)
 {
-    glSecondaryColor3usv((const GLushort *) (pc + 0));
+    PFNGLSECONDARYCOLOR3USVPROC SecondaryColor3usv =
+        __glGetProcAddress("glSecondaryColor3usv");
+    SecondaryColor3usv((const GLushort *) (pc + 0));
 }
 
 void
 __glXDisp_WindowPos3fv(GLbyte * pc)
 {
-    glWindowPos3fv((const GLfloat *) (pc + 0));
+    PFNGLWINDOWPOS3FVPROC WindowPos3fv = __glGetProcAddress("glWindowPos3fv");
+
+    WindowPos3fv((const GLfloat *) (pc + 0));
 }
 
 void
 __glXDisp_BeginQuery(GLbyte * pc)
 {
-    glBeginQuery(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
+    PFNGLBEGINQUERYPROC BeginQuery = __glGetProcAddress("glBeginQuery");
+
+    BeginQuery(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
 }
 
 int
 __glXDisp_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLDELETEQUERIESPROC DeleteQueries =
+        __glGetProcAddress("glDeleteQueries");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -3807,7 +3852,7 @@ __glXDisp_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         const GLsizei n = *(GLsizei *) (pc + 0);
 
-        glDeleteQueries(n, (const GLuint *) (pc + 4));
+        DeleteQueries(n, (const GLuint *) (pc + 4));
         error = Success;
     }
 
@@ -3817,12 +3862,15 @@ __glXDisp_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDisp_EndQuery(GLbyte * pc)
 {
-    glEndQuery(*(GLenum *) (pc + 0));
+    PFNGLENDQUERYPROC EndQuery = __glGetProcAddress("glEndQuery");
+
+    EndQuery(*(GLenum *) (pc + 0));
 }
 
 int
 __glXDisp_GenQueries(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGENQUERIESPROC GenQueries = __glGetProcAddress("glGenQueries");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -3835,7 +3883,7 @@ __glXDisp_GenQueries(__GLXclientState * cl, GLbyte * pc)
         GLuint *ids =
             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                  4);
-        glGenQueries(n, ids);
+        GenQueries(n, ids);
         __glXSendReply(cl->client, ids, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -3846,6 +3894,8 @@ __glXDisp_GenQueries(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv =
+        __glGetProcAddress("glGetQueryObjectiv");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -3864,7 +3914,7 @@ __glXDisp_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
             return BadAlloc;
         __glXClearErrorOccured();
 
-        glGetQueryObjectiv(*(GLuint *) (pc + 0), pname, params);
+        GetQueryObjectiv(*(GLuint *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3875,6 +3925,8 @@ __glXDisp_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv =
+        __glGetProcAddress("glGetQueryObjectuiv");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -3893,7 +3945,7 @@ __glXDisp_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
             return BadAlloc;
         __glXClearErrorOccured();
 
-        glGetQueryObjectuiv(*(GLuint *) (pc + 0), pname, params);
+        GetQueryObjectuiv(*(GLuint *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3904,6 +3956,7 @@ __glXDisp_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETQUERYIVPROC GetQueryiv = __glGetProcAddress("glGetQueryiv");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -3922,7 +3975,7 @@ __glXDisp_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
             return BadAlloc;
         __glXClearErrorOccured();
 
-        glGetQueryiv(*(GLenum *) (pc + 0), pname, params);
+        GetQueryiv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3933,6 +3986,7 @@ __glXDisp_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_IsQuery(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLISQUERYPROC IsQuery = __glGetProcAddress("glIsQuery");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -3941,7 +3995,7 @@ __glXDisp_IsQuery(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLboolean retval;
 
-        retval = glIsQuery(*(GLuint *) (pc + 0));
+        retval = IsQuery(*(GLuint *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -3952,20 +4006,25 @@ __glXDisp_IsQuery(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDisp_BlendEquationSeparate(GLbyte * pc)
 {
-    glBlendEquationSeparate(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
+    PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate =
+        __glGetProcAddress("glBlendEquationSeparate");
+    BlendEquationSeparate(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
 }
 
 void
 __glXDisp_DrawBuffers(GLbyte * pc)
 {
+    PFNGLDRAWBUFFERSPROC DrawBuffers = __glGetProcAddress("glDrawBuffers");
     const GLsizei n = *(GLsizei *) (pc + 0);
 
-    glDrawBuffers(n, (const GLenum *) (pc + 4));
+    DrawBuffers(n, (const GLenum *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib1dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv =
+        __glGetProcAddress("glVertexAttrib1dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 12);
@@ -3973,18 +4032,22 @@ __glXDisp_VertexAttrib1dv(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib1dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
+    VertexAttrib1dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib1sv(GLbyte * pc)
 {
-    glVertexAttrib1sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
+    PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv =
+        __glGetProcAddress("glVertexAttrib1sv");
+    VertexAttrib1sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib2dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv =
+        __glGetProcAddress("glVertexAttrib2dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 20);
@@ -3992,18 +4055,22 @@ __glXDisp_VertexAttrib2dv(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib2dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
+    VertexAttrib2dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib2sv(GLbyte * pc)
 {
-    glVertexAttrib2sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
+    PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv =
+        __glGetProcAddress("glVertexAttrib2sv");
+    VertexAttrib2sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib3dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv =
+        __glGetProcAddress("glVertexAttrib3dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 28);
@@ -4011,60 +4078,78 @@ __glXDisp_VertexAttrib3dv(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib3dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
+    VertexAttrib3dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib3sv(GLbyte * pc)
 {
-    glVertexAttrib3sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
+    PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv =
+        __glGetProcAddress("glVertexAttrib3sv");
+    VertexAttrib3sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4Nbv(GLbyte * pc)
 {
-    glVertexAttrib4Nbv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv =
+        __glGetProcAddress("glVertexAttrib4Nbv");
+    VertexAttrib4Nbv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4Niv(GLbyte * pc)
 {
-    glVertexAttrib4Niv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4));
+    PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv =
+        __glGetProcAddress("glVertexAttrib4Niv");
+    VertexAttrib4Niv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4Nsv(GLbyte * pc)
 {
-    glVertexAttrib4Nsv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
+    PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv =
+        __glGetProcAddress("glVertexAttrib4Nsv");
+    VertexAttrib4Nsv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4Nubv(GLbyte * pc)
 {
-    glVertexAttrib4Nubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv =
+        __glGetProcAddress("glVertexAttrib4Nubv");
+    VertexAttrib4Nubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4Nuiv(GLbyte * pc)
 {
-    glVertexAttrib4Nuiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4));
+    PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv =
+        __glGetProcAddress("glVertexAttrib4Nuiv");
+    VertexAttrib4Nuiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4Nusv(GLbyte * pc)
 {
-    glVertexAttrib4Nusv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4));
+    PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv =
+        __glGetProcAddress("glVertexAttrib4Nusv");
+    VertexAttrib4Nusv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4bv(GLbyte * pc)
 {
-    glVertexAttrib4bv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv =
+        __glGetProcAddress("glVertexAttrib4bv");
+    VertexAttrib4bv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv =
+        __glGetProcAddress("glVertexAttrib4dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 36);
@@ -4072,54 +4157,70 @@ __glXDisp_VertexAttrib4dv(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib4dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
+    VertexAttrib4dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4iv(GLbyte * pc)
 {
-    glVertexAttrib4iv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4));
+    PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv =
+        __glGetProcAddress("glVertexAttrib4iv");
+    VertexAttrib4iv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4sv(GLbyte * pc)
 {
-    glVertexAttrib4sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
+    PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv =
+        __glGetProcAddress("glVertexAttrib4sv");
+    VertexAttrib4sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4ubv(GLbyte * pc)
 {
-    glVertexAttrib4ubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv =
+        __glGetProcAddress("glVertexAttrib4ubv");
+    VertexAttrib4ubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4uiv(GLbyte * pc)
 {
-    glVertexAttrib4uiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4));
+    PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv =
+        __glGetProcAddress("glVertexAttrib4uiv");
+    VertexAttrib4uiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4usv(GLbyte * pc)
 {
-    glVertexAttrib4usv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4));
+    PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv =
+        __glGetProcAddress("glVertexAttrib4usv");
+    VertexAttrib4usv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4));
 }
 
 void
 __glXDisp_ClampColor(GLbyte * pc)
 {
-    glClampColor(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
+    PFNGLCLAMPCOLORPROC ClampColor = __glGetProcAddress("glClampColor");
+
+    ClampColor(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
 }
 
 void
 __glXDisp_BindProgramARB(GLbyte * pc)
 {
-    glBindProgramARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
+    PFNGLBINDPROGRAMARBPROC BindProgramARB =
+        __glGetProcAddress("glBindProgramARB");
+    BindProgramARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
 }
 
 int
 __glXDisp_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB =
+        __glGetProcAddress("glDeleteProgramsARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4128,7 +4229,7 @@ __glXDisp_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         const GLsizei n = *(GLsizei *) (pc + 0);
 
-        glDeleteProgramsARB(n, (const GLuint *) (pc + 4));
+        DeleteProgramsARB(n, (const GLuint *) (pc + 4));
         error = Success;
     }
 
@@ -4138,6 +4239,8 @@ __glXDisp_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGENPROGRAMSARBPROC GenProgramsARB =
+        __glGetProcAddress("glGenProgramsARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4150,7 +4253,7 @@ __glXDisp_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
         GLuint *programs =
             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                  4);
-        glGenProgramsARB(n, programs);
+        GenProgramsARB(n, programs);
         __glXSendReply(cl->client, programs, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -4161,6 +4264,8 @@ __glXDisp_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMENVPARAMETERDVARBPROC GetProgramEnvParameterdvARB =
+        __glGetProcAddress("glGetProgramEnvParameterdvARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4169,8 +4274,8 @@ __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLdouble params[4];
 
-        glGetProgramEnvParameterdvARB(*(GLenum *) (pc + 0),
-                                      *(GLuint *) (pc + 4), params);
+        GetProgramEnvParameterdvARB(*(GLenum *) (pc + 0),
+                                    *(GLuint *) (pc + 4), params);
         __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -4181,6 +4286,8 @@ __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMENVPARAMETERFVARBPROC GetProgramEnvParameterfvARB =
+        __glGetProcAddress("glGetProgramEnvParameterfvARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4189,8 +4296,8 @@ __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLfloat params[4];
 
-        glGetProgramEnvParameterfvARB(*(GLenum *) (pc + 0),
-                                      *(GLuint *) (pc + 4), params);
+        GetProgramEnvParameterfvARB(*(GLenum *) (pc + 0),
+                                    *(GLuint *) (pc + 4), params);
         __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4201,6 +4308,8 @@ __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GetProgramLocalParameterdvARB =
+        __glGetProcAddress("glGetProgramLocalParameterdvARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4209,8 +4318,8 @@ __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLdouble params[4];
 
-        glGetProgramLocalParameterdvARB(*(GLenum *) (pc + 0),
-                                        *(GLuint *) (pc + 4), params);
+        GetProgramLocalParameterdvARB(*(GLenum *) (pc + 0),
+                                      *(GLuint *) (pc + 4), params);
         __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -4221,6 +4330,8 @@ __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GetProgramLocalParameterfvARB =
+        __glGetProcAddress("glGetProgramLocalParameterfvARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4229,8 +4340,8 @@ __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLfloat params[4];
 
-        glGetProgramLocalParameterfvARB(*(GLenum *) (pc + 0),
-                                        *(GLuint *) (pc + 4), params);
+        GetProgramLocalParameterfvARB(*(GLenum *) (pc + 0),
+                                      *(GLuint *) (pc + 4), params);
         __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4241,6 +4352,8 @@ __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMIVARBPROC GetProgramivARB =
+        __glGetProcAddress("glGetProgramivARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4259,7 +4372,7 @@ __glXDisp_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
             return BadAlloc;
         __glXClearErrorOccured();
 
-        glGetProgramivARB(*(GLenum *) (pc + 0), pname, params);
+        GetProgramivARB(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4270,6 +4383,7 @@ __glXDisp_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLISPROGRAMARBPROC IsProgramARB = __glGetProcAddress("glIsProgramARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4278,7 +4392,7 @@ __glXDisp_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLboolean retval;
 
-        retval = glIsProgramARB(*(GLuint *) (pc + 0));
+        retval = IsProgramARB(*(GLuint *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -4289,6 +4403,8 @@ __glXDisp_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
 {
+    PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB =
+        __glGetProcAddress("glProgramEnvParameter4dvARB");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 40);
@@ -4296,22 +4412,25 @@ __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
     }
 #endif
 
-    glProgramEnvParameter4dvARB(*(GLenum *) (pc + 0),
-                                *(GLuint *) (pc + 4),
-                                (const GLdouble *) (pc + 8));
+    ProgramEnvParameter4dvARB(*(GLenum *) (pc + 0),
+                              *(GLuint *) (pc + 4),
+                              (const GLdouble *) (pc + 8));
 }
 
 void
 __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc)
 {
-    glProgramEnvParameter4fvARB(*(GLenum *) (pc + 0),
-                                *(GLuint *) (pc + 4),
-                                (const GLfloat *) (pc + 8));
+    PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB =
+        __glGetProcAddress("glProgramEnvParameter4fvARB");
+    ProgramEnvParameter4fvARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4),
+                              (const GLfloat *) (pc + 8));
 }
 
 void
 __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
 {
+    PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB =
+        __glGetProcAddress("glProgramLocalParameter4dvARB");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 40);
@@ -4319,81 +4438,96 @@ __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
     }
 #endif
 
-    glProgramLocalParameter4dvARB(*(GLenum *) (pc + 0),
-                                  *(GLuint *) (pc + 4),
-                                  (const GLdouble *) (pc + 8));
+    ProgramLocalParameter4dvARB(*(GLenum *) (pc + 0),
+                                *(GLuint *) (pc + 4),
+                                (const GLdouble *) (pc + 8));
 }
 
 void
 __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc)
 {
-    glProgramLocalParameter4fvARB(*(GLenum *) (pc + 0),
-                                  *(GLuint *) (pc + 4),
-                                  (const GLfloat *) (pc + 8));
+    PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB =
+        __glGetProcAddress("glProgramLocalParameter4fvARB");
+    ProgramLocalParameter4fvARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4),
+                                (const GLfloat *) (pc + 8));
 }
 
 void
 __glXDisp_ProgramStringARB(GLbyte * pc)
 {
+    PFNGLPROGRAMSTRINGARBPROC ProgramStringARB =
+        __glGetProcAddress("glProgramStringARB");
     const GLsizei len = *(GLsizei *) (pc + 8);
 
-    glProgramStringARB(*(GLenum *) (pc + 0),
-                       *(GLenum *) (pc + 4), len, (const GLvoid *) (pc + 12));
+    ProgramStringARB(*(GLenum *) (pc + 0),
+                     *(GLenum *) (pc + 4), len, (const GLvoid *) (pc + 12));
 }
 
 void
 __glXDisp_VertexAttrib1fvARB(GLbyte * pc)
 {
-    glVertexAttrib1fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
+    PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB =
+        __glGetProcAddress("glVertexAttrib1fvARB");
+    VertexAttrib1fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib2fvARB(GLbyte * pc)
 {
-    glVertexAttrib2fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
+    PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB =
+        __glGetProcAddress("glVertexAttrib2fvARB");
+    VertexAttrib2fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib3fvARB(GLbyte * pc)
 {
-    glVertexAttrib3fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
+    PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB =
+        __glGetProcAddress("glVertexAttrib3fvARB");
+    VertexAttrib3fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4fvARB(GLbyte * pc)
 {
-    glVertexAttrib4fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
+    PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB =
+        __glGetProcAddress("glVertexAttrib4fvARB");
+    VertexAttrib4fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
 void
 __glXDisp_BindFramebuffer(GLbyte * pc)
 {
-    glBindFramebuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
+    PFNGLBINDFRAMEBUFFERPROC BindFramebuffer =
+        __glGetProcAddress("glBindFramebuffer");
+    BindFramebuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
 }
 
 void
 __glXDisp_BindRenderbuffer(GLbyte * pc)
 {
-    glBindRenderbuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
+    PFNGLBINDRENDERBUFFERPROC BindRenderbuffer =
+        __glGetProcAddress("glBindRenderbuffer");
+    BindRenderbuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
 }
 
 void
 __glXDisp_BlitFramebuffer(GLbyte * pc)
 {
-    glBlitFramebuffer(*(GLint *) (pc + 0),
-                      *(GLint *) (pc + 4),
-                      *(GLint *) (pc + 8),
-                      *(GLint *) (pc + 12),
-                      *(GLint *) (pc + 16),
-                      *(GLint *) (pc + 20),
-                      *(GLint *) (pc + 24),
-                      *(GLint *) (pc + 28),
-                      *(GLbitfield *) (pc + 32), *(GLenum *) (pc + 36));
+    PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer =
+        __glGetProcAddress("glBlitFramebuffer");
+    BlitFramebuffer(*(GLint *) (pc + 0), *(GLint *) (pc + 4),
+                    *(GLint *) (pc + 8), *(GLint *) (pc + 12),
+                    *(GLint *) (pc + 16), *(GLint *) (pc + 20),
+                    *(GLint *) (pc + 24), *(GLint *) (pc + 28),
+                    *(GLbitfield *) (pc + 32), *(GLenum *) (pc + 36));
 }
 
 int
 __glXDisp_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus =
+        __glGetProcAddress("glCheckFramebufferStatus");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4402,7 +4536,7 @@ __glXDisp_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLenum retval;
 
-        retval = glCheckFramebufferStatus(*(GLenum *) (pc + 0));
+        retval = CheckFramebufferStatus(*(GLenum *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -4413,67 +4547,77 @@ __glXDisp_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDisp_DeleteFramebuffers(GLbyte * pc)
 {
+    PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers =
+        __glGetProcAddress("glDeleteFramebuffers");
     const GLsizei n = *(GLsizei *) (pc + 0);
 
-    glDeleteFramebuffers(n, (const GLuint *) (pc + 4));
+    DeleteFramebuffers(n, (const GLuint *) (pc + 4));
 }
 
 void
 __glXDisp_DeleteRenderbuffers(GLbyte * pc)
 {
+    PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers =
+        __glGetProcAddress("glDeleteRenderbuffers");
     const GLsizei n = *(GLsizei *) (pc + 0);
 
-    glDeleteRenderbuffers(n, (const GLuint *) (pc + 4));
+    DeleteRenderbuffers(n, (const GLuint *) (pc + 4));
 }
 
 void
 __glXDisp_FramebufferRenderbuffer(GLbyte * pc)
 {
-    glFramebufferRenderbuffer(*(GLenum *) (pc + 0),
-                              *(GLenum *) (pc + 4),
-                              *(GLenum *) (pc + 8), *(GLuint *) (pc + 12));
+    PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer =
+        __glGetProcAddress("glFramebufferRenderbuffer");
+    FramebufferRenderbuffer(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                            *(GLenum *) (pc + 8), *(GLuint *) (pc + 12));
 }
 
 void
 __glXDisp_FramebufferTexture1D(GLbyte * pc)
 {
-    glFramebufferTexture1D(*(GLenum *) (pc + 0),
-                           *(GLenum *) (pc + 4),
-                           *(GLenum *) (pc + 8),
-                           *(GLuint *) (pc + 12), *(GLint *) (pc + 16));
+    PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D =
+        __glGetProcAddress("glFramebufferTexture1D");
+    FramebufferTexture1D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                         *(GLenum *) (pc + 8), *(GLuint *) (pc + 12),
+                         *(GLint *) (pc + 16));
 }
 
 void
 __glXDisp_FramebufferTexture2D(GLbyte * pc)
 {
-    glFramebufferTexture2D(*(GLenum *) (pc + 0),
-                           *(GLenum *) (pc + 4),
-                           *(GLenum *) (pc + 8),
-                           *(GLuint *) (pc + 12), *(GLint *) (pc + 16));
+    PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D =
+        __glGetProcAddress("glFramebufferTexture2D");
+    FramebufferTexture2D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                         *(GLenum *) (pc + 8), *(GLuint *) (pc + 12),
+                         *(GLint *) (pc + 16));
 }
 
 void
 __glXDisp_FramebufferTexture3D(GLbyte * pc)
 {
-    glFramebufferTexture3D(*(GLenum *) (pc + 0),
-                           *(GLenum *) (pc + 4),
-                           *(GLenum *) (pc + 8),
-                           *(GLuint *) (pc + 12),
-                           *(GLint *) (pc + 16), *(GLint *) (pc + 20));
+    PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D =
+        __glGetProcAddress("glFramebufferTexture3D");
+    FramebufferTexture3D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                         *(GLenum *) (pc + 8), *(GLuint *) (pc + 12),
+                         *(GLint *) (pc + 16), *(GLint *) (pc + 20));
 }
 
 void
 __glXDisp_FramebufferTextureLayer(GLbyte * pc)
 {
-    glFramebufferTextureLayer(*(GLenum *) (pc + 0),
-                              *(GLenum *) (pc + 4),
-                              *(GLuint *) (pc + 8),
-                              *(GLint *) (pc + 12), *(GLint *) (pc + 16));
+    PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer =
+        __glGetProcAddress("glFramebufferTextureLayer");
+    FramebufferTextureLayer(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                            *(GLuint *) (pc + 8), *(GLint *) (pc + 12),
+                            *(GLint *) (pc + 16));
 }
 
 int
 __glXDisp_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGENFRAMEBUFFERSPROC GenFramebuffers =
+        __glGetProcAddress("glGenFramebuffers");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4486,7 +4630,7 @@ __glXDisp_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
         GLuint *framebuffers =
             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                  4);
-        glGenFramebuffers(n, framebuffers);
+        GenFramebuffers(n, framebuffers);
         __glXSendReply(cl->client, framebuffers, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -4497,6 +4641,8 @@ __glXDisp_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGENRENDERBUFFERSPROC GenRenderbuffers =
+        __glGetProcAddress("glGenRenderbuffers");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4509,7 +4655,7 @@ __glXDisp_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
         GLuint *renderbuffers =
             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                  4);
-        glGenRenderbuffers(n, renderbuffers);
+        GenRenderbuffers(n, renderbuffers);
         __glXSendReply(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -4520,13 +4666,18 @@ __glXDisp_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDisp_GenerateMipmap(GLbyte * pc)
 {
-    glGenerateMipmap(*(GLenum *) (pc + 0));
+    PFNGLGENERATEMIPMAPPROC GenerateMipmap =
+        __glGetProcAddress("glGenerateMipmap");
+    GenerateMipmap(*(GLenum *) (pc + 0));
 }
 
 int
 __glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
                                               GLbyte * pc)
 {
+    PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC
+        GetFramebufferAttachmentParameteriv =
+        __glGetProcAddress("glGetFramebufferAttachmentParameteriv");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4535,9 +4686,9 @@ __glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
     if (cx != NULL) {
         GLint params[1];
 
-        glGetFramebufferAttachmentParameteriv(*(GLenum *) (pc + 0),
-                                              *(GLenum *) (pc + 4),
-                                              *(GLenum *) (pc + 8), params);
+        GetFramebufferAttachmentParameteriv(*(GLenum *) (pc + 0),
+                                            *(GLenum *) (pc + 4),
+                                            *(GLenum *) (pc + 8), params);
         __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4548,6 +4699,8 @@ __glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
 int
 __glXDisp_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv =
+        __glGetProcAddress("glGetRenderbufferParameteriv");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4556,8 +4709,8 @@ __glXDisp_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLint params[1];
 
-        glGetRenderbufferParameteriv(*(GLenum *) (pc + 0),
-                                     *(GLenum *) (pc + 4), params);
+        GetRenderbufferParameteriv(*(GLenum *) (pc + 0),
+                                   *(GLenum *) (pc + 4), params);
         __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4568,6 +4721,8 @@ __glXDisp_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLISFRAMEBUFFERPROC IsFramebuffer =
+        __glGetProcAddress("glIsFramebuffer");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4576,7 +4731,7 @@ __glXDisp_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLboolean retval;
 
-        retval = glIsFramebuffer(*(GLuint *) (pc + 0));
+        retval = IsFramebuffer(*(GLuint *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -4587,6 +4742,8 @@ __glXDisp_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDisp_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLISRENDERBUFFERPROC IsRenderbuffer =
+        __glGetProcAddress("glIsRenderbuffer");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
@@ -4595,7 +4752,7 @@ __glXDisp_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLboolean retval;
 
-        retval = glIsRenderbuffer(*(GLuint *) (pc + 0));
+        retval = IsRenderbuffer(*(GLuint *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -4606,36 +4763,43 @@ __glXDisp_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDisp_RenderbufferStorage(GLbyte * pc)
 {
-    glRenderbufferStorage(*(GLenum *) (pc + 0),
-                          *(GLenum *) (pc + 4),
-                          *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12));
+    PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage =
+        __glGetProcAddress("glRenderbufferStorage");
+    RenderbufferStorage(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                        *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12));
 }
 
 void
 __glXDisp_RenderbufferStorageMultisample(GLbyte * pc)
 {
-    glRenderbufferStorageMultisample(*(GLenum *) (pc + 0),
-                                     *(GLsizei *) (pc + 4),
-                                     *(GLenum *) (pc + 8),
-                                     *(GLsizei *) (pc + 12),
-                                     *(GLsizei *) (pc + 16));
+    PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample =
+        __glGetProcAddress("glRenderbufferStorageMultisample");
+    RenderbufferStorageMultisample(*(GLenum *) (pc + 0), *(GLsizei *) (pc + 4),
+                                   *(GLenum *) (pc + 8), *(GLsizei *) (pc + 12),
+                                   *(GLsizei *) (pc + 16));
 }
 
 void
 __glXDisp_SecondaryColor3fvEXT(GLbyte * pc)
 {
-    glSecondaryColor3fvEXT((const GLfloat *) (pc + 0));
+    PFNGLSECONDARYCOLOR3FVEXTPROC SecondaryColor3fvEXT =
+        __glGetProcAddress("glSecondaryColor3fvEXT");
+    SecondaryColor3fvEXT((const GLfloat *) (pc + 0));
 }
 
 void
 __glXDisp_FogCoordfvEXT(GLbyte * pc)
 {
-    glFogCoordfvEXT((const GLfloat *) (pc + 0));
+    PFNGLFOGCOORDFVEXTPROC FogCoordfvEXT =
+        __glGetProcAddress("glFogCoordfvEXT");
+    FogCoordfvEXT((const GLfloat *) (pc + 0));
 }
 
 void
 __glXDisp_VertexAttrib1dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV =
+        __glGetProcAddress("glVertexAttrib1dvNV");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 12);
@@ -4643,24 +4807,30 @@ __glXDisp_VertexAttrib1dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib1dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
+    VertexAttrib1dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib1fvNV(GLbyte * pc)
 {
-    glVertexAttrib1fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
+    PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV =
+        __glGetProcAddress("glVertexAttrib1fvNV");
+    VertexAttrib1fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib1svNV(GLbyte * pc)
 {
-    glVertexAttrib1svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
+    PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV =
+        __glGetProcAddress("glVertexAttrib1svNV");
+    VertexAttrib1svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib2dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV =
+        __glGetProcAddress("glVertexAttrib2dvNV");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 20);
@@ -4668,24 +4838,30 @@ __glXDisp_VertexAttrib2dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib2dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
+    VertexAttrib2dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib2fvNV(GLbyte * pc)
 {
-    glVertexAttrib2fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
+    PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV =
+        __glGetProcAddress("glVertexAttrib2fvNV");
+    VertexAttrib2fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib2svNV(GLbyte * pc)
 {
-    glVertexAttrib2svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
+    PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV =
+        __glGetProcAddress("glVertexAttrib2svNV");
+    VertexAttrib2svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib3dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV =
+        __glGetProcAddress("glVertexAttrib3dvNV");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 28);
@@ -4693,24 +4869,30 @@ __glXDisp_VertexAttrib3dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib3dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
+    VertexAttrib3dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib3fvNV(GLbyte * pc)
 {
-    glVertexAttrib3fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
+    PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV =
+        __glGetProcAddress("glVertexAttrib3fvNV");
+    VertexAttrib3fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib3svNV(GLbyte * pc)
 {
-    glVertexAttrib3svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
+    PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV =
+        __glGetProcAddress("glVertexAttrib3svNV");
+    VertexAttrib3svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV =
+        __glGetProcAddress("glVertexAttrib4dvNV");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 36);
@@ -4718,30 +4900,38 @@ __glXDisp_VertexAttrib4dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib4dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
+    VertexAttrib4dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4fvNV(GLbyte * pc)
 {
-    glVertexAttrib4fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
+    PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV =
+        __glGetProcAddress("glVertexAttrib4fvNV");
+    VertexAttrib4fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4svNV(GLbyte * pc)
 {
-    glVertexAttrib4svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
+    PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV =
+        __glGetProcAddress("glVertexAttrib4svNV");
+    VertexAttrib4svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttrib4ubvNV(GLbyte * pc)
 {
-    glVertexAttrib4ubvNV(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV =
+        __glGetProcAddress("glVertexAttrib4ubvNV");
+    VertexAttrib4ubvNV(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
 }
 
 void
 __glXDisp_VertexAttribs1dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS1DVNVPROC VertexAttribs1dvNV =
+        __glGetProcAddress("glVertexAttribs1dvNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
 #ifdef __GLX_ALIGN64
@@ -4753,28 +4943,34 @@ __glXDisp_VertexAttribs1dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttribs1dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
+    VertexAttribs1dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs1fvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV =
+        __glGetProcAddress("glVertexAttribs1fvNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
-    glVertexAttribs1fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
+    VertexAttribs1fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs1svNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV =
+        __glGetProcAddress("glVertexAttribs1svNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
-    glVertexAttribs1svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
+    VertexAttribs1svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs2dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS2DVNVPROC VertexAttribs2dvNV =
+        __glGetProcAddress("glVertexAttribs2dvNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
 #ifdef __GLX_ALIGN64
@@ -4786,28 +4982,34 @@ __glXDisp_VertexAttribs2dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttribs2dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
+    VertexAttribs2dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs2fvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV =
+        __glGetProcAddress("glVertexAttribs2fvNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
-    glVertexAttribs2fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
+    VertexAttribs2fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs2svNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV =
+        __glGetProcAddress("glVertexAttribs2svNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
-    glVertexAttribs2svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
+    VertexAttribs2svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs3dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS3DVNVPROC VertexAttribs3dvNV =
+        __glGetProcAddress("glVertexAttribs3dvNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
 #ifdef __GLX_ALIGN64
@@ -4819,28 +5021,34 @@ __glXDisp_VertexAttribs3dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttribs3dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
+    VertexAttribs3dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs3fvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV =
+        __glGetProcAddress("glVertexAttribs3fvNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
-    glVertexAttribs3fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
+    VertexAttribs3fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs3svNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV =
+        __glGetProcAddress("glVertexAttribs3svNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
-    glVertexAttribs3svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
+    VertexAttribs3svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs4dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS4DVNVPROC VertexAttribs4dvNV =
+        __glGetProcAddress("glVertexAttribs4dvNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
 #ifdef __GLX_ALIGN64
@@ -4852,35 +5060,43 @@ __glXDisp_VertexAttribs4dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttribs4dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
+    VertexAttribs4dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs4fvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV =
+        __glGetProcAddress("glVertexAttribs4fvNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
-    glVertexAttribs4fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
+    VertexAttribs4fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs4svNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV =
+        __glGetProcAddress("glVertexAttribs4svNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
-    glVertexAttribs4svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
+    VertexAttribs4svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
 }
 
 void
 __glXDisp_VertexAttribs4ubvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV =
+        __glGetProcAddress("glVertexAttribs4ubvNV");
     const GLsizei n = *(GLsizei *) (pc + 4);
 
-    glVertexAttribs4ubvNV(*(GLuint *) (pc + 0), n, (const GLubyte *) (pc + 8));
+    VertexAttribs4ubvNV(*(GLuint *) (pc + 0), n, (const GLubyte *) (pc + 8));
 }
 
 void
 __glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
 {
-    glActiveStencilFaceEXT(*(GLenum *) (pc + 0));
+    PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT =
+        __glGetProcAddress("glActiveStencilFaceEXT");
+    ActiveStencilFaceEXT(*(GLenum *) (pc + 0));
 }
diff --git a/xorg-server/glx/indirect_dispatch_swap.c b/xorg-server/glx/indirect_dispatch_swap.c
index 974751461..647d0c985 100644
--- a/xorg-server/glx/indirect_dispatch_swap.c
+++ b/xorg-server/glx/indirect_dispatch_swap.c
@@ -3821,7 +3821,7 @@ __glXDispSwap_CopyTexSubImage3D(GLbyte * pc)
 void
 __glXDispSwap_ActiveTexture(GLbyte * pc)
 {
-    glActiveTexture((GLenum) bswap_ENUM(pc + 0));
+    glActiveTextureARB((GLenum) bswap_ENUM(pc + 0));
 }
 
 void
@@ -3834,8 +3834,8 @@ __glXDispSwap_MultiTexCoord1dv(GLbyte * pc)
     }
 #endif
 
-    glMultiTexCoord1dv((GLenum) bswap_ENUM(pc + 8),
-                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
+    glMultiTexCoord1dvARB((GLenum) bswap_ENUM(pc + 8),
+                          (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
                                                          1));
 }
 
@@ -3850,17 +3850,17 @@ __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)
 void
 __glXDispSwap_MultiTexCoord1iv(GLbyte * pc)
 {
-    glMultiTexCoord1iv((GLenum) bswap_ENUM(pc + 0),
-                       (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                      1));
+    glMultiTexCoord1ivARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         1));
 }
 
 void
 __glXDispSwap_MultiTexCoord1sv(GLbyte * pc)
 {
-    glMultiTexCoord1sv((GLenum) bswap_ENUM(pc + 0),
-                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                        1));
+    glMultiTexCoord1svARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                           1));
 }
 
 void
@@ -3873,9 +3873,9 @@ __glXDispSwap_MultiTexCoord2dv(GLbyte * pc)
     }
 #endif
 
-    glMultiTexCoord2dv((GLenum) bswap_ENUM(pc + 16),
-                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
-                                                         2));
+    glMultiTexCoord2dvARB((GLenum) bswap_ENUM(pc + 16),
+                          (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
+                                                            2));
 }
 
 void
@@ -3889,17 +3889,17 @@ __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)
 void
 __glXDispSwap_MultiTexCoord2iv(GLbyte * pc)
 {
-    glMultiTexCoord2iv((GLenum) bswap_ENUM(pc + 0),
-                       (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                      2));
+    glMultiTexCoord2ivARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         2));
 }
 
 void
 __glXDispSwap_MultiTexCoord2sv(GLbyte * pc)
 {
-    glMultiTexCoord2sv((GLenum) bswap_ENUM(pc + 0),
-                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                        2));
+    glMultiTexCoord2svARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                           2));
 }
 
 void
@@ -3912,9 +3912,9 @@ __glXDispSwap_MultiTexCoord3dv(GLbyte * pc)
     }
 #endif
 
-    glMultiTexCoord3dv((GLenum) bswap_ENUM(pc + 24),
-                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
-                                                         3));
+    glMultiTexCoord3dvARB((GLenum) bswap_ENUM(pc + 24),
+                          (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
+                                                            3));
 }
 
 void
@@ -3928,17 +3928,17 @@ __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)
 void
 __glXDispSwap_MultiTexCoord3iv(GLbyte * pc)
 {
-    glMultiTexCoord3iv((GLenum) bswap_ENUM(pc + 0),
-                       (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                      3));
+    glMultiTexCoord3ivARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         3));
 }
 
 void
 __glXDispSwap_MultiTexCoord3sv(GLbyte * pc)
 {
-    glMultiTexCoord3sv((GLenum) bswap_ENUM(pc + 0),
-                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                        3));
+    glMultiTexCoord3svARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                           3));
 }
 
 void
@@ -3951,9 +3951,9 @@ __glXDispSwap_MultiTexCoord4dv(GLbyte * pc)
     }
 #endif
 
-    glMultiTexCoord4dv((GLenum) bswap_ENUM(pc + 32),
-                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
-                                                         4));
+    glMultiTexCoord4dvARB((GLenum) bswap_ENUM(pc + 32),
+                          (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
+                                                            4));
 }
 
 void
@@ -3967,124 +3967,141 @@ __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)
 void
 __glXDispSwap_MultiTexCoord4iv(GLbyte * pc)
 {
-    glMultiTexCoord4iv((GLenum) bswap_ENUM(pc + 0),
-                       (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                      4));
+    glMultiTexCoord4ivARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         4));
 }
 
 void
 __glXDispSwap_MultiTexCoord4sv(GLbyte * pc)
 {
-    glMultiTexCoord4sv((GLenum) bswap_ENUM(pc + 0),
-                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                        4));
+    glMultiTexCoord4svARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                           4));
 }
 
 void
 __glXDispSwap_CompressedTexImage1D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D =
+        __glGetProcAddress("glCompressedTexImage1D");
     const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 20);
 
-    glCompressedTexImage1D((GLenum) bswap_ENUM(pc + 0),
-                           (GLint) bswap_CARD32(pc + 4),
-                           (GLenum) bswap_ENUM(pc + 8),
-                           (GLsizei) bswap_CARD32(pc + 12),
-                           (GLint) bswap_CARD32(pc + 16),
-                           imageSize, (const GLvoid *) (pc + 24));
+    CompressedTexImage1D((GLenum) bswap_ENUM(pc + 0),
+                         (GLint) bswap_CARD32(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLsizei) bswap_CARD32(pc + 12),
+                         (GLint) bswap_CARD32(pc + 16),
+                         imageSize, (const GLvoid *) (pc + 24));
 }
 
 void
 __glXDispSwap_CompressedTexImage2D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D =
+        __glGetProcAddress("glCompressedTexImage2D");
     const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 24);
 
-    glCompressedTexImage2D((GLenum) bswap_ENUM(pc + 0),
-                           (GLint) bswap_CARD32(pc + 4),
-                           (GLenum) bswap_ENUM(pc + 8),
-                           (GLsizei) bswap_CARD32(pc + 12),
-                           (GLsizei) bswap_CARD32(pc + 16),
-                           (GLint) bswap_CARD32(pc + 20),
-                           imageSize, (const GLvoid *) (pc + 28));
+    CompressedTexImage2D((GLenum) bswap_ENUM(pc + 0),
+                         (GLint) bswap_CARD32(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLsizei) bswap_CARD32(pc + 12),
+                         (GLsizei) bswap_CARD32(pc + 16),
+                         (GLint) bswap_CARD32(pc + 20),
+                         imageSize, (const GLvoid *) (pc + 28));
 }
 
 void
 __glXDispSwap_CompressedTexImage3D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D =
+        __glGetProcAddress("glCompressedTexImage3D");
     const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 28);
 
-    glCompressedTexImage3D((GLenum) bswap_ENUM(pc + 0),
-                           (GLint) bswap_CARD32(pc + 4),
-                           (GLenum) bswap_ENUM(pc + 8),
-                           (GLsizei) bswap_CARD32(pc + 12),
-                           (GLsizei) bswap_CARD32(pc + 16),
-                           (GLsizei) bswap_CARD32(pc + 20),
-                           (GLint) bswap_CARD32(pc + 24),
-                           imageSize, (const GLvoid *) (pc + 32));
+    CompressedTexImage3D((GLenum) bswap_ENUM(pc + 0),
+                         (GLint) bswap_CARD32(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLsizei) bswap_CARD32(pc + 12),
+                         (GLsizei) bswap_CARD32(pc + 16),
+                         (GLsizei) bswap_CARD32(pc + 20),
+                         (GLint) bswap_CARD32(pc + 24),
+                         imageSize, (const GLvoid *) (pc + 32));
 }
 
 void
 __glXDispSwap_CompressedTexSubImage1D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D =
+        __glGetProcAddress("glCompressedTexSubImage1D");
     const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 20);
 
-    glCompressedTexSubImage1D((GLenum) bswap_ENUM(pc + 0),
-                              (GLint) bswap_CARD32(pc + 4),
-                              (GLint) bswap_CARD32(pc + 8),
-                              (GLsizei) bswap_CARD32(pc + 12),
-                              (GLenum) bswap_ENUM(pc + 16),
-                              imageSize, (const GLvoid *) (pc + 24));
+    CompressedTexSubImage1D((GLenum) bswap_ENUM(pc + 0),
+                            (GLint) bswap_CARD32(pc + 4),
+                            (GLint) bswap_CARD32(pc + 8),
+                            (GLsizei) bswap_CARD32(pc + 12),
+                            (GLenum) bswap_ENUM(pc + 16),
+                            imageSize, (const GLvoid *) (pc + 24));
 }
 
 void
 __glXDispSwap_CompressedTexSubImage2D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D =
+        __glGetProcAddress("glCompressedTexSubImage2D");
     const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 28);
 
-    glCompressedTexSubImage2D((GLenum) bswap_ENUM(pc + 0),
-                              (GLint) bswap_CARD32(pc + 4),
-                              (GLint) bswap_CARD32(pc + 8),
-                              (GLint) bswap_CARD32(pc + 12),
-                              (GLsizei) bswap_CARD32(pc + 16),
-                              (GLsizei) bswap_CARD32(pc + 20),
-                              (GLenum) bswap_ENUM(pc + 24),
-                              imageSize, (const GLvoid *) (pc + 32));
+    CompressedTexSubImage2D((GLenum) bswap_ENUM(pc + 0),
+                            (GLint) bswap_CARD32(pc + 4),
+                            (GLint) bswap_CARD32(pc + 8),
+                            (GLint) bswap_CARD32(pc + 12),
+                            (GLsizei) bswap_CARD32(pc + 16),
+                            (GLsizei) bswap_CARD32(pc + 20),
+                            (GLenum) bswap_ENUM(pc + 24),
+                            imageSize, (const GLvoid *) (pc + 32));
 }
 
 void
 __glXDispSwap_CompressedTexSubImage3D(GLbyte * pc)
 {
+    PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D =
+        __glGetProcAddress("glCompressedTexSubImage3D");
     const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 36);
 
-    glCompressedTexSubImage3D((GLenum) bswap_ENUM(pc + 0),
-                              (GLint) bswap_CARD32(pc + 4),
-                              (GLint) bswap_CARD32(pc + 8),
-                              (GLint) bswap_CARD32(pc + 12),
-                              (GLint) bswap_CARD32(pc + 16),
-                              (GLsizei) bswap_CARD32(pc + 20),
-                              (GLsizei) bswap_CARD32(pc + 24),
-                              (GLsizei) bswap_CARD32(pc + 28),
-                              (GLenum) bswap_ENUM(pc + 32),
-                              imageSize, (const GLvoid *) (pc + 40));
+    CompressedTexSubImage3D((GLenum) bswap_ENUM(pc + 0),
+                            (GLint) bswap_CARD32(pc + 4),
+                            (GLint) bswap_CARD32(pc + 8),
+                            (GLint) bswap_CARD32(pc + 12),
+                            (GLint) bswap_CARD32(pc + 16),
+                            (GLsizei) bswap_CARD32(pc + 20),
+                            (GLsizei) bswap_CARD32(pc + 24),
+                            (GLsizei) bswap_CARD32(pc + 28),
+                            (GLenum) bswap_ENUM(pc + 32),
+                            imageSize, (const GLvoid *) (pc + 40));
 }
 
 void
 __glXDispSwap_SampleCoverage(GLbyte * pc)
 {
-    glSampleCoverage((GLclampf) bswap_FLOAT32(pc + 0), *(GLboolean *) (pc + 4));
+    PFNGLSAMPLECOVERAGEPROC SampleCoverage =
+        __glGetProcAddress("glSampleCoverage");
+    SampleCoverage((GLclampf) bswap_FLOAT32(pc + 0), *(GLboolean *) (pc + 4));
 }
 
 void
 __glXDispSwap_BlendFuncSeparate(GLbyte * pc)
 {
-    glBlendFuncSeparate((GLenum) bswap_ENUM(pc + 0),
-                        (GLenum) bswap_ENUM(pc + 4),
-                        (GLenum) bswap_ENUM(pc + 8),
-                        (GLenum) bswap_ENUM(pc + 12));
+    PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate =
+        __glGetProcAddress("glBlendFuncSeparate");
+    BlendFuncSeparate((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4),
+                      (GLenum) bswap_ENUM(pc + 8),
+                      (GLenum) bswap_ENUM(pc + 12));
 }
 
 void
 __glXDispSwap_FogCoorddv(GLbyte * pc)
 {
+    PFNGLFOGCOORDDVPROC FogCoorddv = __glGetProcAddress("glFogCoorddv");
+
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 8);
@@ -4092,19 +4109,23 @@ __glXDispSwap_FogCoorddv(GLbyte * pc)
     }
 #endif
 
-    glFogCoorddv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
+    FogCoorddv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
 }
 
 void
 __glXDispSwap_PointParameterf(GLbyte * pc)
 {
-    glPointParameterf((GLenum) bswap_ENUM(pc + 0),
-                      (GLfloat) bswap_FLOAT32(pc + 4));
+    PFNGLPOINTPARAMETERFPROC PointParameterf =
+        __glGetProcAddress("glPointParameterf");
+    PointParameterf((GLenum) bswap_ENUM(pc + 0),
+                    (GLfloat) bswap_FLOAT32(pc + 4));
 }
 
 void
 __glXDispSwap_PointParameterfv(GLbyte * pc)
 {
+    PFNGLPOINTPARAMETERFVPROC PointParameterfv =
+        __glGetProcAddress("glPointParameterfv");
     const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
     const GLfloat *params;
 
@@ -4112,19 +4133,22 @@ __glXDispSwap_PointParameterfv(GLbyte * pc)
         (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
                                          __glPointParameterfv_size(pname));
 
-    glPointParameterfv(pname, params);
+    PointParameterfv(pname, params);
 }
 
 void
 __glXDispSwap_PointParameteri(GLbyte * pc)
 {
-    glPointParameteri((GLenum) bswap_ENUM(pc + 0),
-                      (GLint) bswap_CARD32(pc + 4));
+    PFNGLPOINTPARAMETERIPROC PointParameteri =
+        __glGetProcAddress("glPointParameteri");
+    PointParameteri((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
 }
 
 void
 __glXDispSwap_PointParameteriv(GLbyte * pc)
 {
+    PFNGLPOINTPARAMETERIVPROC PointParameteriv =
+        __glGetProcAddress("glPointParameteriv");
     const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
     const GLint *params;
 
@@ -4132,18 +4156,22 @@ __glXDispSwap_PointParameteriv(GLbyte * pc)
         (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
                                        __glPointParameteriv_size(pname));
 
-    glPointParameteriv(pname, params);
+    PointParameteriv(pname, params);
 }
 
 void
 __glXDispSwap_SecondaryColor3bv(GLbyte * pc)
 {
-    glSecondaryColor3bv((const GLbyte *) (pc + 0));
+    PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv =
+        __glGetProcAddress("glSecondaryColor3bv");
+    SecondaryColor3bv((const GLbyte *) (pc + 0));
 }
 
 void
 __glXDispSwap_SecondaryColor3dv(GLbyte * pc)
 {
+    PFNGLSECONDARYCOLOR3DVPROC SecondaryColor3dv =
+        __glGetProcAddress("glSecondaryColor3dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 24);
@@ -4151,59 +4179,74 @@ __glXDispSwap_SecondaryColor3dv(GLbyte * pc)
     }
 #endif
 
-    glSecondaryColor3dv((const GLdouble *)
-                        bswap_64_array((uint64_t *) (pc + 0), 3));
+    SecondaryColor3dv((const GLdouble *)
+                      bswap_64_array((uint64_t *) (pc + 0), 3));
 }
 
 void
 __glXDispSwap_SecondaryColor3iv(GLbyte * pc)
 {
-    glSecondaryColor3iv((const GLint *)
-                        bswap_32_array((uint32_t *) (pc + 0), 3));
+    PFNGLSECONDARYCOLOR3IVPROC SecondaryColor3iv =
+        __glGetProcAddress("glSecondaryColor3iv");
+    SecondaryColor3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
 void
 __glXDispSwap_SecondaryColor3sv(GLbyte * pc)
 {
-    glSecondaryColor3sv((const GLshort *)
-                        bswap_16_array((uint16_t *) (pc + 0), 3));
+    PFNGLSECONDARYCOLOR3SVPROC SecondaryColor3sv =
+        __glGetProcAddress("glSecondaryColor3sv");
+    SecondaryColor3sv((const GLshort *)
+                      bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
 void
 __glXDispSwap_SecondaryColor3ubv(GLbyte * pc)
 {
-    glSecondaryColor3ubv((const GLubyte *) (pc + 0));
+    PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv =
+        __glGetProcAddress("glSecondaryColor3ubv");
+    SecondaryColor3ubv((const GLubyte *) (pc + 0));
 }
 
 void
 __glXDispSwap_SecondaryColor3uiv(GLbyte * pc)
 {
-    glSecondaryColor3uiv((const GLuint *)
-                         bswap_32_array((uint32_t *) (pc + 0), 3));
+    PFNGLSECONDARYCOLOR3UIVPROC SecondaryColor3uiv =
+        __glGetProcAddress("glSecondaryColor3uiv");
+    SecondaryColor3uiv((const GLuint *)
+                       bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
 void
 __glXDispSwap_SecondaryColor3usv(GLbyte * pc)
 {
-    glSecondaryColor3usv((const GLushort *)
-                         bswap_16_array((uint16_t *) (pc + 0), 3));
+    PFNGLSECONDARYCOLOR3USVPROC SecondaryColor3usv =
+        __glGetProcAddress("glSecondaryColor3usv");
+    SecondaryColor3usv((const GLushort *)
+                       bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
 void
 __glXDispSwap_WindowPos3fv(GLbyte * pc)
 {
-    glWindowPos3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
+    PFNGLWINDOWPOS3FVPROC WindowPos3fv = __glGetProcAddress("glWindowPos3fv");
+
+    WindowPos3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
 void
 __glXDispSwap_BeginQuery(GLbyte * pc)
 {
-    glBeginQuery((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
+    PFNGLBEGINQUERYPROC BeginQuery = __glGetProcAddress("glBeginQuery");
+
+    BeginQuery((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
 }
 
 int
 __glXDispSwap_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLDELETEQUERIESPROC DeleteQueries =
+        __glGetProcAddress("glDeleteQueries");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4213,9 +4256,9 @@ __glXDispSwap_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-        glDeleteQueries(n,
-                        (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                        0));
+        DeleteQueries(n,
+                      (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                      0));
         error = Success;
     }
 
@@ -4225,12 +4268,15 @@ __glXDispSwap_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDispSwap_EndQuery(GLbyte * pc)
 {
-    glEndQuery((GLenum) bswap_ENUM(pc + 0));
+    PFNGLENDQUERYPROC EndQuery = __glGetProcAddress("glEndQuery");
+
+    EndQuery((GLenum) bswap_ENUM(pc + 0));
 }
 
 int
 __glXDispSwap_GenQueries(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGENQUERIESPROC GenQueries = __glGetProcAddress("glGenQueries");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4244,7 +4290,7 @@ __glXDispSwap_GenQueries(__GLXclientState * cl, GLbyte * pc)
         GLuint *ids =
             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                  4);
-        glGenQueries(n, ids);
+        GenQueries(n, ids);
         (void) bswap_32_array((uint32_t *) ids, n);
         __glXSendReplySwap(cl->client, ids, n, 4, GL_TRUE, 0);
         error = Success;
@@ -4256,6 +4302,8 @@ __glXDispSwap_GenQueries(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv =
+        __glGetProcAddress("glGetQueryObjectiv");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4275,7 +4323,7 @@ __glXDispSwap_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
             return BadAlloc;
         __glXClearErrorOccured();
 
-        glGetQueryObjectiv((GLuint) bswap_CARD32(pc + 0), pname, params);
+        GetQueryObjectiv((GLuint) bswap_CARD32(pc + 0), pname, params);
         (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
@@ -4287,6 +4335,8 @@ __glXDispSwap_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv =
+        __glGetProcAddress("glGetQueryObjectuiv");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4306,7 +4356,7 @@ __glXDispSwap_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
             return BadAlloc;
         __glXClearErrorOccured();
 
-        glGetQueryObjectuiv((GLuint) bswap_CARD32(pc + 0), pname, params);
+        GetQueryObjectuiv((GLuint) bswap_CARD32(pc + 0), pname, params);
         (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
@@ -4318,6 +4368,7 @@ __glXDispSwap_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETQUERYIVPROC GetQueryiv = __glGetProcAddress("glGetQueryiv");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4337,7 +4388,7 @@ __glXDispSwap_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
             return BadAlloc;
         __glXClearErrorOccured();
 
-        glGetQueryiv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        GetQueryiv((GLenum) bswap_ENUM(pc + 0), pname, params);
         (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
@@ -4349,6 +4400,7 @@ __glXDispSwap_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_IsQuery(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLISQUERYPROC IsQuery = __glGetProcAddress("glIsQuery");
     xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4358,7 +4410,7 @@ __glXDispSwap_IsQuery(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLboolean retval;
 
-        retval = glIsQuery((GLuint) bswap_CARD32(pc + 0));
+        retval = IsQuery((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -4369,21 +4421,26 @@ __glXDispSwap_IsQuery(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDispSwap_BlendEquationSeparate(GLbyte * pc)
 {
-    glBlendEquationSeparate((GLenum) bswap_ENUM(pc + 0),
-                            (GLenum) bswap_ENUM(pc + 4));
+    PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate =
+        __glGetProcAddress("glBlendEquationSeparate");
+    BlendEquationSeparate((GLenum) bswap_ENUM(pc + 0),
+                          (GLenum) bswap_ENUM(pc + 4));
 }
 
 void
 __glXDispSwap_DrawBuffers(GLbyte * pc)
 {
+    PFNGLDRAWBUFFERSPROC DrawBuffers = __glGetProcAddress("glDrawBuffers");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-    glDrawBuffers(n, (const GLenum *) bswap_32_array((uint32_t *) (pc + 4), 0));
+    DrawBuffers(n, (const GLenum *) bswap_32_array((uint32_t *) (pc + 4), 0));
 }
 
 void
 __glXDispSwap_VertexAttrib1dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv =
+        __glGetProcAddress("glVertexAttrib1dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 12);
@@ -4391,22 +4448,25 @@ __glXDispSwap_VertexAttrib1dv(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib1dv((GLuint) bswap_CARD32(pc + 0),
-                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
-                                                        1));
+    VertexAttrib1dv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                      1));
 }
 
 void
 __glXDispSwap_VertexAttrib1sv(GLbyte * pc)
 {
-    glVertexAttrib1sv((GLuint) bswap_CARD32(pc + 0),
-                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                       1));
+    PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv =
+        __glGetProcAddress("glVertexAttrib1sv");
+    VertexAttrib1sv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 1));
 }
 
 void
 __glXDispSwap_VertexAttrib2dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv =
+        __glGetProcAddress("glVertexAttrib2dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 20);
@@ -4414,22 +4474,25 @@ __glXDispSwap_VertexAttrib2dv(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib2dv((GLuint) bswap_CARD32(pc + 0),
-                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
-                                                        2));
+    VertexAttrib2dv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                      2));
 }
 
 void
 __glXDispSwap_VertexAttrib2sv(GLbyte * pc)
 {
-    glVertexAttrib2sv((GLuint) bswap_CARD32(pc + 0),
-                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                       2));
+    PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv =
+        __glGetProcAddress("glVertexAttrib2sv");
+    VertexAttrib2sv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 2));
 }
 
 void
 __glXDispSwap_VertexAttrib3dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv =
+        __glGetProcAddress("glVertexAttrib3dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 28);
@@ -4437,74 +4500,89 @@ __glXDispSwap_VertexAttrib3dv(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib3dv((GLuint) bswap_CARD32(pc + 0),
-                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
-                                                        3));
+    VertexAttrib3dv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                      3));
 }
 
 void
 __glXDispSwap_VertexAttrib3sv(GLbyte * pc)
 {
-    glVertexAttrib3sv((GLuint) bswap_CARD32(pc + 0),
-                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                       3));
+    PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv =
+        __glGetProcAddress("glVertexAttrib3sv");
+    VertexAttrib3sv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 3));
 }
 
 void
 __glXDispSwap_VertexAttrib4Nbv(GLbyte * pc)
 {
-    glVertexAttrib4Nbv((GLuint) bswap_CARD32(pc + 0),
-                       (const GLbyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv =
+        __glGetProcAddress("glVertexAttrib4Nbv");
+    VertexAttrib4Nbv((GLuint) bswap_CARD32(pc + 0), (const GLbyte *) (pc + 4));
 }
 
 void
 __glXDispSwap_VertexAttrib4Niv(GLbyte * pc)
 {
-    glVertexAttrib4Niv((GLuint) bswap_CARD32(pc + 0),
-                       (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                      4));
+    PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv =
+        __glGetProcAddress("glVertexAttrib4Niv");
+    VertexAttrib4Niv((GLuint) bswap_CARD32(pc + 0),
+                     (const GLint *) bswap_32_array((uint32_t *) (pc + 4), 4));
 }
 
 void
 __glXDispSwap_VertexAttrib4Nsv(GLbyte * pc)
 {
-    glVertexAttrib4Nsv((GLuint) bswap_CARD32(pc + 0),
-                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                        4));
+    PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv =
+        __glGetProcAddress("glVertexAttrib4Nsv");
+    VertexAttrib4Nsv((GLuint) bswap_CARD32(pc + 0),
+                     (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                      4));
 }
 
 void
 __glXDispSwap_VertexAttrib4Nubv(GLbyte * pc)
 {
-    glVertexAttrib4Nubv((GLuint) bswap_CARD32(pc + 0),
-                        (const GLubyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv =
+        __glGetProcAddress("glVertexAttrib4Nubv");
+    VertexAttrib4Nubv((GLuint) bswap_CARD32(pc + 0),
+                      (const GLubyte *) (pc + 4));
 }
 
 void
 __glXDispSwap_VertexAttrib4Nuiv(GLbyte * pc)
 {
-    glVertexAttrib4Nuiv((GLuint) bswap_CARD32(pc + 0),
-                        (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                        4));
+    PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv =
+        __glGetProcAddress("glVertexAttrib4Nuiv");
+    VertexAttrib4Nuiv((GLuint) bswap_CARD32(pc + 0),
+                      (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                      4));
 }
 
 void
 __glXDispSwap_VertexAttrib4Nusv(GLbyte * pc)
 {
-    glVertexAttrib4Nusv((GLuint) bswap_CARD32(pc + 0),
-                        (const GLushort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                          4));
+    PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv =
+        __glGetProcAddress("glVertexAttrib4Nusv");
+    VertexAttrib4Nusv((GLuint) bswap_CARD32(pc + 0),
+                      (const GLushort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                        4));
 }
 
 void
 __glXDispSwap_VertexAttrib4bv(GLbyte * pc)
 {
-    glVertexAttrib4bv((GLuint) bswap_CARD32(pc + 0), (const GLbyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv =
+        __glGetProcAddress("glVertexAttrib4bv");
+    VertexAttrib4bv((GLuint) bswap_CARD32(pc + 0), (const GLbyte *) (pc + 4));
 }
 
 void
 __glXDispSwap_VertexAttrib4dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv =
+        __glGetProcAddress("glVertexAttrib4dv");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 36);
@@ -4512,65 +4590,77 @@ __glXDispSwap_VertexAttrib4dv(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib4dv((GLuint) bswap_CARD32(pc + 0),
-                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
-                                                        4));
+    VertexAttrib4dv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                      4));
 }
 
 void
 __glXDispSwap_VertexAttrib4iv(GLbyte * pc)
 {
-    glVertexAttrib4iv((GLuint) bswap_CARD32(pc + 0),
-                      (const GLint *) bswap_32_array((uint32_t *) (pc + 4), 4));
+    PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv =
+        __glGetProcAddress("glVertexAttrib4iv");
+    VertexAttrib4iv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLint *) bswap_32_array((uint32_t *) (pc + 4), 4));
 }
 
 void
 __glXDispSwap_VertexAttrib4sv(GLbyte * pc)
 {
-    glVertexAttrib4sv((GLuint) bswap_CARD32(pc + 0),
-                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                       4));
+    PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv =
+        __glGetProcAddress("glVertexAttrib4sv");
+    VertexAttrib4sv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 4));
 }
 
 void
 __glXDispSwap_VertexAttrib4ubv(GLbyte * pc)
 {
-    glVertexAttrib4ubv((GLuint) bswap_CARD32(pc + 0),
-                       (const GLubyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv =
+        __glGetProcAddress("glVertexAttrib4ubv");
+    VertexAttrib4ubv((GLuint) bswap_CARD32(pc + 0), (const GLubyte *) (pc + 4));
 }
 
 void
 __glXDispSwap_VertexAttrib4uiv(GLbyte * pc)
 {
-    glVertexAttrib4uiv((GLuint) bswap_CARD32(pc + 0),
-                       (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                       4));
+    PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv =
+        __glGetProcAddress("glVertexAttrib4uiv");
+    VertexAttrib4uiv((GLuint) bswap_CARD32(pc + 0),
+                     (const GLuint *) bswap_32_array((uint32_t *) (pc + 4), 4));
 }
 
 void
 __glXDispSwap_VertexAttrib4usv(GLbyte * pc)
 {
-    glVertexAttrib4usv((GLuint) bswap_CARD32(pc + 0),
-                       (const GLushort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                         4));
+    PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv =
+        __glGetProcAddress("glVertexAttrib4usv");
+    VertexAttrib4usv((GLuint) bswap_CARD32(pc + 0),
+                     (const GLushort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       4));
 }
 
 void
 __glXDispSwap_ClampColor(GLbyte * pc)
 {
-    glClampColor((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
+    PFNGLCLAMPCOLORPROC ClampColor = __glGetProcAddress("glClampColor");
+
+    ClampColor((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
 }
 
 void
 __glXDispSwap_BindProgramARB(GLbyte * pc)
 {
-    glBindProgramARB((GLenum) bswap_ENUM(pc + 0),
-                     (GLuint) bswap_CARD32(pc + 4));
+    PFNGLBINDPROGRAMARBPROC BindProgramARB =
+        __glGetProcAddress("glBindProgramARB");
+    BindProgramARB((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
 }
 
 int
 __glXDispSwap_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB =
+        __glGetProcAddress("glDeleteProgramsARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4580,9 +4670,9 @@ __glXDispSwap_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-        glDeleteProgramsARB(n,
-                            (const GLuint *)
-                            bswap_32_array((uint32_t *) (pc + 4), 0));
+        DeleteProgramsARB(n,
+                          (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                          0));
         error = Success;
     }
 
@@ -4592,6 +4682,8 @@ __glXDispSwap_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGENPROGRAMSARBPROC GenProgramsARB =
+        __glGetProcAddress("glGenProgramsARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4605,7 +4697,7 @@ __glXDispSwap_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
         GLuint *programs =
             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                  4);
-        glGenProgramsARB(n, programs);
+        GenProgramsARB(n, programs);
         (void) bswap_32_array((uint32_t *) programs, n);
         __glXSendReplySwap(cl->client, programs, n, 4, GL_TRUE, 0);
         error = Success;
@@ -4617,6 +4709,8 @@ __glXDispSwap_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMENVPARAMETERDVARBPROC GetProgramEnvParameterdvARB =
+        __glGetProcAddress("glGetProgramEnvParameterdvARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4626,8 +4720,8 @@ __glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLdouble params[4];
 
-        glGetProgramEnvParameterdvARB((GLenum) bswap_ENUM(pc + 0),
-                                      (GLuint) bswap_CARD32(pc + 4), params);
+        GetProgramEnvParameterdvARB((GLenum) bswap_ENUM(pc + 0),
+                                    (GLuint) bswap_CARD32(pc + 4), params);
         (void) bswap_64_array((uint64_t *) params, 4);
         __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
         error = Success;
@@ -4639,6 +4733,8 @@ __glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMENVPARAMETERFVARBPROC GetProgramEnvParameterfvARB =
+        __glGetProcAddress("glGetProgramEnvParameterfvARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4648,8 +4744,8 @@ __glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLfloat params[4];
 
-        glGetProgramEnvParameterfvARB((GLenum) bswap_ENUM(pc + 0),
-                                      (GLuint) bswap_CARD32(pc + 4), params);
+        GetProgramEnvParameterfvARB((GLenum) bswap_ENUM(pc + 0),
+                                    (GLuint) bswap_CARD32(pc + 4), params);
         (void) bswap_32_array((uint32_t *) params, 4);
         __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
         error = Success;
@@ -4661,6 +4757,8 @@ __glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GetProgramLocalParameterdvARB =
+        __glGetProcAddress("glGetProgramLocalParameterdvARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4670,8 +4768,8 @@ __glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLdouble params[4];
 
-        glGetProgramLocalParameterdvARB((GLenum) bswap_ENUM(pc + 0),
-                                        (GLuint) bswap_CARD32(pc + 4), params);
+        GetProgramLocalParameterdvARB((GLenum) bswap_ENUM(pc + 0),
+                                      (GLuint) bswap_CARD32(pc + 4), params);
         (void) bswap_64_array((uint64_t *) params, 4);
         __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
         error = Success;
@@ -4683,6 +4781,8 @@ __glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GetProgramLocalParameterfvARB =
+        __glGetProcAddress("glGetProgramLocalParameterfvARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4692,8 +4792,8 @@ __glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLfloat params[4];
 
-        glGetProgramLocalParameterfvARB((GLenum) bswap_ENUM(pc + 0),
-                                        (GLuint) bswap_CARD32(pc + 4), params);
+        GetProgramLocalParameterfvARB((GLenum) bswap_ENUM(pc + 0),
+                                      (GLuint) bswap_CARD32(pc + 4), params);
         (void) bswap_32_array((uint32_t *) params, 4);
         __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
         error = Success;
@@ -4705,6 +4805,8 @@ __glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETPROGRAMIVARBPROC GetProgramivARB =
+        __glGetProcAddress("glGetProgramivARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4724,7 +4826,7 @@ __glXDispSwap_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
             return BadAlloc;
         __glXClearErrorOccured();
 
-        glGetProgramivARB((GLenum) bswap_ENUM(pc + 0), pname, params);
+        GetProgramivARB((GLenum) bswap_ENUM(pc + 0), pname, params);
         (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
@@ -4736,6 +4838,7 @@ __glXDispSwap_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLISPROGRAMARBPROC IsProgramARB = __glGetProcAddress("glIsProgramARB");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4745,7 +4848,7 @@ __glXDispSwap_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLboolean retval;
 
-        retval = glIsProgramARB((GLuint) bswap_CARD32(pc + 0));
+        retval = IsProgramARB((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -4756,6 +4859,8 @@ __glXDispSwap_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc)
 {
+    PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB =
+        __glGetProcAddress("glProgramEnvParameter4dvARB");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 40);
@@ -4763,24 +4868,28 @@ __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc)
     }
 #endif
 
-    glProgramEnvParameter4dvARB((GLenum) bswap_ENUM(pc + 0),
-                                (GLuint) bswap_CARD32(pc + 4),
-                                (const GLdouble *)
-                                bswap_64_array((uint64_t *) (pc + 8), 4));
+    ProgramEnvParameter4dvARB((GLenum) bswap_ENUM(pc + 0),
+                              (GLuint) bswap_CARD32(pc + 4),
+                              (const GLdouble *)
+                              bswap_64_array((uint64_t *) (pc + 8), 4));
 }
 
 void
 __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc)
 {
-    glProgramEnvParameter4fvARB((GLenum) bswap_ENUM(pc + 0),
-                                (GLuint) bswap_CARD32(pc + 4),
-                                (const GLfloat *)
-                                bswap_32_array((uint32_t *) (pc + 8), 4));
+    PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB =
+        __glGetProcAddress("glProgramEnvParameter4fvARB");
+    ProgramEnvParameter4fvARB((GLenum) bswap_ENUM(pc + 0),
+                              (GLuint) bswap_CARD32(pc + 4),
+                              (const GLfloat *)
+                              bswap_32_array((uint32_t *) (pc + 8), 4));
 }
 
 void
 __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc)
 {
+    PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB =
+        __glGetProcAddress("glProgramLocalParameter4dvARB");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 40);
@@ -4788,95 +4897,112 @@ __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc)
     }
 #endif
 
-    glProgramLocalParameter4dvARB((GLenum) bswap_ENUM(pc + 0),
-                                  (GLuint) bswap_CARD32(pc + 4),
-                                  (const GLdouble *)
-                                  bswap_64_array((uint64_t *) (pc + 8), 4));
+    ProgramLocalParameter4dvARB((GLenum) bswap_ENUM(pc + 0),
+                                (GLuint) bswap_CARD32(pc + 4),
+                                (const GLdouble *)
+                                bswap_64_array((uint64_t *) (pc + 8), 4));
 }
 
 void
 __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc)
 {
-    glProgramLocalParameter4fvARB((GLenum) bswap_ENUM(pc + 0),
-                                  (GLuint) bswap_CARD32(pc + 4),
-                                  (const GLfloat *)
-                                  bswap_32_array((uint32_t *) (pc + 8), 4));
+    PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB =
+        __glGetProcAddress("glProgramLocalParameter4fvARB");
+    ProgramLocalParameter4fvARB((GLenum) bswap_ENUM(pc + 0),
+                                (GLuint) bswap_CARD32(pc + 4),
+                                (const GLfloat *)
+                                bswap_32_array((uint32_t *) (pc + 8), 4));
 }
 
 void
 __glXDispSwap_ProgramStringARB(GLbyte * pc)
 {
+    PFNGLPROGRAMSTRINGARBPROC ProgramStringARB =
+        __glGetProcAddress("glProgramStringARB");
     const GLsizei len = (GLsizei) bswap_CARD32(pc + 8);
 
-    glProgramStringARB((GLenum) bswap_ENUM(pc + 0),
-                       (GLenum) bswap_ENUM(pc + 4),
-                       len, (const GLvoid *) (pc + 12));
+    ProgramStringARB((GLenum) bswap_ENUM(pc + 0),
+                     (GLenum) bswap_ENUM(pc + 4),
+                     len, (const GLvoid *) (pc + 12));
 }
 
 void
 __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc)
 {
-    glVertexAttrib1fvARB((GLuint) bswap_CARD32(pc + 0),
-                         (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
-                                                          1));
+    PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB =
+        __glGetProcAddress("glVertexAttrib1fvARB");
+    VertexAttrib1fvARB((GLuint) bswap_CARD32(pc + 0),
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        1));
 }
 
 void
 __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc)
 {
-    glVertexAttrib2fvARB((GLuint) bswap_CARD32(pc + 0),
-                         (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
-                                                          2));
+    PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB =
+        __glGetProcAddress("glVertexAttrib2fvARB");
+    VertexAttrib2fvARB((GLuint) bswap_CARD32(pc + 0),
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        2));
 }
 
 void
 __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc)
 {
-    glVertexAttrib3fvARB((GLuint) bswap_CARD32(pc + 0),
-                         (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
-                                                          3));
+    PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB =
+        __glGetProcAddress("glVertexAttrib3fvARB");
+    VertexAttrib3fvARB((GLuint) bswap_CARD32(pc + 0),
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        3));
 }
 
 void
 __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc)
 {
-    glVertexAttrib4fvARB((GLuint) bswap_CARD32(pc + 0),
-                         (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
-                                                          4));
+    PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB =
+        __glGetProcAddress("glVertexAttrib4fvARB");
+    VertexAttrib4fvARB((GLuint) bswap_CARD32(pc + 0),
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        4));
 }
 
 void
 __glXDispSwap_BindFramebuffer(GLbyte * pc)
 {
-    glBindFramebuffer((GLenum) bswap_ENUM(pc + 0),
-                      (GLuint) bswap_CARD32(pc + 4));
+    PFNGLBINDFRAMEBUFFERPROC BindFramebuffer =
+        __glGetProcAddress("glBindFramebuffer");
+    BindFramebuffer((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
 }
 
 void
 __glXDispSwap_BindRenderbuffer(GLbyte * pc)
 {
-    glBindRenderbuffer((GLenum) bswap_ENUM(pc + 0),
-                       (GLuint) bswap_CARD32(pc + 4));
+    PFNGLBINDRENDERBUFFERPROC BindRenderbuffer =
+        __glGetProcAddress("glBindRenderbuffer");
+    BindRenderbuffer((GLenum) bswap_ENUM(pc + 0),
+                     (GLuint) bswap_CARD32(pc + 4));
 }
 
 void
 __glXDispSwap_BlitFramebuffer(GLbyte * pc)
 {
-    glBlitFramebuffer((GLint) bswap_CARD32(pc + 0),
-                      (GLint) bswap_CARD32(pc + 4),
-                      (GLint) bswap_CARD32(pc + 8),
-                      (GLint) bswap_CARD32(pc + 12),
-                      (GLint) bswap_CARD32(pc + 16),
-                      (GLint) bswap_CARD32(pc + 20),
-                      (GLint) bswap_CARD32(pc + 24),
-                      (GLint) bswap_CARD32(pc + 28),
-                      (GLbitfield) bswap_CARD32(pc + 32),
-                      (GLenum) bswap_ENUM(pc + 36));
+    PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer =
+        __glGetProcAddress("glBlitFramebuffer");
+    BlitFramebuffer((GLint) bswap_CARD32(pc + 0), (GLint) bswap_CARD32(pc + 4),
+                    (GLint) bswap_CARD32(pc + 8), (GLint) bswap_CARD32(pc + 12),
+                    (GLint) bswap_CARD32(pc + 16),
+                    (GLint) bswap_CARD32(pc + 20),
+                    (GLint) bswap_CARD32(pc + 24),
+                    (GLint) bswap_CARD32(pc + 28),
+                    (GLbitfield) bswap_CARD32(pc + 32),
+                    (GLenum) bswap_ENUM(pc + 36));
 }
 
 int
 __glXDispSwap_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus =
+        __glGetProcAddress("glCheckFramebufferStatus");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4886,7 +5012,7 @@ __glXDispSwap_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLenum retval;
 
-        retval = glCheckFramebufferStatus((GLenum) bswap_ENUM(pc + 0));
+        retval = CheckFramebufferStatus((GLenum) bswap_ENUM(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -4897,76 +5023,92 @@ __glXDispSwap_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDispSwap_DeleteFramebuffers(GLbyte * pc)
 {
+    PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers =
+        __glGetProcAddress("glDeleteFramebuffers");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-    glDeleteFramebuffers(n,
-                         (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                         0));
+    DeleteFramebuffers(n,
+                       (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       0));
 }
 
 void
 __glXDispSwap_DeleteRenderbuffers(GLbyte * pc)
 {
+    PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers =
+        __glGetProcAddress("glDeleteRenderbuffers");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-    glDeleteRenderbuffers(n,
-                          (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
-                                                          0));
+    DeleteRenderbuffers(n,
+                        (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        0));
 }
 
 void
 __glXDispSwap_FramebufferRenderbuffer(GLbyte * pc)
 {
-    glFramebufferRenderbuffer((GLenum) bswap_ENUM(pc + 0),
-                              (GLenum) bswap_ENUM(pc + 4),
-                              (GLenum) bswap_ENUM(pc + 8),
-                              (GLuint) bswap_CARD32(pc + 12));
+    PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer =
+        __glGetProcAddress("glFramebufferRenderbuffer");
+    FramebufferRenderbuffer((GLenum) bswap_ENUM(pc + 0),
+                            (GLenum) bswap_ENUM(pc + 4),
+                            (GLenum) bswap_ENUM(pc + 8),
+                            (GLuint) bswap_CARD32(pc + 12));
 }
 
 void
 __glXDispSwap_FramebufferTexture1D(GLbyte * pc)
 {
-    glFramebufferTexture1D((GLenum) bswap_ENUM(pc + 0),
-                           (GLenum) bswap_ENUM(pc + 4),
-                           (GLenum) bswap_ENUM(pc + 8),
-                           (GLuint) bswap_CARD32(pc + 12),
-                           (GLint) bswap_CARD32(pc + 16));
+    PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D =
+        __glGetProcAddress("glFramebufferTexture1D");
+    FramebufferTexture1D((GLenum) bswap_ENUM(pc + 0),
+                         (GLenum) bswap_ENUM(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLuint) bswap_CARD32(pc + 12),
+                         (GLint) bswap_CARD32(pc + 16));
 }
 
 void
 __glXDispSwap_FramebufferTexture2D(GLbyte * pc)
 {
-    glFramebufferTexture2D((GLenum) bswap_ENUM(pc + 0),
-                           (GLenum) bswap_ENUM(pc + 4),
-                           (GLenum) bswap_ENUM(pc + 8),
-                           (GLuint) bswap_CARD32(pc + 12),
-                           (GLint) bswap_CARD32(pc + 16));
+    PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D =
+        __glGetProcAddress("glFramebufferTexture2D");
+    FramebufferTexture2D((GLenum) bswap_ENUM(pc + 0),
+                         (GLenum) bswap_ENUM(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLuint) bswap_CARD32(pc + 12),
+                         (GLint) bswap_CARD32(pc + 16));
 }
 
 void
 __glXDispSwap_FramebufferTexture3D(GLbyte * pc)
 {
-    glFramebufferTexture3D((GLenum) bswap_ENUM(pc + 0),
-                           (GLenum) bswap_ENUM(pc + 4),
-                           (GLenum) bswap_ENUM(pc + 8),
-                           (GLuint) bswap_CARD32(pc + 12),
-                           (GLint) bswap_CARD32(pc + 16),
-                           (GLint) bswap_CARD32(pc + 20));
+    PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D =
+        __glGetProcAddress("glFramebufferTexture3D");
+    FramebufferTexture3D((GLenum) bswap_ENUM(pc + 0),
+                         (GLenum) bswap_ENUM(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLuint) bswap_CARD32(pc + 12),
+                         (GLint) bswap_CARD32(pc + 16),
+                         (GLint) bswap_CARD32(pc + 20));
 }
 
 void
 __glXDispSwap_FramebufferTextureLayer(GLbyte * pc)
 {
-    glFramebufferTextureLayer((GLenum) bswap_ENUM(pc + 0),
-                              (GLenum) bswap_ENUM(pc + 4),
-                              (GLuint) bswap_CARD32(pc + 8),
-                              (GLint) bswap_CARD32(pc + 12),
-                              (GLint) bswap_CARD32(pc + 16));
+    PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer =
+        __glGetProcAddress("glFramebufferTextureLayer");
+    FramebufferTextureLayer((GLenum) bswap_ENUM(pc + 0),
+                            (GLenum) bswap_ENUM(pc + 4),
+                            (GLuint) bswap_CARD32(pc + 8),
+                            (GLint) bswap_CARD32(pc + 12),
+                            (GLint) bswap_CARD32(pc + 16));
 }
 
 int
 __glXDispSwap_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGENFRAMEBUFFERSPROC GenFramebuffers =
+        __glGetProcAddress("glGenFramebuffers");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -4980,7 +5122,7 @@ __glXDispSwap_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
         GLuint *framebuffers =
             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                  4);
-        glGenFramebuffers(n, framebuffers);
+        GenFramebuffers(n, framebuffers);
         (void) bswap_32_array((uint32_t *) framebuffers, n);
         __glXSendReplySwap(cl->client, framebuffers, n, 4, GL_TRUE, 0);
         error = Success;
@@ -4992,6 +5134,8 @@ __glXDispSwap_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGENRENDERBUFFERSPROC GenRenderbuffers =
+        __glGetProcAddress("glGenRenderbuffers");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -5005,7 +5149,7 @@ __glXDispSwap_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
         GLuint *renderbuffers =
             __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                  4);
-        glGenRenderbuffers(n, renderbuffers);
+        GenRenderbuffers(n, renderbuffers);
         (void) bswap_32_array((uint32_t *) renderbuffers, n);
         __glXSendReplySwap(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
         error = Success;
@@ -5017,13 +5161,18 @@ __glXDispSwap_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDispSwap_GenerateMipmap(GLbyte * pc)
 {
-    glGenerateMipmap((GLenum) bswap_ENUM(pc + 0));
+    PFNGLGENERATEMIPMAPPROC GenerateMipmap =
+        __glGetProcAddress("glGenerateMipmap");
+    GenerateMipmap((GLenum) bswap_ENUM(pc + 0));
 }
 
 int
 __glXDispSwap_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
                                                   GLbyte * pc)
 {
+    PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC
+        GetFramebufferAttachmentParameteriv =
+        __glGetProcAddress("glGetFramebufferAttachmentParameteriv");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -5033,10 +5182,10 @@ __glXDispSwap_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
     if (cx != NULL) {
         GLint params[1];
 
-        glGetFramebufferAttachmentParameteriv((GLenum) bswap_ENUM(pc + 0),
-                                              (GLenum) bswap_ENUM(pc + 4),
-                                              (GLenum) bswap_ENUM(pc + 8),
-                                              params);
+        GetFramebufferAttachmentParameteriv((GLenum) bswap_ENUM(pc + 0),
+                                            (GLenum) bswap_ENUM(pc + 4),
+                                            (GLenum) bswap_ENUM(pc + 8),
+                                            params);
         (void) bswap_32_array((uint32_t *) params, 1);
         __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
         error = Success;
@@ -5048,6 +5197,8 @@ __glXDispSwap_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
 int
 __glXDispSwap_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv =
+        __glGetProcAddress("glGetRenderbufferParameteriv");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -5057,8 +5208,8 @@ __glXDispSwap_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLint params[1];
 
-        glGetRenderbufferParameteriv((GLenum) bswap_ENUM(pc + 0),
-                                     (GLenum) bswap_ENUM(pc + 4), params);
+        GetRenderbufferParameteriv((GLenum) bswap_ENUM(pc + 0),
+                                   (GLenum) bswap_ENUM(pc + 4), params);
         (void) bswap_32_array((uint32_t *) params, 1);
         __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
         error = Success;
@@ -5070,6 +5221,8 @@ __glXDispSwap_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLISFRAMEBUFFERPROC IsFramebuffer =
+        __glGetProcAddress("glIsFramebuffer");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -5079,7 +5232,7 @@ __glXDispSwap_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLboolean retval;
 
-        retval = glIsFramebuffer((GLuint) bswap_CARD32(pc + 0));
+        retval = IsFramebuffer((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -5090,6 +5243,8 @@ __glXDispSwap_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
 int
 __glXDispSwap_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
 {
+    PFNGLISRENDERBUFFERPROC IsRenderbuffer =
+        __glGetProcAddress("glIsRenderbuffer");
     xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
     __GLXcontext *const cx =
@@ -5099,7 +5254,7 @@ __glXDispSwap_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
     if (cx != NULL) {
         GLboolean retval;
 
-        retval = glIsRenderbuffer((GLuint) bswap_CARD32(pc + 0));
+        retval = IsRenderbuffer((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -5110,38 +5265,48 @@ __glXDispSwap_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
 void
 __glXDispSwap_RenderbufferStorage(GLbyte * pc)
 {
-    glRenderbufferStorage((GLenum) bswap_ENUM(pc + 0),
-                          (GLenum) bswap_ENUM(pc + 4),
-                          (GLsizei) bswap_CARD32(pc + 8),
-                          (GLsizei) bswap_CARD32(pc + 12));
+    PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage =
+        __glGetProcAddress("glRenderbufferStorage");
+    RenderbufferStorage((GLenum) bswap_ENUM(pc + 0),
+                        (GLenum) bswap_ENUM(pc + 4),
+                        (GLsizei) bswap_CARD32(pc + 8),
+                        (GLsizei) bswap_CARD32(pc + 12));
 }
 
 void
 __glXDispSwap_RenderbufferStorageMultisample(GLbyte * pc)
 {
-    glRenderbufferStorageMultisample((GLenum) bswap_ENUM(pc + 0),
-                                     (GLsizei) bswap_CARD32(pc + 4),
-                                     (GLenum) bswap_ENUM(pc + 8),
-                                     (GLsizei) bswap_CARD32(pc + 12),
-                                     (GLsizei) bswap_CARD32(pc + 16));
+    PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample =
+        __glGetProcAddress("glRenderbufferStorageMultisample");
+    RenderbufferStorageMultisample((GLenum) bswap_ENUM(pc + 0),
+                                   (GLsizei) bswap_CARD32(pc + 4),
+                                   (GLenum) bswap_ENUM(pc + 8),
+                                   (GLsizei) bswap_CARD32(pc + 12),
+                                   (GLsizei) bswap_CARD32(pc + 16));
 }
 
 void
 __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc)
 {
-    glSecondaryColor3fvEXT((const GLfloat *)
-                           bswap_32_array((uint32_t *) (pc + 0), 3));
+    PFNGLSECONDARYCOLOR3FVEXTPROC SecondaryColor3fvEXT =
+        __glGetProcAddress("glSecondaryColor3fvEXT");
+    SecondaryColor3fvEXT((const GLfloat *)
+                         bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
 void
 __glXDispSwap_FogCoordfvEXT(GLbyte * pc)
 {
-    glFogCoordfvEXT((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
+    PFNGLFOGCOORDFVEXTPROC FogCoordfvEXT =
+        __glGetProcAddress("glFogCoordfvEXT");
+    FogCoordfvEXT((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
 }
 
 void
 __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV =
+        __glGetProcAddress("glVertexAttrib1dvNV");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 12);
@@ -5149,30 +5314,36 @@ __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib1dvNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
-                                                          1));
+    VertexAttrib1dvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                        1));
 }
 
 void
 __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc)
 {
-    glVertexAttrib1fvNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
-                                                         1));
+    PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV =
+        __glGetProcAddress("glVertexAttrib1fvNV");
+    VertexAttrib1fvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       1));
 }
 
 void
 __glXDispSwap_VertexAttrib1svNV(GLbyte * pc)
 {
-    glVertexAttrib1svNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                         1));
+    PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV =
+        __glGetProcAddress("glVertexAttrib1svNV");
+    VertexAttrib1svNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       1));
 }
 
 void
 __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV =
+        __glGetProcAddress("glVertexAttrib2dvNV");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 20);
@@ -5180,30 +5351,36 @@ __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib2dvNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
-                                                          2));
+    VertexAttrib2dvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                        2));
 }
 
 void
 __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc)
 {
-    glVertexAttrib2fvNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
-                                                         2));
+    PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV =
+        __glGetProcAddress("glVertexAttrib2fvNV");
+    VertexAttrib2fvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       2));
 }
 
 void
 __glXDispSwap_VertexAttrib2svNV(GLbyte * pc)
 {
-    glVertexAttrib2svNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                         2));
+    PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV =
+        __glGetProcAddress("glVertexAttrib2svNV");
+    VertexAttrib2svNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       2));
 }
 
 void
 __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV =
+        __glGetProcAddress("glVertexAttrib3dvNV");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 28);
@@ -5211,30 +5388,36 @@ __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib3dvNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
-                                                          3));
+    VertexAttrib3dvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                        3));
 }
 
 void
 __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc)
 {
-    glVertexAttrib3fvNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
-                                                         3));
+    PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV =
+        __glGetProcAddress("glVertexAttrib3fvNV");
+    VertexAttrib3fvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       3));
 }
 
 void
 __glXDispSwap_VertexAttrib3svNV(GLbyte * pc)
 {
-    glVertexAttrib3svNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                         3));
+    PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV =
+        __glGetProcAddress("glVertexAttrib3svNV");
+    VertexAttrib3svNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       3));
 }
 
 void
 __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV =
+        __glGetProcAddress("glVertexAttrib4dvNV");
 #ifdef __GLX_ALIGN64
     if ((unsigned long) (pc) & 7) {
         (void) memmove(pc - 4, pc, 36);
@@ -5242,37 +5425,45 @@ __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttrib4dvNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
-                                                          4));
+    VertexAttrib4dvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                        4));
 }
 
 void
 __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc)
 {
-    glVertexAttrib4fvNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
-                                                         4));
+    PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV =
+        __glGetProcAddress("glVertexAttrib4fvNV");
+    VertexAttrib4fvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       4));
 }
 
 void
 __glXDispSwap_VertexAttrib4svNV(GLbyte * pc)
 {
-    glVertexAttrib4svNV((GLuint) bswap_CARD32(pc + 0),
-                        (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
-                                                         4));
+    PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV =
+        __glGetProcAddress("glVertexAttrib4svNV");
+    VertexAttrib4svNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       4));
 }
 
 void
 __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc)
 {
-    glVertexAttrib4ubvNV((GLuint) bswap_CARD32(pc + 0),
-                         (const GLubyte *) (pc + 4));
+    PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV =
+        __glGetProcAddress("glVertexAttrib4ubvNV");
+    VertexAttrib4ubvNV((GLuint) bswap_CARD32(pc + 0),
+                       (const GLubyte *) (pc + 4));
 }
 
 void
 __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS1DVNVPROC VertexAttribs1dvNV =
+        __glGetProcAddress("glVertexAttribs1dvNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
 #ifdef __GLX_ALIGN64
@@ -5284,37 +5475,43 @@ __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttribs1dvNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLdouble *)
-                         bswap_64_array((uint64_t *) (pc + 8), 0));
+    VertexAttribs1dvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
+                                                         0));
 }
 
 void
 __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV =
+        __glGetProcAddress("glVertexAttribs1fvNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    glVertexAttribs1fvNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
-                                                          0));
+    VertexAttribs1fvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                                        0));
 }
 
 void
 __glXDispSwap_VertexAttribs1svNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV =
+        __glGetProcAddress("glVertexAttribs1svNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    glVertexAttribs1svNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
-                                                          0));
+    VertexAttribs1svNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
+                                                        0));
 }
 
 void
 __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS2DVNVPROC VertexAttribs2dvNV =
+        __glGetProcAddress("glVertexAttribs2dvNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
 #ifdef __GLX_ALIGN64
@@ -5326,37 +5523,43 @@ __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttribs2dvNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLdouble *)
-                         bswap_64_array((uint64_t *) (pc + 8), 0));
+    VertexAttribs2dvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
+                                                         0));
 }
 
 void
 __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV =
+        __glGetProcAddress("glVertexAttribs2fvNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    glVertexAttribs2fvNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
-                                                          0));
+    VertexAttribs2fvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                                        0));
 }
 
 void
 __glXDispSwap_VertexAttribs2svNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV =
+        __glGetProcAddress("glVertexAttribs2svNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    glVertexAttribs2svNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
-                                                          0));
+    VertexAttribs2svNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
+                                                        0));
 }
 
 void
 __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS3DVNVPROC VertexAttribs3dvNV =
+        __glGetProcAddress("glVertexAttribs3dvNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
 #ifdef __GLX_ALIGN64
@@ -5368,37 +5571,43 @@ __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttribs3dvNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLdouble *)
-                         bswap_64_array((uint64_t *) (pc + 8), 0));
+    VertexAttribs3dvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
+                                                         0));
 }
 
 void
 __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV =
+        __glGetProcAddress("glVertexAttribs3fvNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    glVertexAttribs3fvNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
-                                                          0));
+    VertexAttribs3fvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                                        0));
 }
 
 void
 __glXDispSwap_VertexAttribs3svNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV =
+        __glGetProcAddress("glVertexAttribs3svNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    glVertexAttribs3svNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
-                                                          0));
+    VertexAttribs3svNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
+                                                        0));
 }
 
 void
 __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS4DVNVPROC VertexAttribs4dvNV =
+        __glGetProcAddress("glVertexAttribs4dvNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
 #ifdef __GLX_ALIGN64
@@ -5410,45 +5619,53 @@ __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc)
     }
 #endif
 
-    glVertexAttribs4dvNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLdouble *)
-                         bswap_64_array((uint64_t *) (pc + 8), 0));
+    VertexAttribs4dvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
+                                                         0));
 }
 
 void
 __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV =
+        __glGetProcAddress("glVertexAttribs4fvNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    glVertexAttribs4fvNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
-                                                          0));
+    VertexAttribs4fvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                                        0));
 }
 
 void
 __glXDispSwap_VertexAttribs4svNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV =
+        __glGetProcAddress("glVertexAttribs4svNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    glVertexAttribs4svNV((GLuint) bswap_CARD32(pc + 0),
-                         n,
-                         (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
-                                                          0));
+    VertexAttribs4svNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
+                                                        0));
 }
 
 void
 __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV =
+        __glGetProcAddress("glVertexAttribs4ubvNV");
     const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    glVertexAttribs4ubvNV((GLuint) bswap_CARD32(pc + 0),
-                          n, (const GLubyte *) (pc + 8));
+    VertexAttribs4ubvNV((GLuint) bswap_CARD32(pc + 0),
+                        n, (const GLubyte *) (pc + 8));
 }
 
 void
 __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc)
 {
-    glActiveStencilFaceEXT((GLenum) bswap_ENUM(pc + 0));
+    PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT =
+        __glGetProcAddress("glActiveStencilFaceEXT");
+    ActiveStencilFaceEXT((GLenum) bswap_ENUM(pc + 0));
 }
diff --git a/xorg-server/glx/indirect_program.c b/xorg-server/glx/indirect_program.c
index db22d845d..fa4a2408b 100644
--- a/xorg-server/glx/indirect_program.c
+++ b/xorg-server/glx/indirect_program.c
@@ -104,29 +104,43 @@ DoGetProgramString(struct __GLXclientStateRec *cl, GLbyte * pc,
 int
 __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *cl, GLbyte * pc)
 {
-    return DoGetProgramString(cl, pc, glGetProgramivARB,
-                              glGetProgramStringARB, False);
+    PFNGLGETPROGRAMIVARBPROC get_program =
+        __glGetProcAddress("glGetProgramivARB");
+    PFNGLGETPROGRAMSTRINGARBPROC get_program_string =
+        __glGetProcAddress("glGetProgramStringARB");
+
+    return DoGetProgramString(cl, pc, get_program, get_program_string, False);
 }
 
 int
 __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *cl, GLbyte * pc)
 {
-    return DoGetProgramString(cl, pc, glGetProgramivARB,
-                              glGetProgramStringARB, True);
+    PFNGLGETPROGRAMIVARBPROC get_program =
+        __glGetProcAddress("glGetProgramivARB");
+    PFNGLGETPROGRAMSTRINGARBPROC get_program_string =
+        __glGetProcAddress("glGetProgramStringARB");
+
+    return DoGetProgramString(cl, pc, get_program, get_program_string, True);
 }
 
 int
 __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *cl, GLbyte * pc)
 {
-    return DoGetProgramString(cl, pc, (PFNGLGETPROGRAMIVARBPROC)glGetProgramivNV,
-                              (PFNGLGETPROGRAMSTRINGARBPROC)glGetProgramStringNV,
-                              False);
+    PFNGLGETPROGRAMIVARBPROC get_program =
+        __glGetProcAddress("glGetProgramivARB");
+    PFNGLGETPROGRAMSTRINGARBPROC get_program_string =
+        __glGetProcAddress("glGetProgramStringARB");
+
+    return DoGetProgramString(cl, pc, get_program, get_program_string, False);
 }
 
 int
 __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *cl, GLbyte * pc)
 {
-    return DoGetProgramString(cl, pc, (PFNGLGETPROGRAMIVARBPROC)glGetProgramivNV,
-                              (PFNGLGETPROGRAMSTRINGARBPROC)glGetProgramStringNV,
-                              True);
+    PFNGLGETPROGRAMIVARBPROC get_program =
+        __glGetProcAddress("glGetProgramivARB");
+    PFNGLGETPROGRAMSTRINGARBPROC get_program_string =
+        __glGetProcAddress("glGetProgramStringARB");
+
+    return DoGetProgramString(cl, pc, get_program, get_program_string, True);
 }
diff --git a/xorg-server/glx/render2.c b/xorg-server/glx/render2.c
index 5a2f4827e..8d9b5f4d2 100644
--- a/xorg-server/glx/render2.c
+++ b/xorg-server/glx/render2.c
@@ -231,13 +231,21 @@ __glXDisp_DrawArrays(GLbyte * pc)
             glEdgeFlagPointer(stride, (const GLboolean *) pc);
             break;
         case GL_SECONDARY_COLOR_ARRAY:
+        {
+            PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT =
+                __glGetProcAddress("glSecondaryColorPointerEXT");
             glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
-            glSecondaryColorPointerEXT(numVals, datatype, stride, pc);
+            SecondaryColorPointerEXT(numVals, datatype, stride, pc);
             break;
+        }
         case GL_FOG_COORD_ARRAY:
+        {
+            PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT =
+                __glGetProcAddress("glFogCoordPointerEXT");
             glEnableClientState(GL_FOG_COORD_ARRAY);
-            glFogCoordPointerEXT(datatype, stride, pc);
+            FogCoordPointerEXT(datatype, stride, pc);
             break;
+        }
         default:
             break;
         }
diff --git a/xorg-server/glx/render2swap.c b/xorg-server/glx/render2swap.c
index e6f73b896..6ed364f75 100644
--- a/xorg-server/glx/render2swap.c
+++ b/xorg-server/glx/render2swap.c
@@ -353,13 +353,21 @@ __glXDispSwap_DrawArrays(GLbyte * pc)
             glEdgeFlagPointer(stride, (const GLboolean *) pc);
             break;
         case GL_SECONDARY_COLOR_ARRAY:
+        {
+            PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT =
+                __glGetProcAddress("glSecondaryColorPointerEXT");
             glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
-            glSecondaryColorPointerEXT(numVals, datatype, stride, pc);
+            SecondaryColorPointerEXT(numVals, datatype, stride, pc);
             break;
+        }
         case GL_FOG_COORD_ARRAY:
+        {
+            PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT =
+                __glGetProcAddress("glFogCoordPointerEXT");
             glEnableClientState(GL_FOG_COORD_ARRAY);
-            glFogCoordPointerEXT(datatype, stride, pc);
+            FogCoordPointerEXT(datatype, stride, pc);
             break;
+        }
         default:
             break;
         }