Merge remote branch 'origin/master' into radeon-rewrite

Conflicts:
	configure.ac
	src/mesa/drivers/dri/r200/r200_context.c
	src/mesa/drivers/dri/r300/r300_render.c

16 files changed, 278 insertions, 111 deletions

diff --git a/src/glx/mini/Makefile b/src/glx/mini/Makefile
index aabc1d2be30..6b5a3c76d74 100644
--- a/src/glx/mini/Makefile
+++ b/src/glx/mini/Makefile
@@ -65,6 +65,7 @@ drmtest: xf86drm.o drmtest.o
 
 
 depend: $(C_SOURCES) $(ASM_SOURCES)
+	rm -f depend
 	touch depend
 	$(MKDEP) $(MKDEP_OPTIONS) $(INCLUDES) $(C_SOURCES) $(ASM_SOURCES) \
 		> /dev/null 
diff --git a/src/glx/x11/Makefile b/src/glx/x11/Makefile
index 419cb2853b4..86d84d4b9ff 100644
--- a/src/glx/x11/Makefile
+++ b/src/glx/x11/Makefile
@@ -39,9 +39,9 @@ SOURCES = \
 	  dri2_glx.c \
 	  dri2.c
 
-include $(TOP)/src/mesa/sources
+include $(TOP)/src/mesa/sources.mak
 
-MESA_ASM_API = $(addprefix $(TOP)/src/mesa/, $(ASM_API))
+MESA_GLAPI_ASM_SOURCES = $(addprefix $(TOP)/src/mesa/, $(GLAPI_ASM_SOURCES))
 MESA_GLAPI_SOURCES = $(addprefix $(TOP)/src/mesa/, $(GLAPI_SOURCES))
 MESA_GLAPI_OBJECTS = $(addprefix $(TOP)/src/mesa/, $(GLAPI_OBJECTS))
 
@@ -77,10 +77,11 @@ $(TOP)/$(LIB_DIR)/$(GL_LIB_NAME):  $(OBJECTS) Makefile
 		$(GL_LIB_DEPS) $(OBJECTS)
 
 
-depend: $(SOURCES) $(MESA_GLAPI_SOURCES) $(MESA_ASM_API) Makefile
+depend: $(SOURCES) $(MESA_GLAPI_SOURCES) $(MESA_GLAPI_ASM_SOURCES) Makefile
+	rm -f depend
 	touch depend
 	$(MKDEP) $(MKDEP_OPTIONS) $(INCLUDES) $(SOURCES) \
-		$(MESA_GLAPI_SOURCES) $(MESA_ASM_API) 
+		$(MESA_GLAPI_SOURCES) $(MESA_GLAPI_ASM_SOURCES) 
 
 
 # Emacs tags
