revert the DRI2 commits

1 files changed, 1043 insertions, 155 deletions

diff --git a/src/glx/x11/glxext.c b/src/glx/x11/glxext.c
index 4d814744cd..6403cbd56d 100644
--- a/src/glx/x11/glxext.c
+++ b/src/glx/x11/glxext.c
@@ -44,25 +44,57 @@
  */     
 
 #include "glxclient.h"
+#include <stdio.h>
 #include <X11/extensions/Xext.h>
 #include <X11/extensions/extutil.h>
+#include <X11/extensions/Xfixes.h>
+#include <X11/extensions/Xdamage.h>
+#include <assert.h>
+#include "indirect_init.h"
 #include "glapi.h"
 #include "glxextensions.h"
 #include "glcontextmodes.h"
 #include "glheader.h"
 
+#ifdef GLX_DIRECT_RENDERING
+#include <inttypes.h>
+#include <sys/mman.h>
+#include "xf86dri.h"
+#include "sarea.h"
+#include "dri_glx.h"
+#endif
+
 #ifdef USE_XCB
 #include <X11/Xlib-xcb.h>
 #include <xcb/xcb.h>
 #include <xcb/glx.h>
 #endif
 
+#include <assert.h>
 
 #ifdef DEBUG
 void __glXDumpDrawBuffer(__GLXcontext *ctx);
 #endif
 
 #ifdef USE_SPARC_ASM
+/*
+ * This is where our dispatch table's bounds are.
+ * And the static mesa_init is taken directly from
+ * Mesa's 'sparc.c' initializer.
+ *
+ * We need something like this here, because this version
+ * of openGL/glx never initializes a Mesa context, and so
+ * the address of the dispatch table pointer never gets stuffed
+ * into the dispatch jump table otherwise.
+ *
+ * It matters only on SPARC, and only if you are using assembler
+ * code instead of C-code indirect dispatch.
+ *
+ * -- FEM, 04.xii.03
+ */
+extern unsigned int _mesa_sparc_glapi_begin;
+extern unsigned int _mesa_sparc_glapi_end;
+extern void __glapi_sparc_icache_flush(unsigned int *);
 static void _glx_mesa_init_sparc_glapi_relocs(void);
 static int _mesa_sparc_needs_init = 1;
 #define INIT_MESA_SPARC { \
@@ -75,11 +107,173 @@ static int _mesa_sparc_needs_init = 1;
 #define INIT_MESA_SPARC
 #endif
 
+#ifdef GLX_DIRECT_RENDERING
+static __DRIscreen *__glXFindDRIScreen(__DRInativeDisplay *dpy, int scrn);
+#endif /* GLX_DIRECT_RENDERING */
+
+static Bool MakeContextCurrent(Display *dpy, GLXDrawable draw,
+    GLXDrawable read, GLXContext gc);
+
+/*
+** We setup some dummy structures here so that the API can be used
+** even if no context is current.
+*/
+
+static GLubyte dummyBuffer[__GLX_BUFFER_LIMIT_SIZE];
+
+/*
+** Dummy context used by small commands when there is no current context.
+** All the
+** gl and glx entry points are designed to operate as nop's when using
+** the dummy context structure.
+*/
+static __GLXcontext dummyContext = {
+    &dummyBuffer[0],
+    &dummyBuffer[0],
+    &dummyBuffer[0],
+    &dummyBuffer[__GLX_BUFFER_LIMIT_SIZE],
+    sizeof(dummyBuffer),
+};
+
+
+/*
+** All indirect rendering contexts will share the same indirect dispatch table.
+*/
+static __GLapi *IndirectAPI = NULL;
+
+
+/*
+ * Current context management and locking
+ */
+
+#if defined( USE_XTHREADS )
+
+/* thread safe */
+static GLboolean TSDinitialized = GL_FALSE;
+static xthread_key_t ContextTSD;
+
+__GLXcontext *__glXGetCurrentContext(void)
+{
+   if (!TSDinitialized) {
+      xthread_key_create(&ContextTSD, NULL);
+      TSDinitialized = GL_TRUE;
+      return &dummyContext;
+   }
+   else {
+      void *p;
+      xthread_get_specific(ContextTSD, &p);
+      if (!p)
+         return &dummyContext;
+      else
+         return (__GLXcontext *) p;
+   }
+}
+
+void __glXSetCurrentContext(__GLXcontext *c)
+{
+   if (!TSDinitialized) {
+      xthread_key_create(&ContextTSD, NULL);
+      TSDinitialized = GL_TRUE;
+   }
+   xthread_set_specific(ContextTSD, c);
+}
+
+
+/* Used by the __glXLock() and __glXUnlock() macros */
+xmutex_rec __glXmutex;
+
+#elif defined( PTHREADS )
+
+pthread_mutex_t __glXmutex = PTHREAD_MUTEX_INITIALIZER;
+
+# if defined( GLX_USE_TLS )
+
+/**
+ * Per-thread GLX context pointer.
+ * 
+ * \c __glXSetCurrentContext is written is such a way that this pointer can
+ * \b never be \c NULL.  This is important!  Because of this
+ * \c __glXGetCurrentContext can be implemented as trivial macro.
+ */
+__thread void * __glX_tls_Context __attribute__((tls_model("initial-exec")))
+    = &dummyContext;
+
+void __glXSetCurrentContext( __GLXcontext * c )
+{
+    __glX_tls_Context = (c != NULL) ? c : &dummyContext;
+}
+
+# else
+
+static pthread_once_t once_control = PTHREAD_ONCE_INIT;
+
+/**
+ * Per-thread data key.
+ * 
+ * Once \c init_thread_data has been called, the per-thread data key will
+ * take a value of \c NULL.  As each new thread is created the default
+ * value, in that thread, will be \c NULL.
+ */
+static pthread_key_t ContextTSD;
+
+/**
+ * Initialize the per-thread data key.
+ * 
+ * This function is called \b exactly once per-process (not per-thread!) to
+ * initialize the per-thread data key.  This is ideally done using the
+ * \c pthread_once mechanism.
+ */
+static void init_thread_data( void )
+{
+    if ( pthread_key_create( & ContextTSD, NULL ) != 0 ) {
+	perror( "pthread_key_create" );
+	exit( -1 );
+    }
+}
+
+void __glXSetCurrentContext( __GLXcontext * c )
+{
+    pthread_once( & once_control, init_thread_data );
+    pthread_setspecific( ContextTSD, c );
+}
+
+__GLXcontext * __glXGetCurrentContext( void )
+{
+    void * v;
+
+    pthread_once( & once_control, init_thread_data );
+
+    v = pthread_getspecific( ContextTSD );
+    return (v == NULL) ? & dummyContext : (__GLXcontext *) v;
+}
+
+# endif /* defined( GLX_USE_TLS ) */
+
+#elif defined( THREADS )
+
+#error Unknown threading method specified.
+
+#else
+
+/* not thread safe */
+__GLXcontext *__glXcurrentContext = &dummyContext;
+
+#endif
+
+
 /*
 ** You can set this cell to 1 to force the gl drawing stuff to be
 ** one command per packet
 */
-_X_HIDDEN int __glXDebug = 0;
+int __glXDebug = 0;
+
+/*
+** forward prototype declarations
+*/
+int __glXCloseDisplay(Display *dpy, XExtCodes *codes);
+
+
+/************************************************************************/
 
 /* Extension required boiler plate */
 
@@ -102,13 +296,16 @@ static /* const */ char *error_list[] = {
     "GLXBadWindow",
 };
 
-static int __glXCloseDisplay(Display *dpy, XExtCodes *codes)
+int __glXCloseDisplay(Display *dpy, XExtCodes *codes)
 {
   GLXContext gc;
 
   gc = __glXGetCurrentContext();
   if (dpy == gc->currentDpy) {
-    __glXSetCurrentContextNull();
+    __glXSetCurrentContext(&dummyContext);
+#ifdef GLX_DIRECT_RENDERING
+    _glapi_set_dispatch(NULL);  /* no-op functions */
+#endif
     __glXFreeContext(gc);
   }
 
@@ -163,10 +360,11 @@ static void FreeScreenConfigs(__GLXdisplayPrivate *priv)
 	Xfree((char*) psc->serverGLXexts);
 
 #ifdef GLX_DIRECT_RENDERING
-	if (psc->driScreen) {
-	    psc->driScreen->destroyScreen(psc);
-	    __glxHashDestroy(psc->drawHash);
-	}
+	/* Free the direct rendering per screen data */
+	if (psc->driScreen.private)
+	    (*psc->driScreen.destroyScreen)(priv->dpy, i,
+					    psc->driScreen.private);
+	psc->driScreen.private = NULL;
 #endif
     }
     XFree((char*) priv->screenConfigs);
@@ -193,12 +391,14 @@ static int __glXFreeDisplayPrivate(XExtData *extension)
 
 #ifdef GLX_DIRECT_RENDERING
     /* Free the direct rendering per display data */
-    if (priv->driDisplay)
-	(*priv->driDisplay->destroyDisplay)(priv->driDisplay);
-    priv->driDisplay = NULL;
-    if (priv->dri2Display)
-	(*priv->dri2Display->destroyDisplay)(priv->dri2Display);
-    priv->dri2Display = NULL;
+    if (priv->driDisplay.private)
+	(*priv->driDisplay.destroyDisplay)(priv->dpy,
+					   priv->driDisplay.private);
+    priv->driDisplay.private = NULL;
+    if (priv->driDisplay.createNewScreen) {
+        Xfree(priv->driDisplay.createNewScreen); /* free array of ptrs */
+        priv->driDisplay.createNewScreen = NULL;
+    }
 #endif
 
     Xfree((char*) priv);
@@ -240,7 +440,7 @@ static Bool QueryVersion(Display *dpy, int opcode, int *major, int *minor)
 }
 
 
-_X_HIDDEN void 
+void 
 __glXInitializeVisualConfigFromTags( __GLcontextModes *config, int count, 
 				     const INT32 *bp, Bool tagged_only,
 				     Bool fbconfig_style_tags )
@@ -434,128 +634,371 @@ __glXInitializeVisualConfigFromTags( __GLcontextModes *config, int count,
     config->haveStencilBuffer = (config->stencilBits > 0);
 }
 
-static __GLcontextModes *
-createConfigsFromProperties(Display *dpy, int nvisuals, int nprops,
-			    int screen, GLboolean tagged_only)
+
+#ifdef GLX_DIRECT_RENDERING
+static unsigned
+filter_modes( __GLcontextModes ** server_modes,
+	      const __GLcontextModes * driver_modes )
 {
-    INT32 buf[__GLX_TOTAL_CONFIG], *props;
-    unsigned prop_size;
-    __GLcontextModes *modes, *m;
-    int i;
+    __GLcontextModes * m;
+    __GLcontextModes ** prev_next;
+    const __GLcontextModes * check;
+    unsigned modes_count = 0;
 
-    if (nprops == 0)
-	return NULL;
+    if ( driver_modes == NULL ) {
+	fprintf(stderr, "libGL warning: 3D driver returned no fbconfigs.\n");
+	return 0;
+    }
 
-    /* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for FBconfigs? */
+    /* For each mode in server_modes, check to see if a matching mode exists
+     * in driver_modes.  If not, then the mode is not available.
+     */
 
-    /* Check number of properties */
-    if (nprops < __GLX_MIN_CONFIG_PROPS || nprops > __GLX_MAX_CONFIG_PROPS)
-	return NULL;
+    prev_next = server_modes;
+    for ( m = *prev_next ; m != NULL ; m = *prev_next ) {
+	GLboolean do_delete = GL_TRUE;
 
-    /* Allocate memory for our config structure */
-    modes = _gl_context_modes_create(nvisuals, sizeof(__GLcontextModes));
-    if (!modes)
-	return NULL;
+	for ( check = driver_modes ; check != NULL ; check = check->next ) {
+	    if ( _gl_context_modes_are_same( m, check ) ) {
+		do_delete = GL_FALSE;
+		break;
+	    }
+	}
 
-    prop_size = nprops * __GLX_SIZE_INT32;
-    if (prop_size <= sizeof(buf))
-	props = buf;
-    else
-	props = Xmalloc(prop_size);
+	/* The 3D has to support all the modes that match the GLX visuals
+	 * sent from the X server.
+	 */
+	if ( do_delete && (m->visualID != 0) ) {
+	    do_delete = GL_FALSE;
 
-    /* Read each config structure and convert it into our format */
-    m = modes;
-    for (i = 0; i < nvisuals; i++) {
-	_XRead(dpy, (char *)props, prop_size);
-	/* Older X servers don't send this so we default it here. */
-	m->drawableType = GLX_WINDOW_BIT;
-	__glXInitializeVisualConfigFromTags(m, nprops, props,
-					    tagged_only, GL_TRUE);
-	m->screen = screen;
-	m = m->next;
-    }
+            if (getenv("LIBGL_DEBUG")) {
+               fprintf(stderr, "libGL warning: 3D driver claims to not support "
+                       "visual 0x%02x\n", m->visualID);
+            }
+	}
 
-    if (props != buf)
-	Xfree(props);
+	if ( do_delete ) {
+	    *prev_next = m->next;
 
-    return modes;
+	    m->next = NULL;
+	    _gl_context_modes_destroy( m );
+	}
+	else {
+	    modes_count++;
+	    prev_next = & m->next;
+	}
+    }
+
+    return modes_count;
 }
 