diff --git a/src/glx/x11/dri2.c b/src/glx/x11/dri2.c
index 3b48cd9c1ca..f967432b994 100644
--- a/src/glx/x11/dri2.c
+++ b/src/glx/x11/dri2.c
@@ -253,7 +253,7 @@ DRI2Buffer *DRI2GetBuffers(Display *dpy, XID drawable,
     *height = rep.height;
     *outCount = rep.count;
 
-    buffers = Xmalloc(count * sizeof buffers[0]);
+    buffers = Xmalloc(rep.count * sizeof buffers[0]);
     if (buffers == NULL) {
 	_XEatData(dpy, rep.count * sizeof repBuffer);
 	UnlockDisplay(dpy);
diff --git a/src/glx/x11/dri2_glx.c b/src/glx/x11/dri2_glx.c
index 2bee67780bd..b878f05ddac 100644
--- a/src/glx/x11/dri2_glx.c
+++ b/src/glx/x11/dri2_glx.c
@@ -60,6 +60,9 @@ struct __GLXDRIdisplayPrivateRec {
     int driMajor;
     int driMinor;
     int driPatch;
+
+    unsigned long configureSeqno;
+    Bool (*oldConfigProc)(Display *, XEvent *, xEvent *);
 };
 
 struct __GLXDRIcontextPrivateRec {
@@ -73,6 +76,7 @@ struct __GLXDRIdrawablePrivateRec {
     __DRIbuffer buffers[5];
     int bufferCount;
     int width, height;
+    unsigned long configureSeqno;
 };
 
 static void dri2DestroyContext(__GLXDRIcontext *context,
@@ -166,6 +170,8 @@ static __GLXDRIdrawable *dri2CreateDrawable(__GLXscreenConfigs *psc,
     pdraw->base.xDrawable = xDrawable;
     pdraw->base.drawable = drawable;
     pdraw->base.psc = psc;
+    pdraw->bufferCount = 0;
+    pdraw->configureSeqno = ~0;
 
     DRI2CreateDrawable(psc->dpy, xDrawable);
 
@@ -223,9 +229,30 @@ dri2GetBuffers(__DRIdrawable *driDrawable,
 	       int *out_count, void *loaderPrivate)
 {
     __GLXDRIdrawablePrivate *pdraw = loaderPrivate;
+    __GLXdisplayPrivate *dpyPriv = __glXInitialize(pdraw->base.psc->dpy);
+    __GLXDRIdisplayPrivate *pdp = (__GLXDRIdisplayPrivate *)dpyPriv->dri2Display;
     DRI2Buffer *buffers;
     int i;
 
+    /**
+     * Check if a ConfigureNotify has come in since we last asked for the
+     * buffers associated with this drawable.  If not, we can assume that they're
+     * the same set at glViewport time, and save a synchronous round-trip to the
+     * X Server.
+     */
+    if (pdraw->configureSeqno == pdp->configureSeqno &&
+	count == pdraw->bufferCount) {
+	for (i = 0; i < count; i++) {
+	    if (pdraw->buffers[i].attachment != attachments[i])
+		break;
+	}
+	if (i == count) {
+	    *out_count = pdraw->bufferCount;
+	    return pdraw->buffers;
+	}
+    }
+    pdraw->configureSeqno = pdp->configureSeqno;
+
     buffers = DRI2GetBuffers(pdraw->base.psc->dpy, pdraw->base.xDrawable,
 			     width, height, attachments, count, out_count);
     if (buffers == NULL)
@@ -233,6 +260,7 @@ dri2GetBuffers(__DRIdrawable *driDrawable,
 
     pdraw->width = *width;
     pdraw->height = *height;
+    pdraw->bufferCount = *out_count;
 
     /* This assumes the DRI2 buffer attachment tokens matches the
      * __DRIbuffer tokens. */
@@ -282,8 +310,10 @@ static __GLXDRIscreen *dri2CreateScreen(__GLXscreenConfigs *psc, int screen,
 	return NULL;
 
     psc->driver = driOpenDriver(driverName);
-    if (psc->driver == NULL)
+    if (psc->driver == NULL) {
+	ErrorMessageF("driver pointer missing\n");
 	goto handle_error;
+    }
 
     extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
     if (extensions == NULL) {
@@ -309,11 +339,15 @@ static __GLXDRIscreen *dri2CreateScreen(__GLXscreenConfigs *psc, int screen,
 	return NULL;
     }
 
-    if (drmGetMagic(psc->fd, &magic))
+    if (drmGetMagic(psc->fd, &magic)) {
+	ErrorMessageF("failed to get magic\n");
 	return NULL;
+    }
 
-    if (!DRI2Authenticate(psc->dpy, RootWindow(psc->dpy, screen), magic))
+    if (!DRI2Authenticate(psc->dpy, RootWindow(psc->dpy, screen), magic)) {
+	ErrorMessageF("failed to authenticate magic %d\n", magic);
 	return NULL;
+    }
 
     psc->__driScreen = 
 	psc->dri2->createNewScreen(screen, psc->fd,
@@ -359,6 +393,28 @@ static void dri2DestroyDisplay(__GLXDRIdisplay *dpy)
     Xfree(dpy);
 }
 
+/**
+ * Makes a note on receiving ConfigureNotify that we need to re-check the
+ * DRI2 buffers, as window sizes may have resulted in reallocation.
+ */
+static Bool dri2ConfigureNotifyProc(Display *dpy, XEvent *re, xEvent *event)
+{
+    __GLXdisplayPrivate *dpyPriv = __glXInitialize(dpy);
+    __GLXDRIdisplayPrivate *pdp;
+    Bool ret;
+
+    /* We should always be able to find our pdp, as it only gets torn down
+     * when the Display is torn down.
+     */
+    pdp = (__GLXDRIdisplayPrivate *)dpyPriv->dri2Display;
+
+    ret = pdp->oldConfigProc(dpy, re, event);
+
+    pdp->configureSeqno = re->xconfigure.serial;
+
+    return ret;
+}
+
 /*
  * Allocate, initialize and return a __DRIdisplayPrivate object.
  * This is called from __glXInitialize() when we are given a new
@@ -381,7 +437,11 @@ _X_HIDDEN __GLXDRIdisplay *dri2CreateDisplay(Display *dpy)
 	return NULL;
     }
 
+    pdp->oldConfigProc = XESetWireToEvent(dpy, ConfigureNotify,
+					  dri2ConfigureNotifyProc);
+
     pdp->driPatch = 0;
+    pdp->configureSeqno = 0;
 
     pdp->base.destroyDisplay = dri2DestroyDisplay;
     pdp->base.createScreen = dri2CreateScreen;
diff --git a/src/glx/x11/drisw_glx.c b/src/glx/x11/drisw_glx.c
index fee45952b38..35bbd9151ca 100644
--- a/src/glx/x11/drisw_glx.c
+++ b/src/glx/x11/drisw_glx.c
@@ -113,7 +113,7 @@ swrastGetDrawableInfo(__DRIdrawable * draw,
                       int *x, int *y, int *w, int *h, void *loaderPrivate)
 {
    __GLXDRIdrawablePrivate *pdp = loaderPrivate;
-   __GLXDRIdrawable *pdraw = &(pdp->base);;
+   __GLXDRIdrawable *pdraw = &(pdp->base);
    Display *dpy = pdraw->psc->dpy;
    Drawable drawable;
 
@@ -141,7 +141,7 @@ swrastPutImage(__DRIdrawable * draw, int op,
                int x, int y, int w, int h, char *data, void *loaderPrivate)
 {
    __GLXDRIdrawablePrivate *pdp = loaderPrivate;
-   __GLXDRIdrawable *pdraw = &(pdp->base);;
+   __GLXDRIdrawable *pdraw = &(pdp->base);
    Display *dpy = pdraw->psc->dpy;
    Drawable drawable;
    XImage *ximage;
@@ -176,7 +176,7 @@ swrastGetImage(__DRIdrawable * draw,
                int x, int y, int w, int h, char *data, void *loaderPrivate)
 {
    __GLXDRIdrawablePrivate *pdp = loaderPrivate;
-   __GLXDRIdrawable *pdraw = &(pdp->base);;
+   __GLXDRIdrawable *pdraw = &(pdp->base);
    Display *dpy = pdraw->psc->dpy;
    Drawable drawable;
    XImage *ximage;
diff --git a/src/glx/x11/glx_pbuffer.c b/src/glx/x11/glx_pbuffer.c
index c63d53439d5..a602cd28817 100644
--- a/src/glx/x11/glx_pbuffer.c
+++ b/src/glx/x11/glx_pbuffer.c
@@ -220,14 +220,14 @@ GetDrawableAttribute(Display * dpy, GLXDrawable drawable,
    unsigned int length;
    unsigned int i;
    unsigned int num_attributes;
+   GLboolean use_glx_1_3;
 
    if ((dpy == NULL) || (drawable == 0)) {
       return 0;
    }
 
    priv = __glXInitialize(dpy);
-   GLboolean use_glx_1_3 = ((priv->majorVersion > 1)
-                            || (priv->minorVersion >= 3));
+   use_glx_1_3 = ((priv->majorVersion > 1) || (priv->minorVersion >= 3));
 
    *value = 0;
 
diff --git a/src/glx/x11/glx_query.c b/src/glx/x11/glx_query.c
index 56f34951863..2789b841b1b 100644
--- a/src/glx/x11/glx_query.c
+++ b/src/glx/x11/glx_query.c
@@ -31,6 +31,70 @@
 
 #include "glxclient.h"
 
+#if defined(USE_XCB)
+# include <X11/Xlib-xcb.h>
+# include <xcb/xcb.h>
+# include <xcb/glx.h>
+#endif
+
+#ifdef USE_XCB
+
+/**
+ * Exchange a protocol request for glXQueryServerString.
+ */
+char *
+__glXQueryServerString(Display* dpy,
+                       int opcode,
+                       CARD32 screen,
+                       CARD32 name)
+{
+   xcb_connection_t *c = XGetXCBConnection(dpy);
+   xcb_glx_query_server_string_reply_t* reply =
+      xcb_glx_query_server_string_reply(c,
+                                        xcb_glx_query_server_string(c,
+                                                                    screen,
+                                                                    name),
+                                        NULL);
+
+   /* The spec doesn't mention this, but the Xorg server replies with
+    * a string already terminated with '\0'. */
+   uint32_t len = xcb_glx_query_server_string_string_length(reply);
+   char* buf = Xmalloc(len);
+   memcpy(buf, xcb_glx_query_server_string_string(reply), len);
+   free(reply);
+
+   return buf;
+}
+
+/**
+ * Exchange a protocol request for glGetString.
+ */
+char *
+__glXGetString(Display* dpy,
+               int opcode,
+               CARD32 contextTag,
+               CARD32 name)
+{
+   xcb_connection_t *c = XGetXCBConnection(dpy);
+   xcb_glx_get_string_reply_t* reply =
+      xcb_glx_get_string_reply(c,
+                               xcb_glx_get_string(c,
+                                                  contextTag,
+                                                  name),
+                               NULL);
+
+   /* The spec doesn't mention this, but the Xorg server replies with
+    * a string already terminated with '\0'. */
+   uint32_t len = xcb_glx_get_string_string_length(reply);
+   char* buf = Xmalloc(len);
+   memcpy(buf, xcb_glx_get_string_string(reply), len);
+   free(reply);
+
+   return buf;
+}
+
+#else
+
 /**
  * GLX protocol structure for the ficticious "GXLGenericGetString" request.
  * 
@@ -57,7 +121,7 @@ typedef struct GLXGenericGetString
  * Query the Server GLX string.
  * This routine will allocate the necessay space for the string.
  */
-char *
+static char *
 __glXGetStringFromServer(Display * dpy, int opcode, CARD32 glxCode,
                          CARD32 for_whom, CARD32 name)
 {
@@ -101,3 +165,27 @@ __glXGetStringFromServer(Display * dpy, int opcode, CARD32 glxCode,
 
    return buf;
 }
+
+char *
+__glXQueryServerString(Display* dpy,
+                       int opcode,
+                       CARD32 screen,
+                       CARD32 name)
+{
+   return __glXGetStringFromServer(dpy, opcode,
+                                   X_GLXQueryServerString,
+                                   screen, name);
+}
+
+char *
+__glXGetString(Display* dpy,
+               int opcode,
+               CARD32 contextTag,
+               CARD32 name)
+{
+   return __glXGetStringFromServer(dpy, opcode, X_GLsop_GetString,
+                                   contextTag, name);
+}
+
+#endif /* USE_XCB */
+
diff --git a/src/glx/x11/glxclient.h b/src/glx/x11/glxclient.h
index 02e8750c972..9332eb64d3b 100644
--- a/src/glx/x11/glxclient.h
+++ b/src/glx/x11/glxclient.h
@@ -602,8 +602,11 @@ extern void __glXSendLargeCommand(__GLXcontext *, const GLvoid *, GLint,
 				  const GLvoid *, GLint);
 
 /* Initialize the GLX extension for dpy */
+extern __GLXdisplayPrivate * __glXGetPrivateFromDisplay(Display *dpy);
 extern __GLXdisplayPrivate *__glXInitialize(Display*);
 
+extern void __glXPreferEGL(int state);
+
 /************************************************************************/
 
 extern int __glXDebug;
@@ -739,8 +742,10 @@ extern void _XSend(Display*, const void*, long);
 extern void __glXInitializeVisualConfigFromTags( __GLcontextModes *config,
     int count, const INT32 *bp, Bool tagged_only, Bool fbconfig_style_tags );
 
-extern char * __glXGetStringFromServer( Display * dpy, int opcode,
-    CARD32 glxCode, CARD32 for_whom, CARD32 name );
+extern char * __glXQueryServerString(Display* dpy, int opcode,
+                                     CARD32 screen, CARD32 name);
+extern char * __glXGetString(Display* dpy, int opcode,
+                             CARD32 screen, CARD32 name);
 
 extern char *__glXstrdup(const char *str);
 
diff --git a/src/glx/x11/glxcmds.c b/src/glx/x11/glxcmds.c
index 391e0be05e7..c68b6ac4efe 100644
--- a/src/glx/x11/glxcmds.c
+++ b/src/glx/x11/glxcmds.c
@@ -44,6 +44,12 @@
 #include "xf86dri.h"
 #endif
 
+#if defined(USE_XCB)
+#include <X11/Xlib-xcb.h>
+#include <xcb/xcb.h>
+#include <xcb/glx.h>
+#endif
+
 static const char __glXGLXClientVendorName[] = "SGI";
 static const char __glXGLXClientVersion[] = "1.4";
 
@@ -749,8 +755,10 @@ PUBLIC void glXCopyContext(Display *dpy, GLXContext source,
  */
 static Bool __glXIsDirect(Display *dpy, GLXContextID contextID)
 {
+#if !defined(USE_XCB)
     xGLXIsDirectReq *req;
     xGLXIsDirectReply reply;
+#endif
     CARD8 opcode;
 
     opcode = __glXSetupForCommand(dpy);
@@ -758,6 +766,18 @@ static Bool __glXIsDirect(Display *dpy, GLXContextID contextID)
 	return GL_FALSE;
     }
 
+#ifdef USE_XCB
+   xcb_connection_t* c = XGetXCBConnection(dpy);
+   xcb_glx_is_direct_reply_t* reply =
+      xcb_glx_is_direct_reply(c,
+                              xcb_glx_is_direct(c, contextID),
+                              NULL);
+
+   const Bool is_direct = reply->is_direct ? True : False;
+   free(reply);
+
+   return is_direct;
+#else
     /* Send the glXIsDirect request */
     LockDisplay(dpy);
     GetReq(GLXIsDirect,req);
@@ -769,6 +789,7 @@ static Bool __glXIsDirect(Display *dpy, GLXContextID contextID)
     SyncHandle();
 
     return reply.isDirect;
+#endif /* USE_XCB */
 }
 
 /**
@@ -840,10 +861,15 @@ PUBLIC void glXDestroyGLXPixmap(Display *dpy, GLXPixmap glxpixmap)
 
 PUBLIC void glXSwapBuffers(Display *dpy, GLXDrawable drawable)
 {
-    xGLXSwapBuffersReq *req;
     GLXContext gc;
     GLXContextTag tag;
     CARD8 opcode;
+#ifdef USE_XCB
+    xcb_connection_t *c;
+#else
+    xGLXSwapBuffersReq *req;
+#endif
+
 #ifdef GLX_DIRECT_RENDERING
     __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
 
@@ -871,6 +897,11 @@ PUBLIC void glXSwapBuffers(Display *dpy, GLXDrawable drawable)
 	tag = 0;
     }
 
+#ifdef USE_XCB
+    c = XGetXCBConnection(dpy);
+    xcb_glx_swap_buffers(c, tag, drawable);
+    xcb_flush(c);
+#else
     /* Send the glXSwapBuffers request */
     LockDisplay(dpy);
     GetReq(GLXSwapBuffers,req);
@@ -881,6 +912,7 @@ PUBLIC void glXSwapBuffers(Display *dpy, GLXDrawable drawable)
     UnlockDisplay(dpy);
     SyncHandle();
     XFlush(dpy);
+#endif /* USE_XCB */
 }
 
 
@@ -1314,9 +1346,8 @@ PUBLIC const char *glXQueryExtensionsString( Display *dpy, int screen )
 
     if (!psc->effectiveGLXexts) {
         if (!psc->serverGLXexts) {
-	    psc->serverGLXexts = __glXGetStringFromServer(dpy, priv->majorOpcode,
-					  	   X_GLXQueryServerString,
-					  	   screen, GLX_EXTENSIONS);
+           psc->serverGLXexts =
+              __glXQueryServerString(dpy, priv->majorOpcode, screen, GLX_EXTENSIONS);
 	}
 
 	__glXCalculateUsableExtensions(psc,
@@ -1371,8 +1402,7 @@ PUBLIC const char *glXQueryServerString( Display *dpy, int screen, int name )
     }
 
     if ( *str == NULL ) {
-	*str = __glXGetStringFromServer(dpy, priv->majorOpcode,
-					X_GLXQueryServerString, screen, name);
+       *str = __glXQueryServerString(dpy, priv->majorOpcode, screen, name);
     }
     
     return *str;
@@ -1380,9 +1410,18 @@ PUBLIC const char *glXQueryServerString( Display *dpy, int screen, int name )
 
 void __glXClientInfo (  Display *dpy, int opcode  )
 {
-    xGLXClientInfoReq *req;
-    int size;
     char * ext_str = __glXGetClientGLExtensionString();
+    int size = strlen( ext_str ) + 1;
+
+#ifdef USE_XCB
+   xcb_connection_t *c = XGetXCBConnection(dpy);
+   xcb_glx_client_info(c,
+                       GLX_MAJOR_VERSION,
+                       GLX_MINOR_VERSION,
+                       size,
+                       (const uint8_t *)ext_str);
+#else
+    xGLXClientInfoReq *req;
 
     /* Send the glXClientInfo request */
     LockDisplay(dpy);
@@ -1392,14 +1431,14 @@ void __glXClientInfo (  Display *dpy, int opcode  )
     req->major = GLX_MAJOR_VERSION;
     req->minor = GLX_MINOR_VERSION;
 
-    size = strlen( ext_str ) + 1;
     req->length += (size + 3) >> 2;
     req->numbytes = size;
     Data(dpy, ext_str, size);
 
     UnlockDisplay(dpy);
     SyncHandle();
-    
+#endif /* USE_XCB */
+
     Xfree( ext_str );
 }
 
diff --git a/src/glx/x11/glxcurrent.c b/src/glx/x11/glxcurrent.c
index f3eb045d9f9..4d0a7c65eba 100644
--- a/src/glx/x11/glxcurrent.c
+++ b/src/glx/x11/glxcurrent.c
@@ -312,13 +312,11 @@ SendMakeCurrentRequest(Display * dpy, CARD8 opcode,
 
 #ifdef GLX_DIRECT_RENDERING
 static __GLXDRIdrawable *
-FetchDRIDrawable(Display * dpy,
-                 GLXDrawable glxDrawable, GLXContext gc, Bool pre13)
+FetchDRIDrawable(Display * dpy, GLXDrawable glxDrawable, GLXContext gc)
 {
    __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
    __GLXDRIdrawable *pdraw;
    __GLXscreenConfigs *psc;
-   XID drawable;
 
    if (priv == NULL)
       return NULL;
@@ -330,15 +328,7 @@ FetchDRIDrawable(Display * dpy,
    if (__glxHashLookup(psc->drawHash, glxDrawable, (void *) &pdraw) == 0)
       return pdraw;
 
-   /* If this is glXMakeCurrent (pre GLX 1.3) we allow creating the
-    * GLX drawable on the fly.  Otherwise we pass None as the X
-    * drawable */
-   if (pre13)
-      drawable = glxDrawable;
-   else
-      drawable = None;
-
-   pdraw = psc->driScreen->createDrawable(psc, drawable,
+   pdraw = psc->driScreen->createDrawable(psc, glxDrawable,
                                           glxDrawable, gc->mode);
    if (__glxHashInsert(psc->drawHash, glxDrawable, pdraw)) {
       (*pdraw->destroyDrawable) (pdraw);
@@ -357,7 +347,7 @@ FetchDRIDrawable(Display * dpy,
  */
 static Bool
 MakeContextCurrent(Display * dpy, GLXDrawable draw,
-                   GLXDrawable read, GLXContext gc, Bool pre13)
+                   GLXDrawable read, GLXContext gc)
 {
    xGLXMakeCurrentReply reply;
    const GLXContext oldGC = __glXGetCurrentContext();
@@ -365,7 +355,7 @@ MakeContextCurrent(Display * dpy, GLXDrawable draw,
    const CARD8 oldOpcode = ((gc == oldGC) || (oldGC == &dummyContext))
       ? opcode : __glXSetupForCommand(oldGC->currentDpy);
    Bool bindReturnValue;
-
+   __GLXattribute *state;
 
    if (!opcode || !oldOpcode) {
       return GL_FALSE;
@@ -384,8 +374,21 @@ MakeContextCurrent(Display * dpy, GLXDrawable draw,
 #ifdef GLX_DIRECT_RENDERING
    /* Bind the direct rendering context to the drawable */
    if (gc && gc->driContext) {
-      __GLXDRIdrawable *pdraw = FetchDRIDrawable(dpy, draw, gc, pre13);
-      __GLXDRIdrawable *pread = FetchDRIDrawable(dpy, read, gc, pre13);
+      __GLXDRIdrawable *pdraw = FetchDRIDrawable(dpy, draw, gc);
+      __GLXDRIdrawable *pread = FetchDRIDrawable(dpy, read, gc);
+
+      if ((pdraw == NULL) || (pread == NULL)) {
+         xError error;
+
+         error.errorCode = GLXBadDrawable;
+         error.resourceID = (pdraw == NULL) ? draw : read;
+         error.sequenceNumber = dpy->request;
+         error.type = X_Error;
+         error.majorCode = gc->majorOpcode;
+         error.minorCode = X_GLXMakeContextCurrent;
+         _XError(dpy, &error);
+         return False;
+      }
 
       bindReturnValue =
          (gc->driContext->bindContext) (gc->driContext, pdraw, pread);
@@ -489,8 +492,7 @@ MakeContextCurrent(Display * dpy, GLXDrawable draw,
             } while (0);
 #endif
 
-            __GLXattribute *state =
-               (__GLXattribute *) (gc->client_state_private);
+            state = (__GLXattribute *) (gc->client_state_private);
 
             gc->currentContextTag = reply.contextTag;
             if (state->array_state == NULL) {
@@ -517,15 +519,16 @@ MakeContextCurrent(Display * dpy, GLXDrawable draw,
 PUBLIC Bool
 glXMakeCurrent(Display * dpy, GLXDrawable draw, GLXContext gc)
 {
-   return MakeContextCurrent(dpy, draw, draw, gc, True);
+   return MakeContextCurrent(dpy, draw, draw, gc);
 }
 
 PUBLIC
 GLX_ALIAS(Bool, glXMakeCurrentReadSGI,
           (Display * dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
-          (dpy, d, r, ctx, False), MakeContextCurrent)
+          (dpy, d, r, ctx), MakeContextCurrent)
 
-     PUBLIC GLX_ALIAS(Bool, glXMakeContextCurrent,
-                      (Display * dpy, GLXDrawable d, GLXDrawable r,
-                       GLXContext ctx), (dpy, d, r, ctx, False),
-                      MakeContextCurrent)
+PUBLIC
+GLX_ALIAS(Bool, glXMakeContextCurrent,
+	  (Display * dpy, GLXDrawable d, GLXDrawable r,
+	   GLXContext ctx), (dpy, d, r, ctx),
+	  MakeContextCurrent)
diff --git a/src/glx/x11/glxext.c b/src/glx/x11/glxext.c
index b6bdbd52bb5..be6edf9b193 100644
--- a/src/glx/x11/glxext.c
+++ b/src/glx/x11/glxext.c
@@ -139,7 +139,8 @@ XEXT_GENERATE_FIND_DISPLAY(__glXFindDisplay, __glXExtensionInfo,
 ** Free the per screen configs data as well as the array of
 ** __glXScreenConfigs.
 */
-     static void FreeScreenConfigs(__GLXdisplayPrivate * priv)
+static void
+FreeScreenConfigs(__GLXdisplayPrivate * priv)
 {
    __GLXscreenConfigs *psc;
    GLint i, screens;
@@ -221,6 +222,25 @@ __glXFreeDisplayPrivate(XExtData * extension)
 static Bool
 QueryVersion(Display * dpy, int opcode, int *major, int *minor)
 {
+#ifdef USE_XCB
+   xcb_connection_t *c = XGetXCBConnection(dpy);
+   xcb_glx_query_version_reply_t* reply =
+      xcb_glx_query_version_reply(c,
+                                  xcb_glx_query_version(c,
+                                                        GLX_MAJOR_VERSION,
+                                                        GLX_MINOR_VERSION),
+                                  NULL);
+
+   if(reply->major_version != GLX_MAJOR_VERSION)
+   {
+      free(reply);
+      return GL_FALSE;
+   }
+   *major = reply->major_version;
+   *minor = min(reply->minor_version, GLX_MINOR_VERSION);
+   free(reply);
+   return GL_TRUE;
+#else
    xGLXQueryVersionReq *req;
    xGLXQueryVersionReply reply;
 
@@ -245,6 +265,7 @@ QueryVersion(Display * dpy, int opcode, int *major, int *minor)
    *major = reply.majorVersion;
    *minor = min(reply.minorVersion, GLX_MINOR_VERSION);
    return GL_TRUE;
+#endif /* USE_XCB */
 }
 
 
@@ -529,9 +550,7 @@ getFBConfigs(Display * dpy, __GLXdisplayPrivate * priv, int screen)
    __GLXscreenConfigs *psc;
 
    psc = priv->screenConfigs + screen;
-   psc->serverGLXexts = __glXGetStringFromServer(dpy, priv->majorOpcode,
-                                                 X_GLXQueryServerString,
-                                                 screen, GLX_EXTENSIONS);
+   psc->serverGLXexts = __glXQueryServerString(dpy, priv->majorOpcode, screen, GLX_EXTENSIONS);
 
    LockDisplay(dpy);
 
@@ -589,9 +608,7 @@ AllocAndFetchScreenConfigs(Display * dpy, __GLXdisplayPrivate * priv)
    memset(psc, 0, screens * sizeof(__GLXscreenConfigs));
    priv->screenConfigs = psc;
 
-   priv->serverGLXversion = __glXGetStringFromServer(dpy, priv->majorOpcode,
-                                                     X_GLXQueryServerString,
-                                                     0, GLX_VERSION);
+   priv->serverGLXversion = __glXQueryServerString(dpy, priv->majorOpcode, 0, GLX_VERSION);
    if (priv->serverGLXversion == NULL) {
       FreeScreenConfigs(priv);
       return GL_FALSE;
diff --git a/src/glx/x11/glxextensions.c b/src/glx/x11/glxextensions.c
index d061fa93336..051433a006c 100644
--- a/src/glx/x11/glxextensions.c
+++ b/src/glx/x11/glxextensions.c
@@ -99,7 +99,7 @@ static const struct extension_info known_glx_extensions[] = {
    { GLX(SGIS_color_range),            VER(0,0), N, N, N, N },
    { GLX(SGIS_multisample),            VER(0,0), Y, Y, N, N },
    { GLX(SGIX_fbconfig),               VER(1,3), Y, Y, N, N },
-   { GLX(SGIX_pbuffer),                VER(1,3), Y, N, N, N },
+   { GLX(SGIX_pbuffer),                VER(1,3), Y, Y, N, N },
    { GLX(SGIX_swap_barrier),           VER(0,0), N, N, N, N },
    { GLX(SGIX_swap_group),             VER(0,0), N, N, N, N },
    { GLX(SGIX_visual_select_group),    VER(0,0), Y, Y, N, N },
diff --git a/src/glx/x11/indirect.c b/src/glx/x11/indirect.c
index 1fcd5ca1bb1..fb87abc0a5a 100644
--- a/src/glx/x11/indirect.c
+++ b/src/glx/x11/indirect.c
@@ -5397,8 +5397,7 @@ __glx_TexSubImage_1D2D(unsigned opcode, unsigned dim, GLenum target,
             (void) memcpy((void *) (gc->pc + 44), (void *) (&height), 4);
             (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4);
             (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4);
-            (void) memcpy((void *) (gc->pc + 56),
-                          (void *) ((pixels == NULL) ? one : zero), 4);
+            (void) memset((void *) (gc->pc + 56), 0, 4);
             if (compsize > 0) {
                 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
                                   pixels, gc->pc + 60, gc->pc + 4);
@@ -5424,7 +5423,7 @@ __glx_TexSubImage_1D2D(unsigned opcode, unsigned dim, GLenum target,
             (void) memcpy((void *) (pc + 48), (void *) (&height), 4);
             (void) memcpy((void *) (pc + 52), (void *) (&format), 4);
             (void) memcpy((void *) (pc + 56), (void *) (&type), 4);
-            (void) memcpy((void *) (pc + 60), zero, 4);
+            (void) memset((void *) (pc + 60), 0, 4);
             __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
                                 type, pixels, pc + 64, pc + 8);
         }
@@ -6869,8 +6868,7 @@ __glx_TexSubImage_3D4D(unsigned opcode, unsigned dim, GLenum target,
             (void) memcpy((void *) (gc->pc + 76), (void *) (&extent), 4);
             (void) memcpy((void *) (gc->pc + 80), (void *) (&format), 4);
             (void) memcpy((void *) (gc->pc + 84), (void *) (&type), 4);
-            (void) memcpy((void *) (gc->pc + 88),
-                          (void *) ((pixels == NULL) ? one : zero), 4);
+            (void) memset((void *) (gc->pc + 88), 0, 4);
             if (compsize > 0) {
                 (*gc->fillImage) (gc, dim, width, height, depth, format, type,
                                   pixels, gc->pc + 92, gc->pc + 4);
@@ -6900,7 +6898,7 @@ __glx_TexSubImage_3D4D(unsigned opcode, unsigned dim, GLenum target,
             (void) memcpy((void *) (pc + 80), (void *) (&extent), 4);
             (void) memcpy((void *) (pc + 84), (void *) (&format), 4);
             (void) memcpy((void *) (pc + 88), (void *) (&type), 4);
-            (void) memcpy((void *) (pc + 92), zero, 4);
+            (void) memset((void *) (pc + 92), 0, 4);
             __glXSendLargeImage(gc, compsize, dim, width, height, depth,
                                 format, type, pixels, pc + 96, pc + 8);
         }
@@ -7525,26 +7523,6 @@ __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
 
 #define X_GLrop_ProgramEnvParameter4dvARB 4185
 void
-__indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x,
-                                      GLdouble y, GLdouble z, GLdouble w)
-{
-    __GLXcontext *const gc = __glXGetCurrentContext();
-    const GLuint cmdlen = 44;
-    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
-    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
-    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
-    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
-    (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
-    (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
-    (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) {
-        (void) __glXFlushRenderBuffer(gc, gc->pc);
-    }
-}
-
-#define X_GLrop_ProgramEnvParameter4dvARB 4185
-void
 __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index,
                                        const GLdouble * params)
 {
@@ -7562,26 +7540,6 @@ __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index,
 
 #define X_GLrop_ProgramEnvParameter4fvARB 4184
 void
-__indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x,
-                                      GLfloat y, GLfloat z, GLfloat w)
-{
-    __GLXcontext *const gc = __glXGetCurrentContext();
-    const GLuint cmdlen = 28;
-    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
-    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
-    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
-    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
-    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
-    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
-    (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) {
-        (void) __glXFlushRenderBuffer(gc, gc->pc);
-    }
-}
-
-#define X_GLrop_ProgramEnvParameter4fvARB 4184
-void
 __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index,
                                        const GLfloat * params)
 {
diff --git a/src/glx/x11/indirect.h b/src/glx/x11/indirect.h
index 0719a1b3024..f8c88b36bb8 100644
--- a/src/glx/x11/indirect.h
+++ b/src/glx/x11/indirect.h
@@ -517,9 +517,7 @@ extern HIDDEN void __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLi
 extern HIDDEN void __indirect_glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble * params);
 extern HIDDEN void __indirect_glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat * params);
 extern HIDDEN void __indirect_glGetVertexAttribivARB(GLuint index, GLenum pname, GLint * params);
-extern HIDDEN void __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
 extern HIDDEN void __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params);
-extern HIDDEN void __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
 extern HIDDEN void __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params);
 extern HIDDEN void __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
 extern HIDDEN void __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params);
diff --git a/src/glx/x11/indirect_init.c b/src/glx/x11/indirect_init.c
index 852fe712c66..479184337c1 100644
--- a/src/glx/x11/indirect_init.c
+++ b/src/glx/x11/indirect_init.c
@@ -526,9 +526,7 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->GetVertexAttribdvARB = __indirect_glGetVertexAttribdvARB;
     glAPI->GetVertexAttribfvARB = __indirect_glGetVertexAttribfvARB;
     glAPI->GetVertexAttribivARB = __indirect_glGetVertexAttribivARB;
-    glAPI->ProgramEnvParameter4dARB = __indirect_glProgramEnvParameter4dARB;
     glAPI->ProgramEnvParameter4dvARB = __indirect_glProgramEnvParameter4dvARB;
-    glAPI->ProgramEnvParameter4fARB = __indirect_glProgramEnvParameter4fARB;
     glAPI->ProgramEnvParameter4fvARB = __indirect_glProgramEnvParameter4fvARB;
     glAPI->ProgramLocalParameter4dARB = __indirect_glProgramLocalParameter4dARB;
     glAPI->ProgramLocalParameter4dvARB = __indirect_glProgramLocalParameter4dvARB;
diff --git a/src/glx/x11/single2.c b/src/glx/x11/single2.c
index b008c6996c1..0b2d5113cc8 100644
--- a/src/glx/x11/single2.c
+++ b/src/glx/x11/single2.c
@@ -40,6 +40,7 @@
 #ifdef USE_XCB
 #include <xcb/xcb.h>
 #include <xcb/glx.h>
+#include <X11/Xlib-xcb.h>
 #endif /* USE_XCB */
 
 
@@ -678,9 +679,7 @@ __indirect_glGetString(GLenum name)
     */
 
    (void) __glXFlushRenderBuffer(gc, gc->pc);
-   s = (GLubyte *) __glXGetStringFromServer(dpy, gc->majorOpcode,
-                                            X_GLsop_GetString,
-                                            gc->currentContextTag, name);
+   s = (GLubyte *) __glXGetString(dpy, gc->majorOpcode, gc->currentContextTag, name);
    if (!s) {
       /* Throw data on the floor */
       __glXSetError(gc, GL_OUT_OF_MEMORY);