-static GLboolean
-getVisualConfigs(Display *dpy, __GLXdisplayPrivate *priv, int screen)
+
+/**
+ * Implement \c __DRIinterfaceMethods::getProcAddress.
+ */
+static __DRIfuncPtr get_proc_address( const char * proc_name )
 {
-    xGLXGetVisualConfigsReq *req;
-    __GLXscreenConfigs *psc;
-    xGLXGetVisualConfigsReply reply;
+    if (strcmp( proc_name, "glxEnableExtension" ) == 0) {
+	return (__DRIfuncPtr) __glXScrEnableExtension;
+    }
     
-    LockDisplay(dpy);
+    return NULL;
+}
+
+#ifdef XDAMAGE_1_1_INTERFACE
+static GLboolean has_damage_post(__DRInativeDisplay *dpy)
+{
+    static GLboolean inited = GL_FALSE;
+    static GLboolean has_damage;
+
+    if (!inited) {
+	int major, minor;
 
-    psc = priv->screenConfigs + screen;
-    psc->visuals = NULL;
-    GetReq(GLXGetVisualConfigs, req);
-    req->reqType = priv->majorOpcode;
-    req->glxCode = X_GLXGetVisualConfigs;
-    req->screen = screen;
+	if (XDamageQueryVersion(dpy, &major, &minor) &&
+	    major == 1 && minor >= 1)
+	{
+	    has_damage = GL_TRUE;
+	} else {
+	    has_damage = GL_FALSE;
+	}
+	inited = GL_TRUE;
+    }
 
-    if (!_XReply(dpy, (xReply*) &reply, 0, False))
-	goto out;
+    return has_damage;
+}
+#endif /* XDAMAGE_1_1_INTERFACE */
 
-    psc->visuals = createConfigsFromProperties(dpy,
-					       reply.numVisuals,
-					       reply.numProps,
-					       screen, GL_FALSE);
+static void __glXReportDamage(__DRInativeDisplay *dpy, int screen,
+			      __DRIid drawable,
+			      int x, int y,
+			      drm_clip_rect_t *rects, int num_rects,
+			      GLboolean front_buffer)
+{
+#ifdef XDAMAGE_1_1_INTERFACE
+    XRectangle *xrects;
+    XserverRegion region;
+    int i;
+    int x_off, y_off;
+
+    if (!has_damage_post(dpy))
+	return;
+
+    if (front_buffer) {
+	x_off = x;
+	y_off = y;
+	drawable = RootWindow(dpy, screen);
+    } else{
+	x_off = 0;
+	y_off = 0;
+    }
 
- out:
-    UnlockDisplay(dpy);
-    return psc->visuals != NULL;
+    xrects = malloc(sizeof(XRectangle) * num_rects);
+    if (xrects == NULL)
+	return;
+
+    for (i = 0; i < num_rects; i++) {
+	xrects[i].x = rects[i].x1 + x_off;
+	xrects[i].y = rects[i].y1 + y_off;
+	xrects[i].width = rects[i].x2 - rects[i].x1;
+	xrects[i].height = rects[i].y2 - rects[i].y1;
+    }
+    region = XFixesCreateRegion(dpy, xrects, num_rects);
+    free(xrects);
+    XDamageAdd(dpy, drawable, region);
+    XFixesDestroyRegion(dpy, region);
+#endif
 }
 
-static GLboolean
-getFBConfigs(Display *dpy, __GLXdisplayPrivate *priv, int screen)
+/**
+ * Table of functions exported by the loader to the driver.
+ */
+static const __DRIinterfaceMethods interface_methods = {
+    get_proc_address,
+
+    _gl_context_modes_create,
+    _gl_context_modes_destroy,
+      
+    __glXFindDRIScreen,
+    __glXWindowExists,
+      
+    XF86DRICreateContextWithConfig,
+    XF86DRIDestroyContext,
+
+    XF86DRICreateDrawable,
+    XF86DRIDestroyDrawable,
+    XF86DRIGetDrawableInfo,
+
+    __glXGetUST,
+    __glXGetMscRateOML,
+
+    __glXReportDamage,
+};
+
+
+
+/**
+ * Perform the required libGL-side initialization and call the client-side
+ * driver's \c __driCreateNewScreen function.
+ * 
+ * \param dpy    Display pointer.
+ * \param scrn   Screen number on the display.
+ * \param psc    DRI screen information.
+ * \param driDpy DRI display information.
+ * \param createNewScreen  Pointer to the client-side driver's
+ *               \c __driCreateNewScreen function.
+ * \returns A pointer to the \c __DRIscreenPrivate structure returned by
+ *          the client-side driver on success, or \c NULL on failure.
+ * 
+ * \todo This function needs to be modified to remove context-modes from the
+ *       list stored in the \c __GLXscreenConfigsRec to match the list
+ *       returned by the client-side driver.
+ */
+static void *
+CallCreateNewScreen(Display *dpy, int scrn, __DRIscreen *psc,
+		    __DRIdisplay * driDpy,
+		    PFNCREATENEWSCREENFUNC createNewScreen)
 {
-    xGLXGetFBConfigsReq *fb_req;
-    xGLXGetFBConfigsSGIXReq *sgi_req;
-    xGLXVendorPrivateWithReplyReq *vpreq;
-    xGLXGetFBConfigsReply reply;
-    __GLXscreenConfigs *psc;
+    __DRIscreenPrivate *psp = NULL;
+#ifndef GLX_USE_APPLEGL
+    drm_handle_t hSAREA;
+    drmAddress pSAREA = MAP_FAILED;
+    char *BusID;
+    __DRIversion   ddx_version;
+    __DRIversion   dri_version;
+    __DRIversion   drm_version;
+    __DRIframebuffer  framebuffer;
+    int   fd = -1;
+    int   status;
+    const char * err_msg;
+    const char * err_extra;
+    int api_ver = __glXGetInternalVersion();
+
+
+    dri_version.major = driDpy->private->driMajor;
+    dri_version.minor = driDpy->private->driMinor;
+    dri_version.patch = driDpy->private->driPatch;
+
+
+    err_msg = "XF86DRIOpenConnection";
+    err_extra = NULL;
+
+    framebuffer.base = MAP_FAILED;
+    framebuffer.dev_priv = NULL;
+
+    if (XF86DRIOpenConnection(dpy, scrn, &hSAREA, &BusID)) {
+        int newlyopened;
+	fd = drmOpenOnce(NULL,BusID, &newlyopened);
+	Xfree(BusID); /* No longer needed */
+
+	err_msg = "open DRM";
+	err_extra = strerror( -fd );
+
+	if (fd >= 0) {
+	    drm_magic_t magic;
+
+	    err_msg = "drmGetMagic";
+	    err_extra = NULL;
+
+	    if (!drmGetMagic(fd, &magic)) {
+		drmVersionPtr version = drmGetVersion(fd);
+		if (version) {
+		    drm_version.major = version->version_major;
+		    drm_version.minor = version->version_minor;
+		    drm_version.patch = version->version_patchlevel;
+		    drmFreeVersion(version);
+		}
+		else {
+		    drm_version.major = -1;
+		    drm_version.minor = -1;
+		    drm_version.patch = -1;
+		}
+
+		err_msg = "XF86DRIAuthConnection";
+		if (!newlyopened || XF86DRIAuthConnection(dpy, scrn, magic)) {
+		    char *driverName;
+
+		    /*
+		     * Get device name (like "tdfx") and the ddx version
+		     * numbers.  We'll check the version in each DRI driver's
+		     * "createNewScreen" function.
+		     */
+		    err_msg = "XF86DRIGetClientDriverName";
+		    if (XF86DRIGetClientDriverName(dpy, scrn,
+						   &ddx_version.major,
+						   &ddx_version.minor,
+						   &ddx_version.patch,
+						   &driverName)) {
+			drm_handle_t  hFB;
+			int        junk;
+
+			/* No longer needed. */
+			Xfree( driverName );
+
+
+			/*
+			 * Get device-specific info.  pDevPriv will point to a struct
+			 * (such as DRIRADEONRec in xfree86/driver/ati/radeon_dri.h)
+			 * that has information about the screen size, depth, pitch,
+			 * ancilliary buffers, DRM mmap handles, etc.
+			 */
+			err_msg = "XF86DRIGetDeviceInfo";
+			if (XF86DRIGetDeviceInfo(dpy, scrn,
+						 &hFB,
+						 &junk,
+						 &framebuffer.size,
+						 &framebuffer.stride,
+						 &framebuffer.dev_priv_size,
+						 &framebuffer.dev_priv)) {
+			    framebuffer.width = DisplayWidth(dpy, scrn);
+			    framebuffer.height = DisplayHeight(dpy, scrn);
+
+			    /*
+			     * Map the framebuffer region.
+			     */
+			    status = drmMap(fd, hFB, framebuffer.size, 
+					    (drmAddressPtr)&framebuffer.base);
+
+			    err_msg = "drmMap of framebuffer";
+			    err_extra = strerror( -status );
+
+			    if ( status == 0 ) {
+				/*
+				 * Map the SAREA region.  Further mmap regions
+				 * may be setup in each DRI driver's
+				 * "createNewScreen" function.
+				 */
+				status = drmMap(fd, hSAREA, SAREA_MAX, 
+						&pSAREA);
+
+				err_msg = "drmMap of sarea";
+				err_extra = strerror( -status );
+
+				if ( status == 0 ) {
+				    __GLcontextModes * driver_modes = NULL;
+				    __GLXscreenConfigs *configs = psc->screenConfigs;
+
+				    err_msg = "InitDriver";
+				    err_extra = NULL;
+				    psp = (*createNewScreen)(dpy, scrn,
+							     psc,
+							     configs->configs,
+							     & ddx_version,
+							     & dri_version,
+							     & drm_version,
+							     & framebuffer,
+							     pSAREA,
+							     fd,
+							     api_ver,
+							     & interface_methods,
+							     & driver_modes );
+
+				    filter_modes( & configs->configs,
+						  driver_modes );
+				    _gl_context_modes_destroy( driver_modes );
+				}
+			    }
+			}
+		    }
+		}
+	    }
+	}
+    }
 
-    psc = priv->screenConfigs + screen;
-    psc->serverGLXexts = __glXGetStringFromServer(dpy, priv->majorOpcode,
-						  X_GLXQueryServerString,
-						  screen, GLX_EXTENSIONS);
+    if ( psp == NULL ) {
+	if ( pSAREA != MAP_FAILED ) {
+	    (void)drmUnmap(pSAREA, SAREA_MAX);
+	}
 
-    LockDisplay(dpy);
+	if ( framebuffer.base != MAP_FAILED ) {
+	    (void)drmUnmap((drmAddress)framebuffer.base, framebuffer.size);
+	}
 
-    psc->configs = NULL;
-    if (atof(priv->serverGLXversion) >= 1.3) {
-	GetReq(GLXGetFBConfigs, fb_req);
-	fb_req->reqType = priv->majorOpcode;
-	fb_req->glxCode = X_GLXGetFBConfigs;
-	fb_req->screen = screen;
-    } else if (strstr(psc->serverGLXexts, "GLX_SGIX_fbconfig") != NULL) {
-	GetReqExtra(GLXVendorPrivateWithReply,
-		    sz_xGLXGetFBConfigsSGIXReq +
-		    sz_xGLXVendorPrivateWithReplyReq, vpreq);
-	sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
-	sgi_req->reqType = priv->majorOpcode;
-	sgi_req->glxCode = X_GLXVendorPrivateWithReply;
-	sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
-	sgi_req->screen = screen;
-    } else
-	goto out;
+	if ( framebuffer.dev_priv != NULL ) {
+	    Xfree(framebuffer.dev_priv);
+	}
 
-    if (!_XReply(dpy, (xReply*) &reply, 0, False))
-	goto out;
+	if ( fd >= 0 ) {
+	    (void)drmCloseOnce(fd);
+	}
 
-    psc->configs = createConfigsFromProperties(dpy,
-					       reply.numFBConfigs,
-					       reply.numAttribs * 2,
-					       screen, GL_TRUE);
+	(void)XF86DRICloseConnection(dpy, scrn);
 
- out:
-    UnlockDisplay(dpy);
-    return psc->configs != NULL;
+	if ( err_extra != NULL ) {
+	    fprintf(stderr, "libGL error: %s failed (%s)\n", err_msg,
+		    err_extra);
+	}
+	else {
+	    fprintf(stderr, "libGL error: %s failed\n", err_msg );
+	}
+
+        fprintf(stderr, "libGL error: reverting to (slow) indirect rendering\n");
+    }
+#endif /* !GLX_USE_APPLEGL */
+
+    return psp;
 }
+#endif /* GLX_DIRECT_RENDERING */
+
 
 /*
 ** Allocate the memory for the per screen configs for each screen.
@@ -563,8 +1006,17 @@ getFBConfigs(Display *dpy, __GLXdisplayPrivate *priv, int screen)
 */
 static Bool AllocAndFetchScreenConfigs(Display *dpy, __GLXdisplayPrivate *priv)
 {
+    xGLXGetVisualConfigsReq *req;
+    xGLXGetFBConfigsReq *fb_req;
+    xGLXVendorPrivateWithReplyReq *vpreq;
+    xGLXGetFBConfigsSGIXReq *sgi_req;
+    xGLXGetVisualConfigsReply reply;
     __GLXscreenConfigs *psc;
-    GLint i, screens;
+    __GLcontextModes *config;
+    GLint i, j, nprops, screens;
+    INT32 buf[__GLX_TOTAL_CONFIG], *props;
+    unsigned supported_request = 0;
+    unsigned prop_size;
 
     /*
     ** First allocate memory for the array of per screen configs.
@@ -578,30 +1030,159 @@ static Bool AllocAndFetchScreenConfigs(Display *dpy, __GLXdisplayPrivate *priv)
     priv->screenConfigs = psc;
     
     priv->serverGLXversion = __glXGetStringFromServer(dpy, priv->majorOpcode,
-						      X_GLXQueryServerString,
-						      0, GLX_VERSION);
+					 X_GLXQueryServerString,
+					 0, GLX_VERSION);
     if ( priv->serverGLXversion == NULL ) {
 	FreeScreenConfigs(priv);
 	return GL_FALSE;
     }
 
+    if ( atof( priv->serverGLXversion ) >= 1.3 ) {
+	supported_request = 1;
+    }
+
+    /*
+    ** Now fetch each screens configs structures.  If a screen supports
+    ** GL (by returning a numVisuals > 0) then allocate memory for our
+    ** config structure and then fill it in.
+    */
     for (i = 0; i < screens; i++, psc++) {
-	getVisualConfigs(dpy, priv, i);
-	getFBConfigs(dpy, priv, i);
+	if ( supported_request != 1 ) {
+	    psc->serverGLXexts = __glXGetStringFromServer(dpy, priv->majorOpcode,
+							  X_GLXQueryServerString,
+							  i, GLX_EXTENSIONS);
+	    if ( strstr( psc->serverGLXexts, "GLX_SGIX_fbconfig" ) != NULL ) {
+		supported_request = 2;
+	    }
+	    else {
+		supported_request = 3;
+	    }
+	}
 
-	psc->scr = i;
-	psc->dpy = dpy;
-#ifdef GLX_DIRECT_RENDERING
-	psc->drawHash = __glxHashCreate();
-	if (psc->drawHash == NULL)
+
+	LockDisplay(dpy);
+	switch( supported_request ) {
+	    case 1:
+	    GetReq(GLXGetFBConfigs,fb_req);
+	    fb_req->reqType = priv->majorOpcode;
+	    fb_req->glxCode = X_GLXGetFBConfigs;
+	    fb_req->screen = i;
+	    break;
+	   
+	    case 2:
+	    GetReqExtra(GLXVendorPrivateWithReply,
+			sz_xGLXGetFBConfigsSGIXReq-sz_xGLXVendorPrivateWithReplyReq,vpreq);
+	    sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
+	    sgi_req->reqType = priv->majorOpcode;
+	    sgi_req->glxCode = X_GLXVendorPrivateWithReply;
+	    sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
+	    sgi_req->screen = i;
+	    break;
+
+	    case 3:
+	    GetReq(GLXGetVisualConfigs,req);
+	    req->reqType = priv->majorOpcode;
+	    req->glxCode = X_GLXGetVisualConfigs;
+	    req->screen = i;
+	    break;
+ 	}
+
+	if (!_XReply(dpy, (xReply*) &reply, 0, False)) {
+	    /* Something is busted. Punt. */
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    FreeScreenConfigs(priv);
+	    return GL_FALSE;
+	}
+
+	if (!reply.numVisuals) {
+	    /* This screen does not support GL rendering */
+	    UnlockDisplay(dpy);
 	    continue;
-	if (priv->dri2Display)
-	    psc->driScreen = (*priv->dri2Display->createScreen)(psc, i, priv);
-	if (psc->driScreen == NULL && priv->driDisplay)
-	    psc->driScreen = (*priv->driDisplay->createScreen)(psc, i, priv);
-	if (psc->driScreen == NULL) {
-	    __glxHashDestroy(psc->drawHash);
-	    psc->drawHash = NULL;
+	}
+
+	/* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for
+	 * FIXME: FBconfigs? 
+	 */
+	/* Check number of properties */
+	nprops = reply.numProps;
+	if ((nprops < __GLX_MIN_CONFIG_PROPS) ||
+	    (nprops > __GLX_MAX_CONFIG_PROPS)) {
+	    /* Huh?  Not in protocol defined limits.  Punt */
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    FreeScreenConfigs(priv);
+	    return GL_FALSE;
+	}
+
+	/* Allocate memory for our config structure */
+	psc->configs = _gl_context_modes_create(reply.numVisuals,
+						sizeof(__GLcontextModes));
+	if (!psc->configs) {
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    FreeScreenConfigs(priv);
+	    return GL_FALSE;
+	}
+
+	/* Allocate memory for the properties, if needed */
+	if ( supported_request != 3 ) {
+	    nprops *= 2;
+	}
+
+	prop_size = nprops * __GLX_SIZE_INT32;
+
+	if (prop_size <= sizeof(buf)) {
+ 	    props = buf;
+ 	} else {
+	    props = (INT32 *) Xmalloc(prop_size);
+ 	} 
+
+	/* Read each config structure and convert it into our format */
+        config = psc->configs;
+	for (j = 0; j < reply.numVisuals; j++) {
+	    assert( config != NULL );
+	    _XRead(dpy, (char *)props, prop_size);
+
+	    if ( supported_request != 3 ) {
+		config->rgbMode = GL_TRUE;
+		config->drawableType = GLX_WINDOW_BIT;
+	    }
+	    else {
+		config->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT;
+	    }
+
+	    __glXInitializeVisualConfigFromTags( config, nprops, props,
+						 (supported_request != 3),
+						 GL_TRUE );
+	    if ( config->fbconfigID == GLX_DONT_CARE ) {
+		config->fbconfigID = config->visualID;
+	    }
+	    config->screen = i;
+	    config = config->next;
+	}
+	if (props != buf) {
+	    Xfree((char *)props);
+	}
+	UnlockDisplay(dpy);
+
+#ifdef GLX_DIRECT_RENDERING
+        /* Initialize per screen dynamic client GLX extensions */
+	psc->ext_list_first_time = GL_TRUE;
+	/* Initialize the direct rendering per screen data and functions */
+	if (priv->driDisplay.private != NULL) {
+	    /* FIXME: Should it be some sort of an error if createNewScreen[i]
+	     * FIXME: is NULL?
+	     */
+	    if (priv->driDisplay.createNewScreen &&
+		priv->driDisplay.createNewScreen[i]) {
+
+		psc->driScreen.screenConfigs = (void *)psc;
+		psc->driScreen.private =
+		    CallCreateNewScreen(dpy, i, & psc->driScreen,
+					& priv->driDisplay,
+					priv->driDisplay.createNewScreen[i] );
+	    }
 	}
 #endif
     }
@@ -612,7 +1193,7 @@ static Bool AllocAndFetchScreenConfigs(Display *dpy, __GLXdisplayPrivate *priv)
 /*
 ** Initialize the client side extension code.
 */
-_X_HIDDEN __GLXdisplayPrivate *__glXInitialize(Display* dpy)
+__GLXdisplayPrivate *__glXInitialize(Display* dpy)
 {
     XExtDisplayInfo *info = __glXFindDisplay(dpy);
     XExtData **privList, *private, *found;
@@ -692,8 +1273,8 @@ _X_HIDDEN __GLXdisplayPrivate *__glXInitialize(Display* dpy)
     ** (e.g., those called in AllocAndFetchScreenConfigs).
     */
     if (getenv("LIBGL_ALWAYS_INDIRECT") == NULL) {
-        dpyPriv->dri2Display = dri2CreateDisplay(dpy);
-	dpyPriv->driDisplay = driCreateDisplay(dpy);
+        dpyPriv->driDisplay.private =
+            driCreateDisplay(dpy, &dpyPriv->driDisplay);
     }
 #endif
 
@@ -727,7 +1308,7 @@ _X_HIDDEN __GLXdisplayPrivate *__glXInitialize(Display* dpy)
 ** Setup for sending a GLX command on dpy.  Make sure the extension is
 ** initialized.  Try to avoid calling __glXInitialize as its kinda slow.
 */
-_X_HIDDEN CARD8 __glXSetupForCommand(Display *dpy)
+CARD8 __glXSetupForCommand(Display *dpy)
 {
     GLXContext gc;
     __GLXdisplayPrivate *priv;
@@ -768,7 +1349,7 @@ _X_HIDDEN CARD8 __glXSetupForCommand(Display *dpy)
  * Modify this function to use \c ctx->pc instead of the explicit
  * \c pc parameter.
  */
-_X_HIDDEN GLubyte *__glXFlushRenderBuffer(__GLXcontext *ctx, GLubyte *pc)
+GLubyte *__glXFlushRenderBuffer(__GLXcontext *ctx, GLubyte *pc)
 {
     Display * const dpy = ctx->currentDpy;
 #ifdef USE_XCB
@@ -780,8 +1361,7 @@ _X_HIDDEN GLubyte *__glXFlushRenderBuffer(__GLXcontext *ctx, GLubyte *pc)
 
     if ( (dpy != NULL) && (size > 0) ) {
 #ifdef USE_XCB
-	xcb_glx_render(c, ctx->currentContextTag, size,
-		       (const uint8_t *)ctx->buf);
+	xcb_glx_render(c, ctx->currentContextTag, size, (char *)ctx->buf);
 #else
 	/* Send the entire buffer as an X request */
 	LockDisplay(dpy);
@@ -818,9 +1398,9 @@ _X_HIDDEN GLubyte *__glXFlushRenderBuffer(__GLXcontext *ctx, GLubyte *pc)
  * \param data           Command data.
  * \param dataLen        Size, in bytes, of the command data.
  */
-_X_HIDDEN void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber, 
-				   GLint totalRequests,
-				   const GLvoid * data, GLint dataLen)
+void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber, 
+			 GLint totalRequests,
+			 const GLvoid * data, GLint dataLen)
 {
     Display *dpy = gc->currentDpy;
 #ifdef USE_XCB
@@ -866,9 +1446,9 @@ _X_HIDDEN void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber,
  * \param data       Command data.
  * \param dataLen    Size, in bytes, of the command data.
  */
-_X_HIDDEN void __glXSendLargeCommand(__GLXcontext *ctx,
-				     const GLvoid *header, GLint headerLen,
-				     const GLvoid *data, GLint dataLen)
+void __glXSendLargeCommand(__GLXcontext *ctx,
+			   const GLvoid *header, GLint headerLen,
+			   const GLvoid *data, GLint dataLen)
 {
     GLint maxSize;
     GLint totalRequests, requestNumber;
@@ -904,8 +1484,330 @@ _X_HIDDEN void __glXSendLargeCommand(__GLXcontext *ctx,
 
 /************************************************************************/
 
+PUBLIC GLXContext glXGetCurrentContext(void)
+{
+    GLXContext cx = __glXGetCurrentContext();
+    
+    if (cx == &dummyContext) {
+	return NULL;
+    } else {
+	return cx;
+    }
+}
+
+PUBLIC GLXDrawable glXGetCurrentDrawable(void)
+{
+    GLXContext gc = __glXGetCurrentContext();
+    return gc->currentDrawable;
+}
+
+
+/************************************************************************/
+
+#ifdef GLX_DIRECT_RENDERING
+/* Return the DRI per screen structure */
+__DRIscreen *__glXFindDRIScreen(__DRInativeDisplay *dpy, int scrn)
+{
+    __DRIscreen *pDRIScreen = NULL;
+    XExtDisplayInfo *info = __glXFindDisplay(dpy);
+    XExtData **privList, *found;
+    __GLXdisplayPrivate *dpyPriv;
+    XEDataObject dataObj;
+
+    __glXLock();
+    dataObj.display = dpy;
+    privList = XEHeadOfExtensionList(dataObj);
+    found = XFindOnExtensionList(privList, info->codes->extension);
+    __glXUnlock();
+
+    if (found) {
+	dpyPriv = (__GLXdisplayPrivate *)found->private_data;
+	pDRIScreen = &dpyPriv->screenConfigs[scrn].driScreen;
+    }
+
+    return pDRIScreen;
+}
+#endif
+
+/************************************************************************/
+
+static Bool SendMakeCurrentRequest( Display *dpy, CARD8 opcode,
+    GLXContextID gc, GLXContextTag old_gc, GLXDrawable draw, GLXDrawable read,
+    xGLXMakeCurrentReply * reply );
+
+/**
+ * Sends a GLX protocol message to the specified display to make the context
+ * and the drawables current.
+ *
+ * \param dpy     Display to send the message to.
+ * \param opcode  Major opcode value for the display.
+ * \param gc_id   Context tag for the context to be made current.
+ * \param draw    Drawable ID for the "draw" drawable.
+ * \param read    Drawable ID for the "read" drawable.
+ * \param reply   Space to store the X-server's reply.
+ *
+ * \warning
+ * This function assumes that \c dpy is locked with \c LockDisplay on entry.
+ */
+static Bool SendMakeCurrentRequest(Display *dpy, CARD8 opcode,
+				   GLXContextID gc_id, GLXContextTag gc_tag,
+				   GLXDrawable draw, GLXDrawable read,
+				   xGLXMakeCurrentReply *reply)
+{
+    Bool ret;
+
+
+    LockDisplay(dpy);
+
+    if (draw == read) {
+	xGLXMakeCurrentReq *req;
+
+	GetReq(GLXMakeCurrent,req);
+	req->reqType = opcode;
+	req->glxCode = X_GLXMakeCurrent;
+	req->drawable = draw;
+	req->context = gc_id;
+	req->oldContextTag = gc_tag;
+    }
+    else {
+	__GLXdisplayPrivate *priv = __glXInitialize(dpy);
+
+	/* If the server can support the GLX 1.3 version, we should
+	 * perfer that.  Not only that, some servers support GLX 1.3 but
+	 * not the SGI extension.
+	 */
+
+	if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
+	    xGLXMakeContextCurrentReq *req;
+
+	    GetReq(GLXMakeContextCurrent,req);
+	    req->reqType = opcode;
+	    req->glxCode = X_GLXMakeContextCurrent;
+	    req->drawable = draw;
+	    req->readdrawable = read;
+	    req->context = gc_id;
+	    req->oldContextTag = gc_tag;
+	}
+	else {
+	    xGLXVendorPrivateWithReplyReq *vpreq;
+	    xGLXMakeCurrentReadSGIReq *req;
+
+	    GetReqExtra(GLXVendorPrivateWithReply,
+			sz_xGLXMakeCurrentReadSGIReq-sz_xGLXVendorPrivateWithReplyReq,vpreq);
+	    req = (xGLXMakeCurrentReadSGIReq *)vpreq;
+	    req->reqType = opcode;
+	    req->glxCode = X_GLXVendorPrivateWithReply;
+	    req->vendorCode = X_GLXvop_MakeCurrentReadSGI;
+	    req->drawable = draw;
+	    req->readable = read;
+	    req->context = gc_id;
+	    req->oldContextTag = gc_tag;
+	}
+    }
+
+    ret = _XReply(dpy, (xReply*) reply, 0, False);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return ret;
+}
+
+
+#ifdef GLX_DIRECT_RENDERING
+static Bool BindContextWrapper( Display *dpy, GLXContext gc,
+				GLXDrawable draw, GLXDrawable read )
+{
+    return (*gc->driContext.bindContext)(dpy, gc->screen, draw, read,
+					 & gc->driContext);
+}
+
+
+static Bool UnbindContextWrapper( GLXContext gc )
+{
+    return (*gc->driContext.unbindContext)(gc->currentDpy, gc->screen, 
+					   gc->currentDrawable,
+					   gc->currentReadable,
+					   & gc->driContext );
+}
+#endif /* GLX_DIRECT_RENDERING */
+
+
+/**
+ * Make a particular context current.
+ * 
+ * \note This is in this file so that it can access dummyContext.
+ */
+USED static Bool MakeContextCurrent(Display *dpy, GLXDrawable draw,
+                                    GLXDrawable read, GLXContext gc)
+{
+    xGLXMakeCurrentReply reply;
+    const GLXContext oldGC = __glXGetCurrentContext();
+    const CARD8 opcode = __glXSetupForCommand(dpy);
+    const CARD8 oldOpcode = ((gc == oldGC) || (oldGC == &dummyContext))
+      ? opcode : __glXSetupForCommand(oldGC->currentDpy);
+    Bool bindReturnValue;
+
+
+    if (!opcode || !oldOpcode) {
+	return GL_FALSE;
+    }
+
+    /* Make sure that the new context has a nonzero ID.  In the request,
+     * a zero context ID is used only to mean that we bind to no current
+     * context.
+     */
+    if ((gc != NULL) && (gc->xid == None)) {
+	return GL_FALSE;
+    }
+
+#ifndef GLX_DIRECT_RENDERING
+    if (gc && gc->isDirect) {
+	return GL_FALSE;
+    }
+#endif
+
+    _glapi_check_multithread();
+
+#ifdef GLX_DIRECT_RENDERING
+    /* Bind the direct rendering context to the drawable */
+    if (gc && gc->isDirect) {
+	bindReturnValue = (gc->driContext.private) 
+	  ? BindContextWrapper(dpy, gc, draw, read)
+	  : False;
+    } else
+#endif
+    {
+	/* Send a glXMakeCurrent request to bind the new context. */
+	bindReturnValue = 
+	  SendMakeCurrentRequest(dpy, opcode, gc ? gc->xid : None,
+				 ((dpy != oldGC->currentDpy) || oldGC->isDirect)
+				 ? None : oldGC->currentContextTag,
+				 draw, read, &reply);
+    }
+
+
+    if (!bindReturnValue) {
+	return False;
+    }
+
+    if ((dpy != oldGC->currentDpy || (gc && gc->isDirect)) &&
+	!oldGC->isDirect && oldGC != &dummyContext) {
+	xGLXMakeCurrentReply dummy_reply;
+
+	/* We are either switching from one dpy to another and have to
+	 * send a request to the previous dpy to unbind the previous
+	 * context, or we are switching away from a indirect context to
+	 * a direct context and have to send a request to the dpy to
+	 * unbind the previous context.
+	 */
+	(void) SendMakeCurrentRequest(oldGC->currentDpy, oldOpcode, None,
+				      oldGC->currentContextTag, None, None,
+				      & dummy_reply);
+    }
+#ifdef GLX_DIRECT_RENDERING
+    else if (oldGC->isDirect && oldGC->driContext.private) {
+	(void) UnbindContextWrapper(oldGC);
+    }
+#endif
+
+
+    /* Update our notion of what is current */
+    __glXLock();
+    if (gc == oldGC) {
+	/* Even though the contexts are the same the drawable might have
+	 * changed.  Note that gc cannot be the dummy, and that oldGC
+	 * cannot be NULL, therefore if they are the same, gc is not
+	 * NULL and not the dummy.
+	 */
+	gc->currentDrawable = draw;
+	gc->currentReadable = read;
+    } else {
+	if (oldGC != &dummyContext) {
+	    /* Old current context is no longer current to anybody */
+	    oldGC->currentDpy = 0;
+	    oldGC->currentDrawable = None;
+	    oldGC->currentReadable = None;
+	    oldGC->currentContextTag = 0;
+
+	    if (oldGC->xid == None) {
+		/* We are switching away from a context that was
+		 * previously destroyed, so we need to free the memory
+		 * for the old handle.
+		 */
+#ifdef GLX_DIRECT_RENDERING
+		/* Destroy the old direct rendering context */
+		if (oldGC->isDirect) {
+		    if (oldGC->driContext.private) {
+			(*oldGC->driContext.destroyContext)
+			    (dpy, oldGC->screen, oldGC->driContext.private);
+			oldGC->driContext.private = NULL;
+		    }
+		}
+#endif
+		__glXFreeContext(oldGC);
+	    }
+	}
+	if (gc) {
+	    __glXSetCurrentContext(gc);
+
+	    gc->currentDpy = dpy;
+	    gc->currentDrawable = draw;
+	    gc->currentReadable = read;
+
+            if (!gc->isDirect) {
+               if (!IndirectAPI)
+                  IndirectAPI = __glXNewIndirectAPI();
+               _glapi_set_dispatch(IndirectAPI);
+
+#ifdef GLX_USE_APPLEGL
+               do {
+                   extern void XAppleDRIUseIndirectDispatch(void);
+                   XAppleDRIUseIndirectDispatch();
+               } while (0);
+#endif
+
+		__GLXattribute *state = 
+		  (__GLXattribute *)(gc->client_state_private);
+
+		gc->currentContextTag = reply.contextTag;
+		if (state->array_state == NULL) {
+		    (void) glGetString(GL_EXTENSIONS);
+		    (void) glGetString(GL_VERSION);
+		    __glXInitVertexArrayState(gc);
+		}
+	    }
+	    else {
+		gc->currentContextTag = -1;
+	    }
+	} else {
+	    __glXSetCurrentContext(&dummyContext);
+#ifdef GLX_DIRECT_RENDERING
+            _glapi_set_dispatch(NULL);  /* no-op functions */
+#endif
+	}
+    }
+    __glXUnlock();
+    return GL_TRUE;
+}
+
+
+PUBLIC Bool glXMakeCurrent(Display *dpy, GLXDrawable draw, GLXContext gc)
+{
+    return MakeContextCurrent( dpy, draw, draw, gc );
+}
+
+PUBLIC GLX_ALIAS(Bool, glXMakeCurrentReadSGI,
+	  (Display *dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
+	  (dpy, d, r, ctx), MakeContextCurrent)
+
+PUBLIC GLX_ALIAS(Bool, glXMakeContextCurrent,
+	  (Display *dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
+	  (dpy, d, r, ctx), MakeContextCurrent)
+
+
 #ifdef DEBUG
-_X_HIDDEN void __glXDumpDrawBuffer(__GLXcontext *ctx)
+void __glXDumpDrawBuffer(__GLXcontext *ctx)
 {
     GLubyte *p = ctx->buf;
     GLubyte *end = ctx->pc;
@@ -930,23 +1832,9 @@ _X_HIDDEN void __glXDumpDrawBuffer(__GLXcontext *ctx)
 
 #ifdef  USE_SPARC_ASM
 /*
- * This is where our dispatch table's bounds are.
- * And the static mesa_init is taken directly from
- * Mesa's 'sparc.c' initializer.
+ * Used only when we are sparc, using sparc assembler.
  *
- * We need something like this here, because this version
- * of openGL/glx never initializes a Mesa context, and so
- * the address of the dispatch table pointer never gets stuffed
- * into the dispatch jump table otherwise.
- *
- * It matters only on SPARC, and only if you are using assembler
- * code instead of C-code indirect dispatch.
- *
- * -- FEM, 04.xii.03
  */
-extern unsigned int _mesa_sparc_glapi_begin;
-extern unsigned int _mesa_sparc_glapi_end;
-extern void __glapi_sparc_icache_flush(unsigned int *);
 
 static void
 _glx_mesa_init_sparc_glapi_relocs(void)