Merge branch 'master' into r300-compilerr300-compiler

There were additional non-textual conflicts. Conflicts: src/gallium/drivers/r300/r300_tgsi_to_rc.c src/mesa/drivers/dri/r300/compiler/r3xx_vertprog.c src/mesa/drivers/dri/r300/compiler/radeon_program.c src/mesa/drivers/dri/r300/compiler/radeon_program_alu.c
author: Nicolai Hähnle <nhaehnle@gmail.com> 2009-09-21 13:26:50 +0200
committer: Nicolai Hähnle <nhaehnle@gmail.com> 2009-09-21 13:26:50 +0200
commit: 81c7561d9d3faf70ac22c6a5f3fbea18f53eed92 (patch)
tree: 5ec097e0e1fe99804104d3a56923c16edf1533aa
parent: f02f63997ce65530788a6dfcb28f11790a14d938 (diff)
parent: 3083ba38f4c884b32cd0460607b5064b6b7008d2 (diff)
359 files changed, 18025 insertions, 10624 deletions
diff --git a/Makefile b/Makefile
index 211937d731..ea00e811b7 100644
--- a/Makefile
+++ b/Makefile
@@ -182,7 +182,7 @@ ultrix-gcc:
 
 # Rules for making release tarballs
 
-VERSION=7.6-devel
+VERSION=7.7-devel
 DIRECTORY = Mesa-$(VERSION)
 LIB_NAME = MesaLib-$(VERSION)
 DEMO_NAME = MesaDemos-$(VERSION)
@@ -325,6 +325,7 @@ GALLIUM_FILES = \
 	$(DIRECTORY)/src/gallium/*/*/SConscript				\
 	$(DIRECTORY)/src/gallium/*/*/*.[ch]				\
 	$(DIRECTORY)/src/gallium/*/*/*.py				\
+	$(DIRECTORY)/src/gallium/*/*/*.csv				\
 	$(DIRECTORY)/src/gallium/*/*/*/Makefile				\
 	$(DIRECTORY)/src/gallium/*/*/*/SConscript			\
 	$(DIRECTORY)/src/gallium/*/*/*/*.[ch]				\
diff --git a/common.py b/common.py
index a687efc86f..3b6bf52c03 100644
--- a/common.py
+++ b/common.py
@@ -33,9 +33,9 @@ else:
 	default_machine = _platform.machine()
 default_machine = _machine_map.get(default_machine, 'generic')
 
-if default_platform in ('linux', 'freebsd', 'darwin'):
+if default_platform in ('linux', 'freebsd'):
 	default_dri = 'yes'
-elif default_platform in ('winddk', 'windows', 'wince'):
+elif default_platform in ('winddk', 'windows', 'wince', 'darwin'):
 	default_dri = 'no'
 else:
 	default_dri = 'no'
@@ -59,7 +59,7 @@ def AddOptions(opts):
 	opts.Add(EnumOption('machine', 'use machine-specific assembly code', default_machine,
 											 allowed_values=('generic', 'ppc', 'x86', 'x86_64')))
 	opts.Add(EnumOption('platform', 'target platform', default_platform,
-											 allowed_values=('linux', 'cell', 'windows', 'winddk', 'wince')))
+											 allowed_values=('linux', 'cell', 'windows', 'winddk', 'wince', 'darwin')))
 	opts.Add(EnumOption('toolchain', 'compiler toolchain', 'default',
 											 allowed_values=('default', 'crossmingw', 'winsdk', 'winddk')))
 	opts.Add(BoolOption('llvm', 'use LLVM', 'no'))
diff --git a/configs/default b/configs/default
index 127b98e76c..cb3ca1046f 100644
--- a/configs/default
+++ b/configs/default
@@ -9,7 +9,7 @@ CONFIG_NAME = default
 
 # Version info
 MESA_MAJOR=7
-MESA_MINOR=6
+MESA_MINOR=7
 MESA_TINY=0
 MESA_VERSION = $(MESA_MAJOR).$(MESA_MINOR).$(MESA_TINY)
 
@@ -23,6 +23,7 @@ HOST_CC = $(CC)
 CFLAGS = -O
 CXXFLAGS = -O
 LDFLAGS =
+HOST_CFLAGS = $(CFLAGS)
 GLU_CFLAGS = 
 
 # Compiler for building demos/tests/etc
diff --git a/configure.ac b/configure.ac
index c5ef676e2e..2881bb6bc2 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1148,6 +1148,11 @@ yes)
         if test "$tracker" = egl && test "x$enable_egl" != xyes; then
             AC_MSG_ERROR([cannot build egl state tracker without EGL library])
         fi
+        if test "$tracker" = xorg; then
+	    PKG_CHECK_MODULES(XEXT, [xextproto >= 7.0.99.1],
+                  HAVE_XEXTPROTO_71="yes"; DEFINES="$DEFINES -DHAVE_XEXTPROTO_71"
+                  HAVE_XEXTPROTO_71="no")
+	fi
     done
     GALLIUM_STATE_TRACKERS_DIRS="$state_trackers"
     ;;
@@ -1202,7 +1207,7 @@ if test "x$enable_gallium_radeon" = xyes; then
 fi
 
 dnl
-dnl Gallium Radeon configuration
+dnl Gallium Nouveau configuration
 dnl
 AC_ARG_ENABLE([gallium-nouveau],
     [AS_HELP_STRING([--enable-gallium-nouveau],
diff --git a/docs/relnotes-7.5.2.html b/docs/relnotes-7.5.2.html
new file mode 100644
index 0000000000..b638c0517d
--- /dev/null
+++ b/docs/relnotes-7.5.2.html
@@ -0,0 +1,56 @@
+<HTML>
+
+<TITLE>Mesa Release Notes</TITLE>
+
+<head><link rel="stylesheet" type="text/css" href="mesa.css"></head>
+
+<BODY>
+
+<body bgcolor="#eeeeee">
+
+<H1>Mesa 7.5.2 Release Notes, (date tbd)</H1>
+
+<p>
+Mesa 7.5.2 is a bug-fix release fixing issues found since the 7.5.1 release.
+</p>
+<p>
+The main new feature of Mesa 7.5.x is the
+<a href="http://wiki.freedesktop.org/wiki/Software/gallium"
+target="_parent">Gallium3D</a> infrastructure.
+</p>
+<p>
+Mesa 7.5.2 implements the OpenGL 2.1 API, but the version reported by
+glGetString(GL_VERSION) depends on the particular driver being used.
+Some drivers don't support all the features required in OpenGL 2.1.
+</p>
+<p>
+See the <a href="install.html">Compiling/Installing page</a> for prerequisites
+for DRI hardware acceleration.
+</p>
+
+
+<h2>MD5 checksums</h2>
+<pre>
+tbd
+</pre>
+
+
+<h2>New features</h2>
+<ul>
+<li>Detect B43 chipset in Intel driver
+</ul>
+
+
+<h2>Bug fixes</h2>
+<ul>
+<li>Assorted bug fixes for i965/i945 drivers
+<li>Fixed Gallium glDrawPixels(GL_STENCIL_INDEX) failure.
+<li>Fixed GLSL linker/preprocessor version directive issue seen in Wine
+    (such as bug 23946)
+<li>glUseProgram() is now compiled into display lists (bug 23746).
+<li>glUniform functions are now compiled into display lists
+</ul>
+
+
+</body>
+</html>
diff --git a/docs/relnotes-7.6.html b/docs/relnotes-7.6.html
index 8a476378e8..aaa36188d9 100644
--- a/docs/relnotes-7.6.html
+++ b/docs/relnotes-7.6.html
@@ -50,6 +50,8 @@ This was written by Zack Rusin at Tungsten Graphics.
 <li>Rewritten radeon/r200/r300 driver using a buffer manager
 <li>radeon/r200/r300 GL_EXT_framebuffer_object support when used with
     kernel memory manager
+<li>radeon/r200/r300 support for GL_ARB_occlusion_query</li>
+<li>r300 driver supports OpenGL 1.5</li>
 <li>r300 driver support for GL_EXT_vertex_array_bgra, GL_EXT_texture_sRGB
 <li>i915/945 driver support for GL_ARB_point_sprite, GL_EXT_stencil_two_side
     and GL_ATI_separate_stencil extensions
@@ -57,6 +59,10 @@ This was written by Zack Rusin at Tungsten Graphics.
     GL_ARB_fragment_program.</li>
 <li>Added configure --with-max-width=W, --with-max-height=H options to specify
     max framebuffer, viewport size.
+<li>Initial version of Gallium llvmpipe driver.  This is a new driver based
+    on LLVM which makes exensive use of run-time code generation.  This is
+    an "alpha" stage driver.  See the src/gallium/drivers/llvmpipe/README
+    file for more information.
 </ul>
 
 
diff --git a/docs/relnotes-7.7.html b/docs/relnotes-7.7.html
new file mode 100644
index 0000000000..ca6ec55b60
--- /dev/null
+++ b/docs/relnotes-7.7.html
@@ -0,0 +1,54 @@
+<HTML>
+
+<TITLE>Mesa Release Notes</TITLE>
+
+<head><link rel="stylesheet" type="text/css" href="mesa.css"></head>
+
+<BODY>
+
+<body bgcolor="#eeeeee">
+
+<H1>Mesa 7.7 Release Notes / date TBD</H1>
+
+<p>
+Mesa 7.7 is a new development release.
+People who are concerned with stability and reliability should stick
+with a previous release or wait for Mesa 7.7.1.
+</p>
+<p>
+Mesa 7.7 implements the OpenGL 2.1 API, but the version reported by
+glGetString(GL_VERSION) depends on the particular driver being used.
+Some drivers don't support all the features required in OpenGL 2.1.
+</p>
+<p>
+See the <a href="install.html">Compiling/Installing page</a> for prerequisites
+for DRI hardware acceleration.
+</p>
+
+
+<h2>MD5 checksums</h2>
+<pre>
+tbd
+</pre>
+
+
+<h2>New features</h2>
+<ul>
+<li>GL_ARB_draw_elements_base_vertex (supported in Intel i965 and software drivers)</li>
+<li>GL_ARB_depth_clamp (supported in Intel i965 DRI and software drivers)</li>
+<li>GL_NV_depth_clamp (supported in Intel i965 DRI and software drivers)</li>
+<li>GL_ARB_provoking_vertex (same as GL_EXT_provoking_vertex)</li>
+</ul>
+
+
+<h2>Bug fixes</h2>
+<ul>
+</ul>
+
+
+<h2>Changes</h2>
+<ul>
+</ul>
+
+</body>
+</html>
diff --git a/docs/relnotes.html b/docs/relnotes.html
index ddd2e1cded..7a87f58a82 100644
--- a/docs/relnotes.html
+++ b/docs/relnotes.html
@@ -13,7 +13,9 @@ The release notes summarize what's new or changed in each Mesa release.
 </p>
 
 <UL>
+<LI><A HREF="relnotes-7.7.html">7.7 release notes</A>
 <LI><A HREF="relnotes-7.6.html">7.6 release notes</A>
+<LI><A HREF="relnotes-7.5.2.html">7.5.2 release notes</A>
 <LI><A HREF="relnotes-7.5.1.html">7.5.1 release notes</A>
 <LI><A HREF="relnotes-7.5.html">7.5 release notes</A>
 <LI><A HREF="relnotes-7.4.4.html">7.4.4 release notes</A>
diff --git a/include/EGL/eglplatform.h b/include/EGL/eglplatform.h
index 83e89cd704..9e83b60003 100644
--- a/include/EGL/eglplatform.h
+++ b/include/EGL/eglplatform.h
@@ -69,7 +69,8 @@ typedef HWND	NativeWindowType;
 typedef HBITMAP NativePixmapType;
 /** END Added for Windows **/
 
-#elif defined(__gnu_linux__) || defined(__FreeBSD__) || defined(__sun)
+#elif defined(__gnu_linux__) || defined(__FreeBSD__) || defined(__sun) || defined(__APPLE__)
+
 
 /** BEGIN Added for X (Mesa) **/
 #ifndef EGLAPI
diff --git a/include/GL/gl.h b/include/GL/gl.h
index 05362b9776..5f8bc2b708 100644
--- a/include/GL/gl.h
+++ b/include/GL/gl.h
@@ -1740,6 +1740,9 @@ GLAPI void GLAPIENTRY glSeparableFilter2D( GLenum target,
 GLAPI void GLAPIENTRY glGetSeparableFilter( GLenum target, GLenum format,
 	GLenum type, GLvoid *row, GLvoid *column, GLvoid *span );
 
+typedef void (APIENTRYP PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode);
+
 
 
 /*
@@ -1945,6 +1948,18 @@ GLAPI void GLAPIENTRY glMultTransposeMatrixf( const GLfloat m[16] );
 GLAPI void GLAPIENTRY glSampleCoverage( GLclampf value, GLboolean invert );
 
 
+typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
+typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint level, GLvoid *img);
+
+
+
 /*
  * GL_ARB_multitexture (ARB extension 1 and OpenGL 1.2.1)
  */
diff --git a/progs/SConscript b/progs/SConscript
index 620dd30e69..66eaf9e541 100644
--- a/progs/SConscript
+++ b/progs/SConscript
@@ -10,4 +10,5 @@ SConscript([
     'vpglsl/SConscript',
     'fp/SConscript',
     'wgl/SConscript',
+    'perf/SConscript',
 ])
diff --git a/progs/demos/copypix.c b/progs/demos/copypix.c
index 51435acfa0..a13339ea62 100644
--- a/progs/demos/copypix.c
+++ b/progs/demos/copypix.c
@@ -26,6 +26,7 @@ static int Scissor = 0;
 static float Xzoom, Yzoom;
 static GLboolean DrawFront = GL_FALSE;
 static GLboolean Dither = GL_TRUE;
+static GLboolean Invert = GL_FALSE;
 
 
 static void Reset( void )
@@ -59,6 +60,15 @@ static void Display( void )
    if (Scissor)
       glEnable(GL_SCISSOR_TEST);
 
+   if (Invert) {
+      glPixelTransferf(GL_RED_SCALE, -1.0);
+      glPixelTransferf(GL_GREEN_SCALE, -1.0);
+      glPixelTransferf(GL_BLUE_SCALE, -1.0);
+      glPixelTransferf(GL_RED_BIAS, 1.0);
+      glPixelTransferf(GL_GREEN_BIAS, 1.0);
+      glPixelTransferf(GL_BLUE_BIAS, 1.0);
+   }
+
    /* draw copy */
    glPixelZoom(Xzoom, Yzoom);
    glWindowPos2iARB(Xpos, Ypos);
@@ -67,6 +77,15 @@ static void Display( void )
 
    glDisable(GL_SCISSOR_TEST);
 
+   if (Invert) {
+      glPixelTransferf(GL_RED_SCALE, 1.0);
+      glPixelTransferf(GL_GREEN_SCALE, 1.0);
+      glPixelTransferf(GL_BLUE_SCALE, 1.0);
+      glPixelTransferf(GL_RED_BIAS, 0.0);
+      glPixelTransferf(GL_GREEN_BIAS, 0.0);
+      glPixelTransferf(GL_BLUE_BIAS, 0.0);
+   }
+
    if (DrawFront)
       glFinish();
    else
@@ -105,6 +124,9 @@ static void Key( unsigned char key, int x, int y )
          else
             glDisable(GL_DITHER);
          break;
+      case 'i':
+         Invert = !Invert;
+         break;
       case 's':
          Scissor = !Scissor;
          break;
diff --git a/progs/demos/cubemap.c b/progs/demos/cubemap.c
index 0df5ff09c3..015d50d86b 100644
--- a/progs/demos/cubemap.c
+++ b/progs/demos/cubemap.c
@@ -58,6 +58,7 @@ static GLint ClampIndex = 0;
 static GLboolean supportFBO = GL_FALSE;
 static GLboolean supportSeamless = GL_FALSE;
 static GLboolean seamless = GL_FALSE;
+static GLuint TexObj = 0;
 
 
 static struct {
@@ -543,6 +544,10 @@ static void init( GLboolean useImageFiles )
 
    printf("GL_RENDERER: %s\n", (char *) glGetString(GL_RENDERER));
 
+
+   glGenTextures(1, &TexObj);
+   glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, TexObj);
+
    if (useImageFiles) {
       load_envmaps();
    }
diff --git a/progs/demos/lodbias.c b/progs/demos/lodbias.c
index 30b1ed13d5..8d39bd605a 100644
--- a/progs/demos/lodbias.c
+++ b/progs/demos/lodbias.c
@@ -43,6 +43,7 @@ static GLboolean Anim = GL_TRUE;
 static GLint Bias = 0, BiasStepSign = +1; /* ints avoid fp precision problem */
 static GLint BiasMin = -400, BiasMax = 400;
 static int win = 0;
+static GLuint TexObj = 0;
 
 
 static void
@@ -214,6 +215,9 @@ static void Init( void )
 
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
+   glGenTextures(1, &TexObj);
+   glBindTexture(GL_TEXTURE_2D, TexObj);
+
    if (glutExtensionSupported("GL_SGIS_generate_mipmap")) {
       /* test auto mipmap generation */
       GLint width, height, i;
diff --git a/progs/fp/add-sat.txt b/progs/fp/add-sat.txt
new file mode 100644
index 0000000000..2253efb085
--- /dev/null
+++ b/progs/fp/add-sat.txt
@@ -0,0 +1,6 @@
+!!ARBfp1.0
+TEMP R0;
+MOV R0, fragment.color;
+ADD_SAT R0, R0, R0;
+MUL result.color, {0.5}.x, R0;
+END
diff --git a/progs/fp/mov-alias.txt b/progs/fp/mov-alias.txt
new file mode 100644
index 0000000000..5f04e9c76e
--- /dev/null
+++ b/progs/fp/mov-alias.txt
@@ -0,0 +1,6 @@
+!!ARBfp1.0
+TEMP R0;
+MOV R0, fragment.color;
+MOV R0, R0.zyxw;
+MOV result.color, R0;
+END
diff --git a/progs/fp/mul-alias.txt b/progs/fp/mul-alias.txt
new file mode 100644
index 0000000000..cf7d359e78
--- /dev/null
+++ b/progs/fp/mul-alias.txt
@@ -0,0 +1,6 @@
+!!ARBfp1.0
+TEMP R0;
+MOV R0, fragment.color;
+MUL R0, R0.zyxw, fragment.color;
+MOV result.color, R0;
+END
diff --git a/progs/glsl/Makefile b/progs/glsl/Makefile
index 8103a5cbca..a8e4cf3e66 100644
--- a/progs/glsl/Makefile
+++ b/progs/glsl/Makefile
@@ -10,16 +10,15 @@ LIB_DEP = \
 	$(TOP)/$(LIB_DIR)/$(GLU_LIB_NAME) \
 	$(TOP)/$(LIB_DIR)/$(GLUT_LIB_NAME)
 
-LIBS = -L$(TOP)/$(LIB_DIR) -l$(GLUT_LIB) -l$(GLEW_LIB) -l$(GLU_LIB) -l$(GL_LIB) $(APP_LIB_DEPS)
-
-INCLUDE_DIRS = -I$(TOP)/progs/util
+LIBS = -L$(TOP)/$(LIB_DIR) -l$(GLUT_LIB) -l$(GLEW_LIB) -l$(GLU_LIB) \
+	-l$(GL_LIB) $(APP_LIB_DEPS)
 
 # using : to avoid APP_CC pointing to CC loop
-CC:=$(APP_CC)
+CC := $(APP_CC)
 CFLAGS += -I$(INCDIR)
-LDLIBS=$(LIBS)
+LDLIBS = $(LIBS)
 
-DEMO_SOURCES = \
+PROG_SOURCES = \
 	array.c \
 	bitmap.c \
 	brick.c \
@@ -59,8 +58,8 @@ UTIL_SOURCES = \
 	readtex.c
 
 UTIL_OBJS = $(UTIL_SOURCES:.c=.o)
-PROG_OBJS = $(DEMO_SOURCES:.c=.o)
-PROGS = $(DEMO_SOURCES:%.c=%)
+PROG_OBJS = $(PROG_SOURCES:.c=.o)
+PROGS = $(PROG_SOURCES:%.c=%)
 
 ##### TARGETS #####
 
diff --git a/progs/perf/Makefile b/progs/perf/Makefile
new file mode 100644
index 0000000000..219667439f
--- /dev/null
+++ b/progs/perf/Makefile
@@ -0,0 +1,49 @@
+# progs/demos/Makefile
+
+TOP = ../..
+include $(TOP)/configs/current
+
+INCDIR = $(TOP)/include
+
+LIBS = -L$(TOP)/$(LIB_DIR) -l$(GLUT_LIB) -l$(GLEW_LIB) \
+	-l$(GLU_LIB) -l$(GL_LIB) $(APP_LIB_DEPS)
+
+# using : to avoid APP_CC pointing to CC loop
+CC := $(APP_CC)
+CFLAGS += -I$(INCDIR)
+LDLIBS = $(LIBS)
+
+PROG_SOURCES = \
+	drawoverhead.c \
+	teximage.c \
+	vbo.c \
+	vertexrate.c \
+
+PROG_OBJS = $(PROG_SOURCES:.c=.o)
+
+PROGS = $(PROG_SOURCES:%.c=%)
+
+
+UTIL_SOURCES = \
+	common.c \
+	glmain.c
+
+UTIL_HEADERS = \
+	common.h \
+	glmain.h
+
+UTIL_OBJS = $(UTIL_SOURCES:.c=.o)
+
+
+
+default: $(PROGS)
+
+$(PROG_OBJS): $(UTIL_HEADERS)
+
+$(PROGS): $(UTIL_OBJS)
+
+
+
+clean:
+	-rm -f $(PROGS)
+	-rm -f *.o *~
diff --git a/progs/perf/SConscript b/progs/perf/SConscript
new file mode 100644
index 0000000000..c019dc95b0
--- /dev/null
+++ b/progs/perf/SConscript
@@ -0,0 +1,26 @@
+Import('env')
+
+if not env['GLUT']:
+    Return()
+
+env = env.Clone()
+
+env.Prepend(LIBS = ['$GLUT_LIB'])
+
+progs = [
+      'drawoverhead',
+      'teximage',
+      'vbo',
+      'vertexrate',
+]
+
+for prog in progs:
+    env.Program(
+        target = prog,
+        source = [
+            prog + '.c',
+            'common.c',
+            'glmain.c',
+            ]
+        )
+
diff --git a/progs/perf/common.c b/progs/perf/common.c
new file mode 100644
index 0000000000..695b8a99d9
--- /dev/null
+++ b/progs/perf/common.c
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * 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 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
+ * VMWARE 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.
+ */
+
+/**
+ * Common perf code.  This should be re-usable with other APIs.
+ */
+
+#include "common.h"
+#include "glmain.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+
+/* Need to add a fflush windows console with mingw, otherwise nothing
+ * shows up until program exit.  May want to add logging here.
+ */
+void
+perf_printf(const char *format, ...)
+{
+   va_list ap;
+   va_start(ap, format);
+
+   fflush(stdout);
+   vfprintf(stdout, format, ap);
+   fflush(stdout);
+
+   va_end(ap);
+}
+
+
+
+/**
+ * Run function 'f' for enough iterations to reach a steady state.
+ * Return the rate (iterations/second).
+ */
+double
+PerfMeasureRate(PerfRateFunc f)
+{
+   const double minDuration = 1.0;
+   double rate = 0.0, prevRate = 0.0;
+   unsigned subiters;
+
+   /* Compute initial number of iterations to try.
+    * If the test function is pretty slow this helps to avoid
+    * extraordarily long run times.
+    */
+   subiters = 2;
+   {
+      const double t0 = PerfGetTime();
+      double t1;
+      do {
+         f(subiters); /* call the rendering function */
+         t1 = PerfGetTime();
+         subiters *= 2;
+      } while (t1 - t0 < 0.1 * minDuration);
+   }
+   /*perf_printf("initial subIters = %u\n", subiters);*/
+
+   while (1) {
+      const double t0 = PerfGetTime();
+      unsigned iters = 0;
+      double t1;
+
+      do {
+         f(subiters); /* call the rendering function */
+         t1 = PerfGetTime();
+         iters += subiters;
+      } while (t1 - t0 < minDuration);
+
+      rate = iters / (t1 - t0);
+
+      if (0)
+         perf_printf("prevRate %f  rate  %f  ratio %f  iters %u\n",
+                prevRate, rate, rate/prevRate, iters);
+
+      /* Try and speed the search up by skipping a few steps:
+       */
+      if (rate > prevRate * 1.6)
+         subiters *= 8;
+      else if (rate > prevRate * 1.2)
+         subiters *= 4;
+      else if (rate > prevRate * 1.05)
+         subiters *= 2;
+      else
+         break;
+
+      prevRate = rate;
+   }
+
+   if (0)
+      perf_printf("%s returning iters %u  rate %f\n", __FUNCTION__, subiters, rate);
+   return rate;
+}
+
+
diff --git a/progs/perf/common.h b/progs/perf/common.h
new file mode 100644
index 0000000000..85db678c64
--- /dev/null
+++ b/progs/perf/common.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * 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 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
+ * VMWARE 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.
+ */
+
+
+#ifndef COMMON_H
+#define COMMON_H
+
+
+typedef void (*PerfRateFunc)(unsigned count);
+
+
+extern double
+PerfMeasureRate(PerfRateFunc f);
+
+
+extern void
+perf_printf(const char *format, ...);
+
+
+#endif /* COMMON_H */
+
diff --git a/progs/perf/drawoverhead.c b/progs/perf/drawoverhead.c
new file mode 100644
index 0000000000..c1e166e746
--- /dev/null
+++ b/progs/perf/drawoverhead.c
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * 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 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
+ * VMWARE 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.
+ */
+
+/**
+ * Measure drawing overhead
+ *
+ * This is the first in a series of simple performance benchmarks.
+ * The code in this file should be as simple as possible to make it
+ * easily portable to other APIs.
+ *
+ * All the window-system stuff should be contained in glmain.c (or TBDmain.c).
+ * All the re-usable, generic code should be in common.c (XXX not done yet).
+ *
+ * Brian Paul
+ * 15 Sep 2009
+ */
+
+#include "glmain.h"
+#include "common.h"
+
+
+int WinWidth = 100, WinHeight = 100;
+
+static GLuint VBO;
+
+struct vertex
+{
+   GLfloat x, y;
+};
+
+static const struct vertex vertices[4] = {
+   { -1.0, -1.0 },
+   {  1.0, -1.0 },
+   {  1.0,  1.0 },
+   { -1.0,  1.0 }
+};
+
+
+/** Called from test harness/main */
+void
+PerfInit(void)
+{
+   /* setup VBO w/ vertex data */
+   glGenBuffersARB(1, &VBO);
+   glBindBufferARB(GL_ARRAY_BUFFER_ARB, VBO);
+   glBufferDataARB(GL_ARRAY_BUFFER_ARB,
+                   sizeof(vertices), vertices, GL_STATIC_DRAW_ARB);
+   glVertexPointer(2, GL_FLOAT, sizeof(struct vertex), (void *) 0);
+   glEnableClientState(GL_VERTEX_ARRAY);
+
+   /* misc GL state */
+   glAlphaFunc(GL_ALWAYS, 0.0);
+}
+
+
+static void
+DrawNoStateChange(unsigned count)
+{
+   unsigned i;
+   for (i = 0; i < count; i++) {
+      glDrawArrays(GL_POINTS, 0, 4);
+   }
+   glFinish();
+}
+
+
+static void
+DrawNopStateChange(unsigned count)
+{
+   unsigned i;
+   for (i = 0; i < count; i++) {
+      glDisable(GL_ALPHA_TEST);
+      glDrawArrays(GL_POINTS, 0, 4);
+   }
+   glFinish();
+}
+
+
+static void
+DrawStateChange(unsigned count)
+{
+   unsigned i;
+   for (i = 0; i < count; i++) {
+      if (i & 1)
+         glEnable(GL_TEXTURE_GEN_S);
+      else
+         glDisable(GL_TEXTURE_GEN_S);
+      glDrawArrays(GL_POINTS, 0, 4);
+   }
+   glFinish();
+}
+
+
+/** Called from test harness/main */
+void
+PerfDraw(void)
+{
+   double rate0, rate1, rate2, overhead;
+
+   rate0 = PerfMeasureRate(DrawNoStateChange);
+   perf_printf("   Draw only: %.1f draws/second\n", rate0);
+   
+
+   rate1 = PerfMeasureRate(DrawNopStateChange);
+   overhead = 1000.0 * (1.0 / rate1 - 1.0 / rate0);
+   perf_printf("   Draw w/ nop state change: %.1f draws/sec (overhead: %f ms/draw)\n",
+               rate1, overhead);
+
+   rate2 = PerfMeasureRate(DrawStateChange);
+   overhead = 1000.0 * (1.0 / rate2 - 1.0 / rate0);
+   perf_printf("   Draw w/ state change: %.1f draws/sec (overhead: %f ms/draw)\n",
+               rate2, overhead);
+
+   exit(0);
+}
+
diff --git a/progs/perf/glmain.c b/progs/perf/glmain.c
new file mode 100644
index 0000000000..62d14259f8
--- /dev/null
+++ b/progs/perf/glmain.c
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * 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 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
+ * VMWARE 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.
+ */
+
+/**
+ * OpenGL/GLUT common code for perf programs.
+ * Brian Paul
+ * 15 Sep 2009
+ */
+
+
+#include "glmain.h"
+#include <GL/glut.h>
+
+
+static int Win;
+static GLfloat Xrot = 0, Yrot = 0, Zrot = 0;
+static GLboolean Anim = GL_FALSE;
+
+
+/** Return time in seconds */
+double
+PerfGetTime(void)
+{
+   return glutGet(GLUT_ELAPSED_TIME) * 0.001;
+}
+
+
+void
+PerfSwapBuffers(void)
+{
+   glutSwapBuffers();
+}
+
+
+static void
+Idle(void)
+{
+   Xrot += 3.0;
+   Yrot += 4.0;
+   Zrot += 2.0;
+   glutPostRedisplay();
+}
+
+
+static void
+Draw(void)
+{
+   PerfDraw();
+   glutSwapBuffers();
+}
+
+
+static void
+Reshape(int width, int height)
+{
+   WinWidth = width;
+   WinHeight = height;
+   glViewport(0, 0, width, height);
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 25.0);
+   glMatrixMode(GL_MODELVIEW);
+   glLoadIdentity();
+   glTranslatef(0.0, 0.0, -15.0);
+}
+
+
+static void
+Key(unsigned char key, int x, int y)
+{
+   const GLfloat step = 3.0;
+   (void) x;
+   (void) y;
+   switch (key) {
+   case 'a':
+      Anim = !Anim;
+      if (Anim)
+         glutIdleFunc(Idle);
+      else
+         glutIdleFunc(NULL);
+      break;
+   case 'z':
+      Zrot -= step;
+      break;
+   case 'Z':
+      Zrot += step;
+      break;
+   case 27:
+      glutDestroyWindow(Win);
+      exit(0);
+      break;
+   }
+   glutPostRedisplay();
+}
+
+
+static void
+SpecialKey(int key, int x, int y)
+{
+   const GLfloat step = 3.0;
+   (void) x;
+   (void) y;
+   switch (key) {
+   case GLUT_KEY_UP:
+      Xrot -= step;
+      break;
+   case GLUT_KEY_DOWN:
+      Xrot += step;
+      break;
+   case GLUT_KEY_LEFT:
+      Yrot -= step;
+      break;
+   case GLUT_KEY_RIGHT:
+      Yrot += step;
+      break;
+   }
+   glutPostRedisplay();
+}
+
+
+int
+main(int argc, char *argv[])
+{
+   glutInit(&argc, argv);
+   glutInitWindowSize(WinWidth, WinHeight);
+   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
+   Win = glutCreateWindow(argv[0]);
+   glewInit();
+   glutReshapeFunc(Reshape);
+   glutKeyboardFunc(Key);
+   glutSpecialFunc(SpecialKey);
+   glutDisplayFunc(Draw);
+   if (Anim)
+      glutIdleFunc(Idle);
+   PerfInit();
+   glutMainLoop();
+   return 0;
+}
diff --git a/progs/perf/glmain.h b/progs/perf/glmain.h
new file mode 100644
index 0000000000..fe11d7235e
--- /dev/null
+++ b/progs/perf/glmain.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * 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 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
+ * VMWARE 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.
+ */
+
+
+#ifndef GLMAIN_H
+#define GLMAIN_H
+
+
+#define GL_GLEXT_PROTOTYPES
+#include <GL/glew.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+/** Test programs can use these vars/functions */
+
+extern int WinWidth, WinHeight;
+
+extern double
+PerfGetTime(void);
+
+extern void
+PerfSwapBuffers(void);
+
+
+/** Test programs must implement these functions **/
+
+extern void
+PerfInit(void);
+
+extern void
+PerfDraw(void);
+
+
+#endif /* GLMAIN_H */
diff --git a/progs/perf/teximage.c b/progs/perf/teximage.c
new file mode 100644
index 0000000000..11d781fccc
--- /dev/null
+++ b/progs/perf/teximage.c
@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * 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 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
+ * VMWARE 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.
+ */
+
+/**
+ * Measure glTexSubImage2D rate
+ *
+ * Brian Paul
+ * 16 Sep 2009
+ */
+
+#include "glmain.h"
+#include "common.h"
+
+
+int WinWidth = 100, WinHeight = 100;
+
+static GLuint VBO;
+static GLuint TexObj = 0;
+static GLubyte *TexImage = NULL;
+static GLsizei TexSize;
+static GLenum TexSrcFormat, TexSrcType;
+
+static const GLboolean DrawPoint = GL_TRUE;
+static const GLboolean TexSubImage4 = GL_TRUE;
+
+struct vertex
+{
+   GLfloat x, y, s, t;
+};
+
+static const struct vertex vertices[1] = {
+   { 0.0, 0.0, 0.5, 0.5 },
+};
+
+#if 0
+#define VOFFSET(F) ((void *) offsetof(struct vertex, F))
+#else
+#define VOFFSET(F) ((void *) &((struct vertex *)NULL)->F)
+#endif
+
+/** Called from test harness/main */
+void
+PerfInit(void)
+{
+   /* setup VBO w/ vertex data */
+   glGenBuffersARB(1, &VBO);
+   glBindBufferARB(GL_ARRAY_BUFFER_ARB, VBO);
+   glBufferDataARB(GL_ARRAY_BUFFER_ARB,
+                   sizeof(vertices), vertices, GL_STATIC_DRAW_ARB);
+   glVertexPointer(2, GL_FLOAT, sizeof(struct vertex), VOFFSET(x));
+   glTexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), VOFFSET(s));
+   glEnableClientState(GL_VERTEX_ARRAY);
+   glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+   /* texture */
+   glGenTextures(1, &TexObj);
+   glBindTexture(GL_TEXTURE_2D, TexObj);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+   glEnable(GL_TEXTURE_2D);
+}
+
+
+static void
+UploadTexImage2D(unsigned count)
+{
+   unsigned i;
+   for (i = 0; i < count; i++) {
+      /* XXX is this equivalent to a glTexSubImage call since we're
+       * always specifying the same image size?  That case isn't optimized
+       * in Mesa but may be optimized in other drivers.  Note sure how
+       * much difference that might make.
+       */
+      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
+                   TexSize, TexSize, 0,
+                   TexSrcFormat, TexSrcType, TexImage);
+      if (DrawPoint)
+         glDrawArrays(GL_POINTS, 0, 1);
+   }
+   glFinish();
+}
+
+
+static void
+UploadTexSubImage2D(unsigned count)
+{
+   unsigned i;
+   for (i = 0; i < count; i++) {
+      if (TexSubImage4) {
+         GLsizei halfSize = (TexSize == 1) ? 1 : TexSize / 2;
+         GLsizei halfPos = TexSize - halfSize;
+         /* do glTexSubImage2D in four pieces */
+         /* lower-left */
+         glPixelStorei(GL_UNPACK_ROW_LENGTH, TexSize);
+         glTexSubImage2D(GL_TEXTURE_2D, 0,
+                         0, 0, halfSize, halfSize,
+                         TexSrcFormat, TexSrcType, TexImage);
+         /* lower-right */
+         glPixelStorei(GL_UNPACK_SKIP_PIXELS, halfPos);
+         glTexSubImage2D(GL_TEXTURE_2D, 0,
+                         halfPos, 0, halfSize, halfSize,
+                         TexSrcFormat, TexSrcType, TexImage);
+         /* upper-left */
+         glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+         glPixelStorei(GL_UNPACK_SKIP_ROWS, halfPos);
+         glTexSubImage2D(GL_TEXTURE_2D, 0,
+                         0, halfPos, halfSize, halfSize,
+                         TexSrcFormat, TexSrcType, TexImage);
+         /* upper-right */
+         glPixelStorei(GL_UNPACK_SKIP_PIXELS, halfPos);
+         glPixelStorei(GL_UNPACK_SKIP_ROWS, halfPos);
+         glTexSubImage2D(GL_TEXTURE_2D, 0,
+                         halfPos, halfPos, halfSize, halfSize,
+                         TexSrcFormat, TexSrcType, TexImage);
+         /* reset the unpacking state */
+         glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+         glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+         glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+      }
+      else {
+         /* replace whole texture image at once */
+         glTexSubImage2D(GL_TEXTURE_2D, 0,
+                         0, 0, TexSize, TexSize,
+                         TexSrcFormat, TexSrcType, TexImage);
+      }
+      if (DrawPoint)
+         glDrawArrays(GL_POINTS, 0, 1);
+   }
+   glFinish();
+}
+
+
+/* XXX any other formats to measure? */
+static const struct {
+   GLenum format, type;
+   const char *name;
+} SrcFormats[] = {
+   { GL_RGBA, GL_UNSIGNED_BYTE, "GL_RGBA/GLubyte" },
+   { GL_BGRA, GL_UNSIGNED_BYTE, "GL_BGRA/GLubyte" },
+   { 0, 0, NULL }
+};
+
+
+
+/** Called from test harness/main */
+void
+PerfDraw(void)
+{
+   GLint maxSize;
+   double rate;
+   GLint fmt, subImage;
+
+   glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
+
+   /* loop over source data formats */
+   for (fmt = 0; SrcFormats[fmt].format; fmt++) {
+      TexSrcFormat = SrcFormats[fmt].format;
+      TexSrcType = SrcFormats[fmt].type;
+
+      /* loop over glTexImage, glTexSubImage */
+      for (subImage = 0; subImage < 2; subImage++) {
+
+         /* loop over texture sizes */
+         for (TexSize = 16; TexSize <= maxSize; TexSize *= 2) {
+            GLint bytesPerImage;
+            double mbPerSec;
+
+            bytesPerImage = TexSize * TexSize * 4;
+            TexImage = malloc(bytesPerImage);
+
+            if (subImage) {
+               /* create initial, empty texture */
+               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
+                            TexSize, TexSize, 0,
+                            TexSrcFormat, TexSrcType, NULL);
+               rate = PerfMeasureRate(UploadTexSubImage2D);
+            }
+            else {
+               rate = PerfMeasureRate(UploadTexImage2D);
+            }
+
+            mbPerSec = rate * bytesPerImage / (1024.0 * 1024.0);
+
+            perf_printf("  glTex%sImage2D(%s %d x %d): "
+                        "%.1f images/sec, %.1f MB/sec\n",
+                        (subImage ? "Sub" : ""),
+                        SrcFormats[fmt].name, TexSize, TexSize, rate, mbPerSec);
+
+            free(TexImage);
+         }
+      }
+   }
+
+   exit(0);
+}
diff --git a/progs/perf/vbo.c b/progs/perf/vbo.c
new file mode 100644
index 0000000000..d2630796ae
--- /dev/null
+++ b/progs/perf/vbo.c
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * 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 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
+ * VMWARE 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.
+ */
+
+/**
+ * Measure VBO upload speed.
+ * That is, measure glBufferDataARB() and glBufferSubDataARB().
+ *
+ * Brian Paul
+ * 16 Sep 2009
+ */
+
+#include <string.h>
+#include "glmain.h"
+#include "common.h"
+
+
+int WinWidth = 100, WinHeight = 100;
+
+static GLuint VBO;
+
+static GLsizei VBOSize = 0;
+static GLubyte *VBOData = NULL;
+
+static const GLboolean DrawPoint = GL_TRUE;
+static const GLboolean BufferSubDataInHalves = GL_TRUE;
+
+static const GLfloat Vertex0[2] = { 0.0, 0.0 };
+
+
+/** Called from test harness/main */
+void
+PerfInit(void)
+{
+   /* setup VBO */
+   glGenBuffersARB(1, &VBO);
+   glBindBufferARB(GL_ARRAY_BUFFER_ARB, VBO);
+   glVertexPointer(2, GL_FLOAT, sizeof(Vertex0), (void *) 0);
+   glEnableClientState(GL_VERTEX_ARRAY);
+}
+
+
+static void
+UploadVBO(unsigned count)
+{
+   unsigned i;
+   for (i = 0; i < count; i++) {
+      glBufferDataARB(GL_ARRAY_BUFFER, VBOSize, VBOData, GL_STREAM_DRAW_ARB);
+
+      if (DrawPoint)
+         glDrawArrays(GL_POINTS, 0, 1);
+   }
+   glFinish();
+}
+
+
+static void
+UploadSubVBO(unsigned count)
+{
+   unsigned i;
+   for (i = 0; i < count; i++) {
+      if (BufferSubDataInHalves) {
+         GLsizei half = VBOSize / 2;
+         glBufferSubDataARB(GL_ARRAY_BUFFER, 0, half, VBOData);
+         glBufferSubDataARB(GL_ARRAY_BUFFER, half, half, VBOData + half);
+      }
+      else {
+         glBufferSubDataARB(GL_ARRAY_BUFFER, 0, VBOSize, VBOData);
+      }
+
+      if (DrawPoint)
+         glDrawArrays(GL_POINTS, 0, 1);
+   }
+   glFinish();
+}
+
+
+static const GLsizei Sizes[] = {
+   64,
+   1024,
+   16*1024,
+   256*1024,
+   1024*1024,
+   16*1024*1024,
+   0 /* end of list */
+};
+
+
+/** Called from test harness/main */
+void
+PerfDraw(void)
+{
+   double rate, mbPerSec;
+   int sub, sz;
+
+   /* loop over whole/sub buffer upload */
+   for (sub = 0; sub < 2; sub++) {
+
+      /* loop over VBO sizes */
+      for (sz = 0; Sizes[sz]; sz++) {
+         VBOSize = Sizes[sz];
+
+         VBOData = malloc(VBOSize);
+         memcpy(VBOData, Vertex0, sizeof(Vertex0));
+
+         if (sub)
+            rate = PerfMeasureRate(UploadSubVBO);
+         else
+            rate = PerfMeasureRate(UploadVBO);
+
+         mbPerSec = rate * VBOSize / (1024.0 * 1024.0);
+
+         perf_printf("  glBuffer%sDataARB(size = %d): %.1f MB/sec\n",
+                     (sub ? "Sub" : ""), VBOSize, mbPerSec);
+
+         free(VBOData);
+      }
+   }
+
+   exit(0);
+}
diff --git a/progs/perf/vertexrate.c b/progs/perf/vertexrate.c
new file mode 100644
index 0000000000..b84b22a4c4
--- /dev/null
+++ b/progs/perf/vertexrate.c
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * 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 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
+ * VMWARE 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.
+ */
+
+/**
+ * Measure simple vertex processing rate via:
+ *  - immediate mode
+ *  - vertex arrays
+ *  - VBO vertex arrays
+ *  - glDrawElements
+ *  - VBO glDrawElements
+ *  - glDrawRangeElements
+ *  - VBO glDrawRangeElements
+ *
+ * Brian Paul
+ * 16 Sep 2009
+ */
+
+#include <assert.h>
+#include <string.h>
+#include "glmain.h"
+#include "common.h"
+
+
+#define MAX_VERTS (100 * 100)
+
+/** glVertex2/3/4 size */
+#define VERT_SIZE 4
+
+int WinWidth = 500, WinHeight = 500;
+
+static GLuint VertexBO, ElementBO;
+
+static unsigned NumVerts = MAX_VERTS;
+static unsigned VertBytes = VERT_SIZE * sizeof(float);
+static float *VertexData = NULL;
+
+static unsigned NumElements = MAX_VERTS;
+static GLuint *Elements = NULL;
+
+
+/**
+ * Load VertexData buffer with a 2-D grid of points in the range [-1,1]^2.
+ */
+static void
+InitializeVertexData(void)
+{
+   unsigned i;
+   float x = -1.0, y = -1.0;
+   float dx = 2.0 / 100;
+   float dy = 2.0 / 100;
+
+   VertexData = (float *) malloc(NumVerts * VertBytes);
+
+   for (i = 0; i < NumVerts; i++) {
+      VertexData[i * VERT_SIZE + 0] = x;
+      VertexData[i * VERT_SIZE + 1] = y;
+      VertexData[i * VERT_SIZE + 2] = 0.0;
+      VertexData[i * VERT_SIZE + 3] = 1.0;
+      x += dx;
+      if (x > 1.0) {
+         x = -1.0;
+         y += dy;
+      }
+   }
+
+   Elements = (GLuint *) malloc(NumVerts * sizeof(GLuint));
+
+   for (i = 0; i < NumVerts; i++) {
+      Elements[i] = NumVerts - i - 1;
+   }
+}
+
+
+/** Called from test harness/main */
+void
+PerfInit(void)
+{
+   InitializeVertexData();
+
+   /* setup VertexBO */
+   glGenBuffersARB(1, &VertexBO);
+   glBindBufferARB(GL_ARRAY_BUFFER_ARB, VertexBO);
+   glBufferDataARB(GL_ARRAY_BUFFER_ARB,
+                   NumVerts * VertBytes, VertexData, GL_STATIC_DRAW_ARB);
+   glEnableClientState(GL_VERTEX_ARRAY);
+
+   /* setup ElementBO */
+   glGenBuffersARB(1, &ElementBO);
+   glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ElementBO);
+   glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
+                   NumElements * sizeof(GLuint), Elements, GL_STATIC_DRAW_ARB);
+}
+
+
+static void
+DrawImmediate(unsigned count)
+{
+   unsigned i;
+   glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
+   glBindBufferARB(GL_ARRAY_BUFFER, 0);
+   for (i = 0; i < count; i++) {
+      unsigned j;
+      glBegin(GL_POINTS);
+      for (j = 0; j < NumVerts; j++) {
+#if VERT_SIZE == 4
+         glVertex4fv(VertexData + j * 4);
+#elif VERT_SIZE == 3
+         glVertex3fv(VertexData + j * 3);
+#elif VERT_SIZE == 2
+         glVertex2fv(VertexData + j * 2);
+#else
+         abort();
+#endif
+      }
+      glEnd();
+   }
+   glFinish();
+   PerfSwapBuffers();
+}
+
+
+static void
+DrawArraysMem(unsigned count)
+{
+   unsigned i;
+   glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
+   glBindBufferARB(GL_ARRAY_BUFFER, 0);
+   glVertexPointer(VERT_SIZE, GL_FLOAT, VertBytes, VertexData);
+   for (i = 0; i < count; i++) {
+      glDrawArrays(GL_POINTS, 0, NumVerts);
+   }
+   glFinish();
+   PerfSwapBuffers();
+}
+
+
+static void
+DrawArraysVBO(unsigned count)
+{
+   unsigned i;
+   glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
+   glBindBufferARB(GL_ARRAY_BUFFER, VertexBO);
+   glVertexPointer(VERT_SIZE, GL_FLOAT, VertBytes, (void *) 0);
+   for (i = 0; i < count; i++) {
+      glDrawArrays(GL_POINTS, 0, NumVerts);
+   }
+   glFinish();
+   PerfSwapBuffers();
+}
+
+
+static void
+DrawElementsMem(unsigned count)
+{
+   unsigned i;
+   glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
+   glBindBufferARB(GL_ARRAY_BUFFER, 0);
+   glVertexPointer(VERT_SIZE, GL_FLOAT, VertBytes, VertexData);
+   for (i = 0; i < count; i++) {
+      glDrawElements(GL_POINTS, NumVerts, GL_UNSIGNED_INT, Elements);
+   }
+   glFinish();
+   PerfSwapBuffers();
+}
+
+
+static void
+DrawElementsBO(unsigned count)
+{
+   unsigned i;
+   glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, ElementBO);
+   glBindBufferARB(GL_ARRAY_BUFFER, VertexBO);
+   glVertexPointer(VERT_SIZE, GL_FLOAT, VertBytes, (void *) 0);
+   for (i = 0; i < count; i++) {
+      glDrawElements(GL_POINTS, NumVerts, GL_UNSIGNED_INT, (void *) 0);
+   }
+   glFinish();
+   PerfSwapBuffers();
+}
+
+
+static void
+DrawRangeElementsMem(unsigned count)
+{
+   unsigned i;
+   glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
+   glBindBufferARB(GL_ARRAY_BUFFER, 0);
+   glVertexPointer(VERT_SIZE, GL_FLOAT, VertBytes, VertexData);
+   for (i = 0; i < count; i++) {
+      glDrawRangeElements(GL_POINTS, 0, NumVerts - 1,
+                          NumVerts, GL_UNSIGNED_INT, Elements);
+   }
+   glFinish();
+   PerfSwapBuffers();
+}
+
+
+static void
+DrawRangeElementsBO(unsigned count)
+{
+   unsigned i;
+   glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, ElementBO);
+   glBindBufferARB(GL_ARRAY_BUFFER, VertexBO);
+   glVertexPointer(VERT_SIZE, GL_FLOAT, VertBytes, (void *) 0);
+   for (i = 0; i < count; i++) {
+      glDrawRangeElements(GL_POINTS, 0, NumVerts - 1,
+                          NumVerts, GL_UNSIGNED_INT, (void *) 0);
+   }
+   glFinish();
+   PerfSwapBuffers();
+}
+
+
+/** Called from test harness/main */
+void
+PerfDraw(void)
+{
+   double rate;
+
+   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+   perf_printf("Vertex rate (%d x Vertex%df)\n", NumVerts, VERT_SIZE);
+
+   rate = PerfMeasureRate(DrawImmediate);
+   rate *= NumVerts;
+   perf_printf("  Immediate mode: %.1f verts/sec\n", rate);
+
+   rate = PerfMeasureRate(DrawArraysMem);
+   rate *= NumVerts;
+   perf_printf("  glDrawArrays: %.1f verts/sec\n", rate);
+
+   rate = PerfMeasureRate(DrawArraysVBO);
+   rate *= NumVerts;
+   perf_printf("  VBO glDrawArrays: %.1f verts/sec\n", rate);
+
+   rate = PerfMeasureRate(DrawElementsMem);
+   rate *= NumVerts;
+   perf_printf("  glDrawElements: %.1f verts/sec\n", rate);
+
+   rate = PerfMeasureRate(DrawElementsBO);
+   rate *= NumVerts;
+   perf_printf("  VBO glDrawElements: %.1f verts/sec\n", rate);
+
+   rate = PerfMeasureRate(DrawRangeElementsMem);
+   rate *= NumVerts;
+   perf_printf("  glDrawRangeElements: %.1f verts/sec\n", rate);
+
+   rate = PerfMeasureRate(DrawRangeElementsBO);
+   rate *= NumVerts;
+   perf_printf("  VBO glDrawRangeElements: %.1f verts/sec\n", rate);
+
+   exit(0);
+}
diff --git a/progs/tests/zreaddraw.c b/progs/tests/zreaddraw.c
index 8839e10836..7dfed20cfb 100644
--- a/progs/tests/zreaddraw.c
+++ b/progs/tests/zreaddraw.c
@@ -12,14 +12,17 @@
 #include <GL/glut.h>
 
 static GLint WinWidth = 500, WinHeight = 500;
+static GLboolean Invert = GL_FALSE;
+static GLboolean TestPacking = GL_FALSE;
+static GLboolean TestList = GL_FALSE;
 
 
 static void Display(void)
 {
-   GLfloat depth[100 * 100];
-   GLfloat depth2[400 * 400];
-   GLfloat min, max;
-   int i;
+   GLfloat depth[100 * 100 * 2];
+   GLfloat depth2[400 * 400]; /* *2 to test pixelstore stuff */
+   GLuint list;
+   GLenum depthType = GL_FLOAT;
 
    glClearColor(0.5, 0.5, 0.5, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -35,22 +38,61 @@ static void Display(void)
    glLoadIdentity();
    glutSolidSphere(1.0, 20, 10);
 
+   if (TestPacking) {
+      glPixelStorei(GL_PACK_ROW_LENGTH, 120);
+      glPixelStorei(GL_PACK_SKIP_PIXELS, 5);
+   }
+
    /* read the depth image */
-   glReadPixels(0, 0, 100, 100, GL_DEPTH_COMPONENT, GL_FLOAT, depth);
-   min = max = depth[0];
-   for (i = 1; i < 100 * 100; i++) {
-      if (depth[i] < min)
-         min = depth[i];
-      if (depth[i] > max)
-         max = depth[i];
+   glReadPixels(0, 0, 100, 100, GL_DEPTH_COMPONENT, depthType, depth);
+   if (depthType == GL_FLOAT) {
+      GLfloat min, max;
+      int i;
+      min = max = depth[0];
+      for (i = 1; i < 100 * 100; i++) {
+         if (depth[i] < min)
+            min = depth[i];
+         if (depth[i] > max)
+            max = depth[i];
+      }
+      printf("Depth value range: [%f, %f]\n", min, max);
+   }
+
+   if (TestPacking) {
+      glPixelStorei(GL_PACK_ROW_LENGTH, 0);
+      glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, 120);
+      glPixelStorei(GL_UNPACK_SKIP_PIXELS, 5);
    }
-   printf("Depth value range: [%f, %f]\n", min, max);
 
    /* draw depth image with scaling (into z buffer) */
    glPixelZoom(4.0, 4.0);
    glColor4f(1, 0, 0, 0);
    glWindowPos2i(100, 0);
-   glDrawPixels(100, 100, GL_DEPTH_COMPONENT, GL_FLOAT, depth);
+   if (Invert) {
+      glPixelTransferf(GL_DEPTH_SCALE, -1.0);
+      glPixelTransferf(GL_DEPTH_BIAS, 1.0);
+   }
+   if (TestList) {
+      list = glGenLists(1);
+      glNewList(list, GL_COMPILE);
+      glDrawPixels(100, 100, GL_DEPTH_COMPONENT, depthType, depth);
+      glEndList();
+      glCallList(list);
+      glDeleteLists(list, 1);
+   }
+   else {
+      glDrawPixels(100, 100, GL_DEPTH_COMPONENT, depthType, depth);
+   }
+   if (Invert) {
+      glPixelTransferf(GL_DEPTH_SCALE, 1.0);
+      glPixelTransferf(GL_DEPTH_BIAS, 0.0);
+   }
+
+   if (TestPacking) {
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+      glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+   }
 
    glDisable(GL_DEPTH_TEST);
 
@@ -77,6 +119,17 @@ static void Key(unsigned char key, int x, int y)
    (void) x;
    (void) y;
    switch (key) {
+      case 'i':
+         Invert = !Invert;
+         break;
+      case 'p':
+         TestPacking = !TestPacking;
+         printf("Test pixel pack/unpack: %d\n", TestPacking);
+         break;
+      case 'l':
+         TestList = !TestList;
+         printf("Test dlist: %d\n", TestList);
+         break;
       case 27:
          exit(0);
          break;
diff --git a/progs/vp/vp-tris.c b/progs/vp/vp-tris.c
index 97995accdd..1356242d97 100644
--- a/progs/vp/vp-tris.c
+++ b/progs/vp/vp-tris.c
@@ -119,6 +119,12 @@ static void Init( void )
       glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum);
       glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
 		        sz, (const GLubyte *) buf);
+      if (glGetError()) {
+         printf("Program failed to compile:\n%s\n", buf);
+         printf("Error: %s\n",
+                (char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));
+         exit(1);
+      }
       assert(glIsProgramARB(prognum));
    }
 
diff --git a/scons/dxsdk.py b/scons/dxsdk.py
index de090e4f99..920cc2f689 100644
--- a/scons/dxsdk.py
+++ b/scons/dxsdk.py
@@ -52,11 +52,20 @@ def generate(env):
         target_cpu = 'x64'
     else:
         raise SCons.Errors.InternalError, "Unsupported target machine"
-    include_dir = 'Include'
+
+    include_dir = os.path.join(dxsdk_root, 'Include')
+    lib_dir = os.path.join(dxsdk_root, 'Lib', target_cpu)
 
     env.Append(CPPDEFINES = [('HAVE_DXSDK', '1')])
-    env.Prepend(CPPPATH = [os.path.join(dxsdk_root, 'Include')])
-    env.Prepend(LIBPATH = [os.path.join(dxsdk_root, 'Lib', target_cpu)])
+
+    gcc = 'gcc' in os.path.basename(env['CC']).split('-')
+    if gcc:
+        # Make GCC more forgiving towards Microsoft's headers
+        env.Prepend(CPPFLAGS = ['-isystem', include_dir])
+    else:
+        env.Prepend(CPPPATH = [include_dir])
+
+    env.Prepend(LIBPATH = [lib_dir])
 
 def exists(env):
     return get_dxsdk_root(env) is not None
diff --git a/scons/gallium.py b/scons/gallium.py
index bf6172b4d7..38782ac726 100644
--- a/scons/gallium.py
+++ b/scons/gallium.py
@@ -334,12 +334,17 @@ def generate(env):
         else:
             ccflags += ['-O3', '-g3']
         if env['profile']:
-            ccflags += ['-pg']
+            # See http://code.google.com/p/jrfonseca/wiki/Gprof2Dot#Which_options_should_I_pass_to_gcc_when_compiling_for_profiling?
+            ccflags += [
+                '-fno-omit-frame-pointer',
+                '-fno-optimize-sibling-calls',
+            ]
         if env['machine'] == 'x86':
             ccflags += [
                 '-m32',
                 #'-march=pentium4',
                 '-mmmx', '-msse', '-msse2', # enable SIMD intrinsics
+                '-mstackrealign', # ensure stack is aligned -- do not enabled -msse without it!
                 #'-mfpmath=sse',
             ]
         if env['machine'] == 'x86_64':
diff --git a/scons/llvm.py b/scons/llvm.py
index 702f1e354f..d3293bb404 100644
--- a/scons/llvm.py
+++ b/scons/llvm.py
@@ -51,20 +51,26 @@ def generate(env):
 
         llvm_bin_dir = os.path.join(llvm_dir, llvm_subdir, 'bin')
         if not os.path.isdir(llvm_bin_dir):
-            raise SCons.Errors.InternalError, "LLVM build directory not found"
+            llvm_bin_dir = os.path.join(llvm_dir, 'bin')
+            if not os.path.isdir(llvm_bin_dir):
+                raise SCons.Errors.InternalError, "LLVM binary directory not found"
 
         env.PrependENVPath('PATH', llvm_bin_dir)
 
     if env.Detect('llvm-config'):
-        try:
-            env['LLVM_VERSION'] = env.backtick('llvm-config --version')
-        except AttributeError:
-            env['LLVM_VERSION'] = 'X.X'
+        version = env.backtick('llvm-config --version').rstrip()
 
-        env.ParseConfig('llvm-config --cppflags')
-        env.ParseConfig('llvm-config --libs jit interpreter nativecodegen bitwriter')
-        env.ParseConfig('llvm-config --ldflags')
-        env['LINK'] = env['CXX']
+        try:
+            env.ParseConfig('llvm-config --cppflags')
+            env.ParseConfig('llvm-config --libs jit interpreter nativecodegen bitwriter')
+            env.ParseConfig('llvm-config --ldflags')
+        except OSError:
+            print 'llvm-config version %s failed' % version
+        else:
+            if env['platform'] == 'windows':
+                env.Append(LIBS = ['imagehlp', 'psapi'])
+            env['LINK'] = env['CXX']
+            env['LLVM_VERSION'] = version
 
 def exists(env):
     return True
diff --git a/scons/winddk.py b/scons/winddk.py
index afcea9909a..4dac16ee66 100644
--- a/scons/winddk.py
+++ b/scons/winddk.py
@@ -85,8 +85,6 @@ def get_winddk_paths(env, version, root):
         else:
             # TODO: take in consideration the host cpu
             bin_dir = os.path.join(root, 'bin', 'win64', 'x86', cpu_bin(target_cpu))
-
-    env.PrependENVPath('PATH', [bin_dir])
     
     crt_inc_dir = os.path.join(root, 'inc', 'crt')
     if version_major >= 6000:
@@ -98,17 +96,33 @@ def get_winddk_paths(env, version, root):
         sdk_inc_dir = os.path.join(root, 'inc', target_os)
         wdm_inc_dir = os.path.join(root, 'inc', 'ddk', 'wdm', target_os)
 
-    env.PrependENVPath('INCLUDE', [
-        wdm_inc_dir,
-        ddk_inc_dir,
-        crt_inc_dir,
-        sdk_inc_dir,
-    ])
+    if env['toolchain'] == 'winddk':
+        env.PrependENVPath('PATH', [bin_dir])
+        env.PrependENVPath('INCLUDE', [
+            wdm_inc_dir,
+            ddk_inc_dir,
+            crt_inc_dir,
+            sdk_inc_dir,
+        ])
+        env.PrependENVPath('LIB', [
+            os.path.join(root, 'lib', 'crt', target_cpu),
+            os.path.join(root, 'lib', target_os, target_cpu),
+        ])
+    elif env['toolchain'] == 'crossmingw':
+        env.Prepend(CPPFLAGS = [
+            '-isystem', ddk_inc_dir,
+            '-isystem', sdk_inc_dir,
+        ])
+    else:
+        env.Prepend(CPPPATH = [
+            wdm_inc_dir,
+            ddk_inc_dir,
+            sdk_inc_dir,
+        ])
+        env.Prepend(LIBPATH = [
+            os.path.join(root, 'lib', target_os, target_cpu),
+        ])
 
-    env.PrependENVPath('LIB', [
-        os.path.join(root, 'lib', 'crt', target_cpu),
-        os.path.join(root, 'lib', target_os, target_cpu),
-    ])
 
 def generate(env):
     if not env.has_key('ENV'):
@@ -120,9 +134,10 @@ def generate(env):
             get_winddk_paths(env, version, root)
             break
 
-    msvc_sa.generate(env)
-    mslib_sa.generate(env)
-    mslink_sa.generate(env)
+    if env['toolchain'] == 'winddk':
+        msvc_sa.generate(env)
+        mslib_sa.generate(env)
+        mslink_sa.generate(env)
 
 def exists(env):
     for version in versions:
diff --git a/src/gallium/auxiliary/tgsi/tgsi_exec.c b/src/gallium/auxiliary/tgsi/tgsi_exec.c
index 60ffa188df..c79c56debd 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_exec.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_exec.c
@@ -2756,19 +2756,32 @@ exec_instruction(
       if (mach->ExecMask) {
          /* do the call */
 
-         /* push the Cond, Loop, Cont stacks */
+         /* First, record the depths of the execution stacks.
+          * This is important for deeply nested/looped return statements.
+          * We have to unwind the stacks by the correct amount.  For a
+          * real code generator, we could determine the number of entries
+          * to pop off each stack with simple static analysis and avoid
+          * implementing this data structure at run time.
+          */
+         mach->CallStack[mach->CallStackTop].CondStackTop = mach->CondStackTop;
+         mach->CallStack[mach->CallStackTop].LoopStackTop = mach->LoopStackTop;
+         mach->CallStack[mach->CallStackTop].ContStackTop = mach->ContStackTop;
+         /* note that PC was already incremented above */
+         mach->CallStack[mach->CallStackTop].ReturnAddr = *pc;
+
+         mach->CallStackTop++;
+
+         /* Second, push the Cond, Loop, Cont, Func stacks */
          assert(mach->CondStackTop < TGSI_EXEC_MAX_COND_NESTING);
          mach->CondStack[mach->CondStackTop++] = mach->CondMask;
          assert(mach->LoopStackTop < TGSI_EXEC_MAX_LOOP_NESTING);
          mach->LoopStack[mach->LoopStackTop++] = mach->LoopMask;
          assert(mach->ContStackTop < TGSI_EXEC_MAX_LOOP_NESTING);
          mach->ContStack[mach->ContStackTop++] = mach->ContMask;
-
          assert(mach->FuncStackTop < TGSI_EXEC_MAX_CALL_NESTING);
          mach->FuncStack[mach->FuncStackTop++] = mach->FuncMask;
 
-         /* note that PC was already incremented above */
-         mach->CallStack[mach->CallStackTop++] = *pc;
+         /* Finally, jump to the subroutine */
          *pc = inst->InstructionExtLabel.Label;
       }
       break;
@@ -2785,18 +2798,24 @@ exec_instruction(
             *pc = -1;
             return;
          }
-         *pc = mach->CallStack[--mach->CallStackTop];
 
-         /* pop the Cond, Loop, Cont stacks */
-         assert(mach->CondStackTop > 0);
-         mach->CondMask = mach->CondStack[--mach->CondStackTop];
-         assert(mach->LoopStackTop > 0);
-         mach->LoopMask = mach->LoopStack[--mach->LoopStackTop];
-         assert(mach->ContStackTop > 0);
-         mach->ContMask = mach->ContStack[--mach->ContStackTop];
+         assert(mach->CallStackTop > 0);
+         mach->CallStackTop--;
+
+         mach->CondStackTop = mach->CallStack[mach->CallStackTop].CondStackTop;
+         mach->CondMask = mach->CondStack[mach->CondStackTop];
+
+         mach->LoopStackTop = mach->CallStack[mach->CallStackTop].LoopStackTop;
+         mach->LoopMask = mach->LoopStack[mach->LoopStackTop];
+
+         mach->ContStackTop = mach->CallStack[mach->CallStackTop].ContStackTop;
+         mach->ContMask = mach->ContStack[mach->ContStackTop];
+
          assert(mach->FuncStackTop > 0);
          mach->FuncMask = mach->FuncStack[--mach->FuncStackTop];
 
+         *pc = mach->CallStack[mach->CallStackTop].ReturnAddr;
+
          UPDATE_EXEC_MASK(mach);
       }
       break;
@@ -3245,7 +3264,6 @@ tgsi_exec_machine_run( struct tgsi_exec_machine *mach )
    mach->FuncMask = 0xf;
    mach->ExecMask = 0xf;
 
-   mach->CondStackTop = 0; /* temporarily subvert this assertion */
    assert(mach->CondStackTop == 0);
    assert(mach->LoopStackTop == 0);
    assert(mach->ContStackTop == 0);
diff --git a/src/gallium/auxiliary/tgsi/tgsi_exec.h b/src/gallium/auxiliary/tgsi/tgsi_exec.h
index 3baa94dbdd..c72f76809d 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_exec.h
+++ b/src/gallium/auxiliary/tgsi/tgsi_exec.h
@@ -186,6 +186,17 @@ struct tgsi_exec_labels
  */
 #define TGSI_EXEC_MAX_CONST_BUFFER  4096
 
+
+/** function call/activation record */
+struct tgsi_call_record
+{
+   uint CondStackTop;
+   uint LoopStackTop;
+   uint ContStackTop;
+   uint ReturnAddr;
+};
+
+
 /**
  * Run-time virtual machine state for executing TGSI shader.
  */
@@ -249,7 +260,7 @@ struct tgsi_exec_machine
    int FuncStackTop;
 
    /** Function call stack for saving/restoring the program counter */
-   uint CallStack[TGSI_EXEC_MAX_CALL_NESTING];
+   struct tgsi_call_record CallStack[TGSI_EXEC_MAX_CALL_NESTING];
    int CallStackTop;
 
    struct tgsi_full_instruction *Instructions;
diff --git a/src/gallium/auxiliary/tgsi/tgsi_sanity.c b/src/gallium/auxiliary/tgsi/tgsi_sanity.c
index 8a13885da9..53e13b30e6 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_sanity.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_sanity.c
@@ -358,7 +358,7 @@ epilog(
 
 boolean
 tgsi_sanity_check(
-   struct tgsi_token *tokens )
+   const struct tgsi_token *tokens )
 {
    struct sanity_check_ctx ctx;
 
diff --git a/src/gallium/auxiliary/tgsi/tgsi_sanity.h b/src/gallium/auxiliary/tgsi/tgsi_sanity.h
index ca45e94c7a..52263ff883 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_sanity.h
+++ b/src/gallium/auxiliary/tgsi/tgsi_sanity.h
@@ -40,7 +40,7 @@ extern "C" {
  */
 boolean
 tgsi_sanity_check(
-   struct tgsi_token *tokens );
+   const struct tgsi_token *tokens );
 
 #if defined __cplusplus
 }
diff --git a/src/gallium/auxiliary/tgsi/tgsi_scan.c b/src/gallium/auxiliary/tgsi/tgsi_scan.c
index c535788819..0db4481a3d 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_scan.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_scan.c
@@ -132,6 +132,7 @@ tgsi_scan_shader(const struct tgsi_token *tokens,
                if (file == TGSI_FILE_INPUT) {
                   info->input_semantic_name[reg] = (ubyte)fulldecl->Semantic.SemanticName;
                   info->input_semantic_index[reg] = (ubyte)fulldecl->Semantic.SemanticIndex;
+                  info->input_interpolate[reg] = (ubyte)fulldecl->Declaration.Interpolate;
                   info->num_inputs++;
                }
                else if (file == TGSI_FILE_OUTPUT) {
diff --git a/src/gallium/auxiliary/tgsi/tgsi_scan.h b/src/gallium/auxiliary/tgsi/tgsi_scan.h
index 2c1a75bc81..8a7ee0c7e4 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_scan.h
+++ b/src/gallium/auxiliary/tgsi/tgsi_scan.h
@@ -45,6 +45,7 @@ struct tgsi_shader_info
    ubyte num_outputs;
    ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS]; /**< TGSI_SEMANTIC_x */
    ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
+   ubyte input_interpolate[PIPE_MAX_SHADER_INPUTS];
    ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS]; /**< TGSI_SEMANTIC_x */
    ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
 
diff --git a/src/gallium/auxiliary/tgsi/tgsi_sse2.c b/src/gallium/auxiliary/tgsi/tgsi_sse2.c
index 3cdf8b9f35..501fc05e72 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_sse2.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_sse2.c
@@ -39,8 +39,9 @@
 #include "tgsi/tgsi_info.h"
 #include "tgsi/tgsi_parse.h"
 #include "tgsi/tgsi_util.h"
-#include "tgsi_exec.h"
-#include "tgsi_sse2.h"
+#include "tgsi/tgsi_dump.h"
+#include "tgsi/tgsi_exec.h"
+#include "tgsi/tgsi_sse2.h"
 
 #include "rtasm/rtasm_x86sse.h"
 
@@ -1360,6 +1361,32 @@ emit_store(
    const struct tgsi_full_instruction *inst,
    unsigned chan_index )
 {
+   switch( inst->Instruction.Saturate ) {
+   case TGSI_SAT_NONE:
+      break;
+
+   case TGSI_SAT_ZERO_ONE:
+      sse_maxps(
+         func,
+         make_xmm( xmm ),
+         get_temp(
+            TGSI_EXEC_TEMP_00000000_I,
+            TGSI_EXEC_TEMP_00000000_C ) );
+
+      sse_minps(
+         func,
+         make_xmm( xmm ),
+         get_temp(
+            TGSI_EXEC_TEMP_ONE_I,
+            TGSI_EXEC_TEMP_ONE_C ) );
+      break;
+
+   case TGSI_SAT_MINUS_PLUS_ONE:
+      assert( 0 );
+      break;
+   }
+
+
    switch( reg->DstRegister.File ) {
    case TGSI_FILE_OUTPUT:
       emit_output(
@@ -1388,19 +1415,6 @@ emit_store(
    default:
       assert( 0 );
    }
-
-   switch( inst->Instruction.Saturate ) {
-   case TGSI_SAT_NONE:
-      break;
-
-   case TGSI_SAT_ZERO_ONE:
-      /* assert( 0 ); */
-      break;
-
-   case TGSI_SAT_MINUS_PLUS_ONE:
-      assert( 0 );
-      break;
-   }
 }
 
 #define STORE( FUNC, INST, XMM, INDEX, CHAN )\
@@ -1747,14 +1761,6 @@ emit_instruction(
    if (indirect_temp_reference(inst))
       return FALSE;
 
-   /* we don't handle saturation/clamping yet */
-   if (inst->Instruction.Saturate != TGSI_SAT_NONE)
-      return FALSE;
-
-   /* need to use extra temps to fix SOA dependencies : */
-   if (tgsi_check_soa_dependencies(inst))
-      return FALSE;
-
    switch (inst->Instruction.Opcode) {
    case TGSI_OPCODE_ARL:
       FOR_EACH_DST0_ENABLED_CHANNEL( *inst, chan_index ) {
@@ -1768,8 +1774,10 @@ emit_instruction(
    case TGSI_OPCODE_MOV:
    case TGSI_OPCODE_SWZ:
       FOR_EACH_DST0_ENABLED_CHANNEL( *inst, chan_index ) {
-         FETCH( func, *inst, 0, 0, chan_index );
-         STORE( func, *inst, 0, 0, chan_index );
+         FETCH( func, *inst, 4 + chan_index, 0, chan_index );
+      }
+      FOR_EACH_DST0_ENABLED_CHANNEL( *inst, chan_index ) {
+         STORE( func, *inst, 4 + chan_index, 0, chan_index );
       }
       break;
 
@@ -2929,6 +2937,22 @@ tgsi_emit_sse2(
                          parse.FullHeader.Processor.Processor == TGSI_PROCESSOR_VERTEX ?
                          "vertex shader" : "fragment shader");
 	 }
+
+         if (tgsi_check_soa_dependencies(&parse.FullToken.FullInstruction)) {
+            uint opcode = parse.FullToken.FullInstruction.Instruction.Opcode;
+
+            /* XXX: we only handle src/dst aliasing in a few opcodes
+             * currently.  Need to use an additional temporay to hold
+             * the result in the cases where the code is too opaque to
+             * fix.
+             */
+            if (opcode != TGSI_OPCODE_MOV &&
+                opcode != TGSI_OPCODE_SWZ) {
+               debug_printf("Warning: src/dst aliasing in instruction"
+                            " is not handled:\n");
+               tgsi_dump_instruction(&parse.FullToken.FullInstruction, 1);
+            }
+         }
          break;
 
       case TGSI_TOKEN_TYPE_IMMEDIATE:
diff --git a/src/gallium/auxiliary/tgsi/tgsi_ureg.c b/src/gallium/auxiliary/tgsi/tgsi_ureg.c
index f7096bd8e2..654426a903 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_ureg.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_ureg.c
@@ -31,6 +31,7 @@
 #include "tgsi/tgsi_ureg.h"
 #include "tgsi/tgsi_info.h"
 #include "tgsi/tgsi_dump.h"
+#include "tgsi/tgsi_sanity.h"
 #include "util/u_memory.h"
 #include "util/u_math.h"
 
@@ -70,6 +71,7 @@ struct ureg_tokens {
 
 #define UREG_MAX_INPUT PIPE_MAX_ATTRIBS
 #define UREG_MAX_OUTPUT PIPE_MAX_ATTRIBS
+#define UREG_MAX_CONSTANT_RANGE 32
 #define UREG_MAX_IMMEDIATE 32
 #define UREG_MAX_TEMP 256
 #define UREG_MAX_ADDR 2
@@ -86,8 +88,10 @@ struct ureg_program
       unsigned semantic_name;
       unsigned semantic_index;
       unsigned interp;
-   } input[UREG_MAX_INPUT];
-   unsigned nr_inputs;
+   } fs_input[UREG_MAX_INPUT];
+   unsigned nr_fs_inputs;
+
+   unsigned vs_inputs[UREG_MAX_INPUT/32];
 
    struct {
       unsigned semantic_name;
@@ -107,9 +111,13 @@ struct ureg_program
    unsigned temps_active[UREG_MAX_TEMP / 32];
    unsigned nr_temps;
 
-   unsigned nr_addrs;
+   struct {
+      unsigned first;
+      unsigned last;
+   } constant_range[UREG_MAX_CONSTANT_RANGE];
+   unsigned nr_constant_ranges;
 
-   unsigned nr_constants;
+   unsigned nr_addrs;
    unsigned nr_instructions;
 
    struct ureg_tokens domain[2];
@@ -119,6 +127,9 @@ static union tgsi_any_token error_tokens[32];
 
 static void tokens_error( struct ureg_tokens *tokens )
 {
+   if (tokens->tokens && tokens->tokens != error_tokens)
+      FREE(tokens->tokens);
+
    tokens->tokens = error_tokens;
    tokens->size = Elements(error_tokens);
    tokens->count = 0;
@@ -228,25 +239,25 @@ ureg_src_register( unsigned file,
 
 
 
-static struct ureg_src 
-ureg_DECL_input( struct ureg_program *ureg,
-                 unsigned name,
-                 unsigned index,
-                 unsigned interp_mode )
+struct ureg_src 
+ureg_DECL_fs_input( struct ureg_program *ureg,
+                    unsigned name,
+                    unsigned index,
+                    unsigned interp_mode )
 {
    unsigned i;
 
-   for (i = 0; i < ureg->nr_inputs; i++) {
-      if (ureg->input[i].semantic_name == name &&
-          ureg->input[i].semantic_index == index) 
+   for (i = 0; i < ureg->nr_fs_inputs; i++) {
+      if (ureg->fs_input[i].semantic_name == name &&
+          ureg->fs_input[i].semantic_index == index) 
          goto out;
    }
 
-   if (ureg->nr_inputs < UREG_MAX_INPUT) {
-      ureg->input[i].semantic_name = name;
-      ureg->input[i].semantic_index = index;
-      ureg->input[i].interp = interp_mode;
-      ureg->nr_inputs++;
+   if (ureg->nr_fs_inputs < UREG_MAX_INPUT) {
+      ureg->fs_input[i].semantic_name = name;
+      ureg->fs_input[i].semantic_index = index;
+      ureg->fs_input[i].interp = interp_mode;
+      ureg->nr_fs_inputs++;
    }
    else {
       set_bad( ureg );
@@ -257,25 +268,14 @@ out:
 }
 
 
-
-struct ureg_src 
-ureg_DECL_fs_input( struct ureg_program *ureg,
-                    unsigned name,
-                    unsigned index,
-                    unsigned interp )
-{
-   assert(ureg->processor == TGSI_PROCESSOR_FRAGMENT);
-   return ureg_DECL_input( ureg, name, index, interp );
-}
-
-
 struct ureg_src 
 ureg_DECL_vs_input( struct ureg_program *ureg,
-                    unsigned name,
                     unsigned index )
 {
    assert(ureg->processor == TGSI_PROCESSOR_VERTEX);
-   return ureg_DECL_input( ureg, name, index, TGSI_INTERPOLATE_CONSTANT );
+   
+   ureg->vs_inputs[index/32] |= 1 << (index % 32);
+   return ureg_src_register( TGSI_FILE_INPUT, index );
 }
 
 
@@ -313,9 +313,57 @@ out:
  * value or manage any constant_buffer contents -- that's the
  * resposibility of the calling code.
  */
-struct ureg_src ureg_DECL_constant(struct ureg_program *ureg )
+struct ureg_src ureg_DECL_constant(struct ureg_program *ureg, 
+                                   unsigned index )
 {
-   return ureg_src_register( TGSI_FILE_CONSTANT, ureg->nr_constants++ );
+   unsigned minconst = index, maxconst = index;
+   unsigned i;
+
+   /* Inside existing range?
+    */
+   for (i = 0; i < ureg->nr_constant_ranges; i++) {
+      if (ureg->constant_range[i].first <= index &&
+          ureg->constant_range[i].last >= index)
+         goto out;
+   }
+
+   /* Extend existing range?
+    */
+   for (i = 0; i < ureg->nr_constant_ranges; i++) {
+      if (ureg->constant_range[i].last == index - 1) {
+         ureg->constant_range[i].last = index;
+         goto out;
+      }
+
+      if (ureg->constant_range[i].first == index + 1) {
+         ureg->constant_range[i].first = index;
+         goto out;
+      }
+
+      minconst = MIN2(minconst, ureg->constant_range[i].first);
+      maxconst = MAX2(maxconst, ureg->constant_range[i].last);
+   }
+
+   /* Create new range?
+    */
+   if (ureg->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) {
+      i = ureg->nr_constant_ranges++;
+      ureg->constant_range[i].first = index;
+      ureg->constant_range[i].last = index;
+   }
+
+   /* Collapse all ranges down to one:
+    */
+   i = 0;
+   ureg->constant_range[0].first = minconst;
+   ureg->constant_range[0].last = maxconst;
+   ureg->nr_constant_ranges = 1;
+
+out:
+   assert(i < ureg->nr_constant_ranges);
+   assert(ureg->constant_range[i].first <= index);
+   assert(ureg->constant_range[i].last >= index);
+   return ureg_src_register( TGSI_FILE_CONSTANT, index );
 }
 
 
@@ -566,6 +614,19 @@ ureg_emit_dst( struct ureg_program *ureg,
 }
 
 
+static void validate( unsigned opcode,
+                      unsigned nr_dst,
+                      unsigned nr_src )
+{
+#ifdef DEBUG
+   const struct tgsi_opcode_info *info = tgsi_get_opcode_info( opcode );
+   assert(info);
+   if(info) {
+      assert(nr_dst == info->num_dst);
+      assert(nr_src == info->num_src);
+   }
+#endif
+}
 
 unsigned
 ureg_emit_insn(struct ureg_program *ureg,
@@ -576,6 +637,8 @@ ureg_emit_insn(struct ureg_program *ureg,
 {
    union tgsi_any_token *out;
 
+   validate( opcode, num_dst, num_src );
+   
    out = get_tokens( ureg, DOMAIN_INSN, 1 );
    out[0].value = 0;
    out[0].insn.Type = TGSI_TOKEN_TYPE_INSTRUCTION;
@@ -678,17 +741,6 @@ ureg_insn(struct ureg_program *ureg,
    unsigned insn, i;
    boolean saturate;
 
-#ifdef DEBUG
-   {
-      const struct tgsi_opcode_info *info = tgsi_get_opcode_info( opcode );
-      assert(info);
-      if(info) {
-         assert(nr_dst == info->num_dst);
-         assert(nr_src == info->num_src);
-      }
-   }
-#endif
-   
    saturate = nr_dst ? dst[0].Saturate : FALSE;
 
    insn = ureg_emit_insn( ureg, opcode, saturate, nr_dst, nr_src );
@@ -702,6 +754,53 @@ ureg_insn(struct ureg_program *ureg,
    ureg_fixup_insn_size( ureg, insn );
 }
 
+void
+ureg_tex_insn(struct ureg_program *ureg,
+              unsigned opcode,
+              const struct ureg_dst *dst,
+              unsigned nr_dst,
+              unsigned target,
+              const struct ureg_src *src,
+              unsigned nr_src )
+{
+   unsigned insn, i;
+   boolean saturate;
+
+   saturate = nr_dst ? dst[0].Saturate : FALSE;
+
+   insn = ureg_emit_insn( ureg, opcode, saturate, nr_dst, nr_src );
+
+   ureg_emit_texture( ureg, insn, target );                             \
+
+   for (i = 0; i < nr_dst; i++)
+      ureg_emit_dst( ureg, dst[i] );
+
+   for (i = 0; i < nr_src; i++)
+      ureg_emit_src( ureg, src[i] );
+
+   ureg_fixup_insn_size( ureg, insn );
+}
+
+
+void
+ureg_label_insn(struct ureg_program *ureg,
+                unsigned opcode,
+                const struct ureg_src *src,
+                unsigned nr_src,
+                unsigned *label_token )
+{
+   unsigned insn, i;
+
+   insn = ureg_emit_insn( ureg, opcode, FALSE, 0, nr_src );
+
+   ureg_emit_label( ureg, insn, label_token );                  \
+
+   for (i = 0; i < nr_src; i++)
+      ureg_emit_src( ureg, src[i] );
+
+   ureg_fixup_insn_size( ureg, insn );
+}
+
 
 
 static void emit_decl( struct ureg_program *ureg,
@@ -777,13 +876,22 @@ static void emit_decls( struct ureg_program *ureg )
 {
    unsigned i;
 
-   for (i = 0; i < ureg->nr_inputs; i++) {
-      emit_decl( ureg, 
-                 TGSI_FILE_INPUT, 
-                 i,
-                 ureg->input[i].semantic_name,
-                 ureg->input[i].semantic_index,
-                 ureg->input[i].interp );
+   if (ureg->processor == TGSI_PROCESSOR_VERTEX) {
+      for (i = 0; i < UREG_MAX_INPUT; i++) {
+         if (ureg->vs_inputs[i/32] & (1 << (i%32))) {
+            emit_decl_range( ureg, TGSI_FILE_INPUT, i, 1 );
+         }
+      }
+   }
+   else {
+      for (i = 0; i < ureg->nr_fs_inputs; i++) {
+         emit_decl( ureg, 
+                    TGSI_FILE_INPUT, 
+                    i,
+                    ureg->fs_input[i].semantic_name,
+                    ureg->fs_input[i].semantic_index,
+                    ureg->fs_input[i].interp );
+      }
    }
 
    for (i = 0; i < ureg->nr_outputs; i++) {
@@ -801,10 +909,13 @@ static void emit_decls( struct ureg_program *ureg )
                        ureg->sampler[i].Index, 1 );
    }
 
-   if (ureg->nr_constants) {
-      emit_decl_range( ureg,
-                       TGSI_FILE_CONSTANT,
-                       0, ureg->nr_constants );
+   if (ureg->nr_constant_ranges) {
+      for (i = 0; i < ureg->nr_constant_ranges; i++)
+         emit_decl_range( ureg,
+                          TGSI_FILE_CONSTANT,
+                          ureg->constant_range[i].first, 
+                          (ureg->constant_range[i].last + 1 -
+                           ureg->constant_range[i].first) );
    }
 
    if (ureg->nr_temps) {
@@ -890,6 +1001,15 @@ const struct tgsi_token *ureg_finalize( struct ureg_program *ureg )
                    ureg->domain[DOMAIN_DECL].count);
       tgsi_dump( tokens, 0 );
    }
+
+#if DEBUG
+   if (tokens && !tgsi_sanity_check(tokens)) {
+      debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n");
+      tgsi_dump(tokens, 0);
+      assert(0);
+   }
+#endif
+
    
    return tokens;
 }
@@ -911,6 +1031,25 @@ void *ureg_create_shader( struct ureg_program *ureg,
 }
 
 
+const struct tgsi_token *ureg_get_tokens( struct ureg_program *ureg,
+                                          unsigned *nr_tokens )
+{
+   const struct tgsi_token *tokens;
+
+   ureg_finalize(ureg);
+
+   tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token;
+
+   if (nr_tokens) 
+      *nr_tokens = ureg->domain[DOMAIN_DECL].size;
+
+   ureg->domain[DOMAIN_DECL].tokens = 0;
+   ureg->domain[DOMAIN_DECL].size = 0;
+   ureg->domain[DOMAIN_DECL].order = 0;
+   ureg->domain[DOMAIN_DECL].count = 0;
+
+   return tokens;
+}
 
 
 struct ureg_program *ureg_create( unsigned processor )
diff --git a/src/gallium/auxiliary/tgsi/tgsi_ureg.h b/src/gallium/auxiliary/tgsi/tgsi_ureg.h
index acbca59040..f04f443b9e 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_ureg.h
+++ b/src/gallium/auxiliary/tgsi/tgsi_ureg.h
@@ -82,10 +82,21 @@ ureg_create( unsigned processor );
 const struct tgsi_token *
 ureg_finalize( struct ureg_program * );
 
+/* Create and return a shader:
+ */
 void *
 ureg_create_shader( struct ureg_program *,
                     struct pipe_context *pipe );
 
+
+/* Alternately, return the built token stream and hand ownership of
+ * that memory to the caller:
+ */
+const struct tgsi_token *
+ureg_get_tokens( struct ureg_program *ureg,
+                 unsigned *nr_tokens );
+
+
 void 
 ureg_destroy( struct ureg_program * );
 
@@ -116,8 +127,7 @@ ureg_DECL_fs_input( struct ureg_program *,
 
 struct ureg_src
 ureg_DECL_vs_input( struct ureg_program *,
-                    unsigned semantic_name,
-                    unsigned semantic_index );
+                    unsigned index );
 
 struct ureg_dst
 ureg_DECL_output( struct ureg_program *,
@@ -130,7 +140,8 @@ ureg_DECL_immediate( struct ureg_program *,
                      unsigned nr );
 
 struct ureg_src
-ureg_DECL_constant( struct ureg_program * );
+ureg_DECL_constant( struct ureg_program *,
+                    unsigned index );
 
 struct ureg_dst
 ureg_DECL_temporary( struct ureg_program * );
@@ -233,6 +244,24 @@ ureg_insn(struct ureg_program *ureg,
           unsigned nr_src );
 
 
+void
+ureg_tex_insn(struct ureg_program *ureg,
+              unsigned opcode,
+              const struct ureg_dst *dst,
+              unsigned nr_dst,
+              unsigned target,
+              const struct ureg_src *src,
+              unsigned nr_src );
+
+
+void
+ureg_label_insn(struct ureg_program *ureg,
+                unsigned opcode,
+                const struct ureg_src *src,
+                unsigned nr_src,
+                unsigned *label);
+
+
 /***********************************************************************
  * Internal instruction helpers, don't call these directly:
  */
diff --git a/src/gallium/auxiliary/util/u_debug.h b/src/gallium/auxiliary/util/u_debug.h
index d42b65ce28..1380d98d7e 100644
--- a/src/gallium/auxiliary/util/u_debug.h
+++ b/src/gallium/auxiliary/util/u_debug.h
@@ -88,6 +88,7 @@ _debug_printf(const char *format, ...)
  * - avoid outputing large strings (512 bytes is the current maximum length 
  * that is guaranteed to be printed in all platforms)
  */
+#if !defined(PIPE_OS_HAIKU)
 static INLINE void
 debug_printf(const char *format, ...)
 {
@@ -101,6 +102,7 @@ debug_printf(const char *format, ...)
 #endif
 }
 
+#endif /* !PIPE_OS_HAIKU */
 
 /*
  * ... isn't portable so we need to pass arguments in parentheses.
diff --git a/src/gallium/auxiliary/util/u_fifo.h b/src/gallium/auxiliary/util/u_fifo.h
new file mode 100644
index 0000000000..9e007de1ad
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_fifo.h
@@ -0,0 +1,94 @@
+/**************************************************************************
+ *
+ * Copyright © 2009 Jakob Bornecrantz
+ *
+ * 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.
+ *
+ **************************************************************************/
+
+#ifndef U_FIFO_H
+#define U_FIFO_H
+
+#include "util/u_memory.h"
+
+struct util_fifo
+{
+   size_t head;
+   size_t tail;
+   size_t num;
+   size_t size;
+};
+
+static INLINE struct util_fifo *
+u_fifo_create(size_t size)
+{
+   struct util_fifo *fifo;
+   fifo = MALLOC(sizeof(*fifo) + size * sizeof(void*));
+
+   fifo->head = 0;
+   fifo->tail = 0;
+   fifo->num = 0;
+   fifo->size = size;
+
+   return fifo;
+}
+
+static INLINE boolean
+u_fifo_add(struct util_fifo *fifo, void *ptr)
+{
+   void **array = (void**)&fifo[1];
+   if (fifo->num >= fifo->size)
+      return FALSE;
+
+   if (++fifo->head >= fifo->size)
+      fifo->head = 0;
+
+   array[fifo->head] = ptr;
+
+   ++fifo->num;
+
+   return TRUE;
+}
+
+static INLINE boolean
+u_fifo_pop(struct util_fifo *fifo, void **ptr)
+{
+   void **array = (void**)&fifo[1];
+
+   if (!fifo->num)
+      return FALSE;
+
+   if (++fifo->tail >= fifo->size)
+      fifo->tail = 0;
+
+   *ptr = array[fifo->tail];
+
+   ++fifo->num;
+
+   return TRUE;
+}
+
+static INLINE void
+u_fifo_destroy(struct util_fifo *fifo)
+{
+   FREE(fifo);
+}
+
+#endif
diff --git a/src/gallium/auxiliary/util/u_format.csv b/src/gallium/auxiliary/util/u_format.csv
index 00a46d0cc4..f1bf94f17d 100644
--- a/src/gallium/auxiliary/util/u_format.csv
+++ b/src/gallium/auxiliary/util/u_format.csv
@@ -2,7 +2,7 @@ PIPE_FORMAT_A8R8G8B8_UNORM        , arith , 1, 1, un8 , un8 , un8 , un8 , zyxw,
 PIPE_FORMAT_X8R8G8B8_UNORM        , arith , 1, 1, un8 , un8 , un8 , un8 , zyx1, rgb
 PIPE_FORMAT_B8G8R8A8_UNORM        , arith , 1, 1, un8 , un8 , un8 , un8 , yzwx, rgb
 PIPE_FORMAT_B8G8R8X8_UNORM        , arith , 1, 1, un8 , un8 , un8 , un8 , yzw1, rgb
-PIPE_FORMAT_A1R5G5B5_UNORM        , arith , 1, 1, un1 , un5 , un5 , un5 , zyxw, rgb
+PIPE_FORMAT_A1R5G5B5_UNORM        , arith , 1, 1, un5 , un5 , un5 , un1 , zyxw, rgb
 PIPE_FORMAT_A4R4G4B4_UNORM        , arith , 1, 1, un4 , un4 , un4 , un4 , zyxw, rgb
 PIPE_FORMAT_R5G6B5_UNORM          , arith , 1, 1, un5 , un6 , un5 ,     , zyx1, rgb
 PIPE_FORMAT_A2B10G10R10_UNORM     , arith , 1, 1, un10, un10, un10, un2 , xyzw, rgb
@@ -14,10 +14,10 @@ PIPE_FORMAT_L16_UNORM             , arith , 1, 1, un16,     ,     ,     , xxx1,
 PIPE_FORMAT_Z16_UNORM             , array , 1, 1, un16,     ,     ,     , x___, zs 
 PIPE_FORMAT_Z32_UNORM             , array , 1, 1, un32,     ,     ,     , x___, zs 
 PIPE_FORMAT_Z32_FLOAT             , array , 1, 1, f32 ,     ,     ,     , x___, zs 
-PIPE_FORMAT_S8Z24_UNORM           , arith , 1, 1, un8 , un24,     ,     , yx__, zs 
-PIPE_FORMAT_Z24S8_UNORM           , arith , 1, 1, un24, un8 ,     ,     , xy__, zs 
-PIPE_FORMAT_X8Z24_UNORM           , arith , 1, 1, un8 , un24,     ,     , y___, zs 
-PIPE_FORMAT_Z24X8_UNORM           , arith , 1, 1, un24, un8 ,     ,     , x___, zs 
+PIPE_FORMAT_S8Z24_UNORM           , arith , 1, 1, un24, un8 ,     ,     , xy__, zs 
+PIPE_FORMAT_Z24S8_UNORM           , arith , 1, 1, un8 , un24,     ,     , yx__, zs 
+PIPE_FORMAT_X8Z24_UNORM           , arith , 1, 1, un24, un8 ,     ,     , x___, zs 
+PIPE_FORMAT_Z24X8_UNORM           , arith , 1, 1, un8 , un24,     ,     , y___, zs 
 PIPE_FORMAT_S8_UNORM              , array , 1, 1, un8 ,     ,     ,     , _x__, zs 
 PIPE_FORMAT_R64_FLOAT             , array , 1, 1, f64 ,     ,     ,     , x001, rgb
 PIPE_FORMAT_R64G64_FLOAT          , array , 1, 1, f64 , f64 ,     ,     , xy01, rgb
diff --git a/src/gallium/auxiliary/util/u_math.h b/src/gallium/auxiliary/util/u_math.h
index 4c6c2bc00e..b428dc544c 100644
--- a/src/gallium/auxiliary/util/u_math.h
+++ b/src/gallium/auxiliary/util/u_math.h
@@ -341,10 +341,22 @@ util_is_inf_or_nan(float x)
 
 
 /**
+ * Test whether x is a power of two.
+ */
+static INLINE boolean
+util_is_pot(unsigned x)
+{
+   return (x & (x - 1)) == 0;
+}
+
+
+/**
  * Find first bit set in word.  Least significant bit is 1.
  * Return 0 if no bits set.
  */
-#if defined(_MSC_VER) && _MSC_VER >= 1300
+#if defined(_MSC_VER) && _MSC_VER >= 1300 && (_M_IX86 || _M_AMD64 || _M_IA64)
+unsigned char _BitScanForward(unsigned long* Index, unsigned long Mask);
+#pragma intrinsic(_BitScanForward)
 static INLINE
 unsigned long ffs( unsigned long u )
 {
diff --git a/src/gallium/auxiliary/util/u_network.c b/src/gallium/auxiliary/util/u_network.c
index 07d804ecdb..bc4b758406 100644
--- a/src/gallium/auxiliary/util/u_network.c
+++ b/src/gallium/auxiliary/util/u_network.c
@@ -6,7 +6,7 @@
 #if defined(PIPE_SUBSYSTEM_WINDOWS_USER)
 #  include <winsock2.h>
 #  include <windows.h>
-#elif defined(PIPE_OS_LINUX)
+#elif defined(PIPE_OS_LINUX) || defined(PIPE_OS_HAIKU)
 #  include <sys/socket.h>
 #  include <netinet/in.h>
 #  include <unistd.h>
@@ -54,7 +54,7 @@ u_socket_close(int s)
    if (s < 0)
       return;
 
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_HAIKU)
    shutdown(s, SHUT_RDWR);
    close(s);
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
@@ -169,7 +169,7 @@ u_socket_listen_on_port(uint16_t portnum)
 void
 u_socket_block(int s, boolean block)
 {
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_HAIKU)
    int old = fcntl(s, F_GETFL, 0);
    if (old == -1)
       return;
diff --git a/src/gallium/auxiliary/util/u_network.h b/src/gallium/auxiliary/util/u_network.h
index 14d3884427..8c778f492c 100644
--- a/src/gallium/auxiliary/util/u_network.h
+++ b/src/gallium/auxiliary/util/u_network.h
@@ -6,7 +6,7 @@
 
 #if defined(PIPE_SUBSYSTEM_WINDOWS_USER)
 #  define PIPE_HAVE_SOCKETS
-#elif defined(PIPE_OS_LINUX)
+#elif defined(PIPE_OS_LINUX) || defined(PIPE_OS_HAIKU)
 #  define PIPE_HAVE_SOCKETS
 #endif
 
diff --git a/src/gallium/auxiliary/util/u_simple_screen.c b/src/gallium/auxiliary/util/u_simple_screen.c
index f01296b40f..5238299015 100644
--- a/src/gallium/auxiliary/util/u_simple_screen.c
+++ b/src/gallium/auxiliary/util/u_simple_screen.c
@@ -52,8 +52,7 @@ pass_user_buffer_create(struct pipe_screen *screen,
                         unsigned bytes)
 {
    struct pipe_buffer *buffer =
-      screen->winsys->user_buffer_create(screen->winsys,
-                                             ptr, bytes);
+      screen->winsys->user_buffer_create(screen->winsys, ptr, bytes);
 
    buffer->screen = screen;
 
@@ -69,9 +68,8 @@ pass_surface_buffer_create(struct pipe_screen *screen,
                            unsigned *stride)
 {
    struct pipe_buffer *buffer =
-      screen->winsys->surface_buffer_create(screen->winsys,
-                                                width, height,
-                                                format, usage, tex_usage, stride);
+      screen->winsys->surface_buffer_create(screen->winsys, width, height,
+                                            format, usage, tex_usage, stride);
 
    buffer->screen = screen;
 
@@ -83,8 +81,7 @@ pass_buffer_map(struct pipe_screen *screen,
                 struct pipe_buffer *buf,
                 unsigned usage)
 {
-   return screen->winsys->buffer_map(screen->winsys,
-                                     buf, usage);
+   return screen->winsys->buffer_map(screen->winsys, buf, usage);
 }
 
 static void
@@ -106,8 +103,7 @@ pass_flush_frontbuffer(struct pipe_screen *screen,
                        struct pipe_surface *surf,
                        void *context_private)
 {
-   screen->winsys->flush_frontbuffer(screen->winsys,
-                                     surf, context_private);
+   screen->winsys->flush_frontbuffer(screen->winsys, surf, context_private);
 }
 
 static void
@@ -115,8 +111,7 @@ pass_fence_reference(struct pipe_screen *screen,
                      struct pipe_fence_handle **ptr,
                      struct pipe_fence_handle *fence)
 {
-   screen->winsys->fence_reference(screen->winsys,
-                                   ptr, fence);
+   screen->winsys->fence_reference(screen->winsys, ptr, fence);
 }
 
 static int
@@ -124,8 +119,7 @@ pass_fence_signalled(struct pipe_screen *screen,
                      struct pipe_fence_handle *fence,
                      unsigned flag)
 {
-   return screen->winsys->fence_signalled(screen->winsys,
-                                          fence, flag);
+   return screen->winsys->fence_signalled(screen->winsys, fence, flag);
 }
 
 static int
@@ -133,11 +127,11 @@ pass_fence_finish(struct pipe_screen *screen,
                   struct pipe_fence_handle *fence,
                   unsigned flag)
 {
-   return screen->winsys->fence_finish(screen->winsys,
-                                       fence, flag);
+   return screen->winsys->fence_finish(screen->winsys, fence, flag);
 }
 
-void u_simple_screen_init(struct pipe_screen *screen)
+void
+u_simple_screen_init(struct pipe_screen *screen)
 {
    screen->buffer_create = pass_buffer_create;
    screen->user_buffer_create = pass_user_buffer_create;
@@ -152,7 +146,8 @@ void u_simple_screen_init(struct pipe_screen *screen)
    screen->fence_finish = pass_fence_finish;
 }
 
-const char* u_simple_screen_winsys_name(struct pipe_screen *screen)
+const char *
+u_simple_screen_winsys_name(struct pipe_screen *screen)
 {
    return screen->winsys->get_name(screen->winsys);
 }
diff --git a/src/gallium/auxiliary/util/u_simple_shaders.c b/src/gallium/auxiliary/util/u_simple_shaders.c
index 1b8da9b685..0d706f9449 100644
--- a/src/gallium/auxiliary/util/u_simple_shaders.c
+++ b/src/gallium/auxiliary/util/u_simple_shaders.c
@@ -34,14 +34,8 @@
 
 
 #include "pipe/p_context.h"
-#include "util/u_debug.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
 #include "pipe/p_shader_tokens.h"
-
-#include "util/u_memory.h"
 #include "util/u_simple_shaders.h"
-
 #include "tgsi/tgsi_ureg.h"
 
 
@@ -67,9 +61,7 @@ util_make_vertex_passthrough_shader(struct pipe_context *pipe,
       struct ureg_src src;
       struct ureg_dst dst;
 
-      src = ureg_DECL_vs_input( ureg,
-                                semantic_names[i],
-                                semantic_indexes[i]);
+      src = ureg_DECL_vs_input( ureg, i );
       
       dst = ureg_DECL_output( ureg,
                               semantic_names[i],
@@ -131,8 +123,6 @@ util_make_fragment_tex_shader(struct pipe_context *pipe )
 
 
 
-
-
 /**
  * Make simple fragment color pass-through shader.
  */
diff --git a/src/gallium/auxiliary/util/u_stream_stdc.c b/src/gallium/auxiliary/util/u_stream_stdc.c
index d8f648e5dd..5cd05b2904 100644
--- a/src/gallium/auxiliary/util/u_stream_stdc.c
+++ b/src/gallium/auxiliary/util/u_stream_stdc.c
@@ -32,7 +32,7 @@
 
 #include "pipe/p_config.h"
 
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU)
 
 #include <stdio.h>
 
diff --git a/src/gallium/auxiliary/util/u_tile.c b/src/gallium/auxiliary/util/u_tile.c
index 1235a67d26..0d6489c26e 100644
--- a/src/gallium/auxiliary/util/u_tile.c
+++ b/src/gallium/auxiliary/util/u_tile.c
@@ -170,7 +170,7 @@ x8r8g8b8_get_tile_rgba(const unsigned *src,
          pRow[0] = ubyte_to_float((pixel >> 16) & 0xff);
          pRow[1] = ubyte_to_float((pixel >>  8) & 0xff);
          pRow[2] = ubyte_to_float((pixel >>  0) & 0xff);
-         pRow[3] = ubyte_to_float(0xff);
+         pRow[3] = 1.0F;
       }
       p += dst_stride;
    }
@@ -394,6 +394,52 @@ r5g6b5_put_tile_rgba(ushort *dst,
 
 
 
+/*** PIPE_FORMAT_R8G8B8_UNORM ***/
+
+static void
+r8g8b8_get_tile_rgba(const ubyte *src,
+                     unsigned w, unsigned h,
+                     float *p,
+                     unsigned dst_stride)
+{
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] = ubyte_to_float(src[0]);
+         pRow[1] = ubyte_to_float(src[1]);
+         pRow[2] = ubyte_to_float(src[2]);
+         pRow[3] = 1.0f;
+         src += 3;
+      }
+      p += dst_stride;
+   }
+}
+
+
+static void
+r8g8b8_put_tile_rgba(ubyte *dst,
+                     unsigned w, unsigned h,
+                     const float *p,
+                     unsigned src_stride)
+{
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      const float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         dst[0] = float_to_ubyte(pRow[0]);
+         dst[1] = float_to_ubyte(pRow[1]);
+         dst[2] = float_to_ubyte(pRow[2]);
+         dst += 3;
+      }
+      p += src_stride;
+   }
+}
+
+
+
 /*** PIPE_FORMAT_Z16_UNORM ***/
 
 /**
@@ -1106,6 +1152,9 @@ pipe_tile_raw_to_rgba(enum pipe_format format,
    case PIPE_FORMAT_R5G6B5_UNORM:
       r5g6b5_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
       break;
+   case PIPE_FORMAT_R8G8B8_UNORM:
+      r8g8b8_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
+      break;
    case PIPE_FORMAT_L8_UNORM:
       l8_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
       break;
@@ -1222,6 +1271,9 @@ pipe_put_tile_rgba(struct pipe_transfer *pt,
    case PIPE_FORMAT_R5G6B5_UNORM:
       r5g6b5_put_tile_rgba((ushort *) packed, w, h, p, src_stride);
       break;
+   case PIPE_FORMAT_R8G8B8_UNORM:
+      r8g8b8_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);
+      break;
    case PIPE_FORMAT_R8G8B8A8_UNORM:
       assert(0);
       break;
diff --git a/src/gallium/auxiliary/util/u_time.c b/src/gallium/auxiliary/util/u_time.c
index c16cdd0b22..b958a98635 100644
--- a/src/gallium/auxiliary/util/u_time.c
+++ b/src/gallium/auxiliary/util/u_time.c
@@ -35,7 +35,7 @@
 
 #include "pipe/p_config.h"
 
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
 #include <sys/time.h>
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
 #include <windows.h>
@@ -77,7 +77,7 @@ util_time_get_frequency(void)
 void 
 util_time_get(struct util_time *t)
 {
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    gettimeofday(&t->tv, NULL);
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
    LONGLONG temp;
@@ -102,7 +102,7 @@ util_time_add(const struct util_time *t1,
               int64_t usecs,
               struct util_time *t2)
 {
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    t2->tv.tv_sec = t1->tv.tv_sec + usecs / 1000000;
    t2->tv.tv_usec = t1->tv.tv_usec + usecs % 1000000;
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
@@ -124,7 +124,7 @@ int64_t
 util_time_diff(const struct util_time *t1, 
                const struct util_time *t2)
 {
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    return (t2->tv.tv_usec - t1->tv.tv_usec) + 
           (t2->tv.tv_sec - t1->tv.tv_sec)*1000000;
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
@@ -144,7 +144,7 @@ util_time_micros( void )
    
    util_time_get(&t1);
    
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    return t1.tv.tv_usec + t1.tv.tv_sec*1000000LL;
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
    util_time_get_frequency();
@@ -166,7 +166,7 @@ static INLINE int
 util_time_compare(const struct util_time *t1, 
                   const struct util_time *t2)
 {
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    if (t1->tv.tv_sec < t2->tv.tv_sec)
       return -1;
    else if(t1->tv.tv_sec > t2->tv.tv_sec)
diff --git a/src/gallium/auxiliary/util/u_time.h b/src/gallium/auxiliary/util/u_time.h
index 7a5c54d9b2..a6189a247b 100644
--- a/src/gallium/auxiliary/util/u_time.h
+++ b/src/gallium/auxiliary/util/u_time.h
@@ -43,6 +43,11 @@
 #include <unistd.h> /* usleep */
 #endif
 
+#if defined(PIPE_OS_HAIKU)
+#include <sys/time.h> /* timeval */
+#include <unistd.h>
+#endif
+
 #include "pipe/p_compiler.h"
 
 
@@ -58,7 +63,7 @@ extern "C" {
  */
 struct util_time 
 {
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    struct timeval tv;
 #else
    int64_t counter;
@@ -89,7 +94,7 @@ util_time_timeout(const struct util_time *start,
                   const struct util_time *end,
                   const struct util_time *curr);
 
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
 #define util_time_sleep usleep
 #else
 void
diff --git a/src/gallium/drivers/cell/ppu/cell_screen.c b/src/gallium/drivers/cell/ppu/cell_screen.c
index bd48ce7005..9161747fdb 100644
--- a/src/gallium/drivers/cell/ppu/cell_screen.c
+++ b/src/gallium/drivers/cell/ppu/cell_screen.c
@@ -64,8 +64,6 @@ cell_get_param(struct pipe_screen *screen, int param)
       return 1;
    case PIPE_CAP_GLSL:
       return 1;
-   case PIPE_CAP_S3TC:
-      return 0;
    case PIPE_CAP_ANISOTROPIC_FILTER:
       return 0;
    case PIPE_CAP_POINT_SPRITE:
diff --git a/src/gallium/drivers/i915simple/i915_prim_vbuf.c b/src/gallium/drivers/i915simple/i915_prim_vbuf.c
index 508f4560e4..b3a7774fd6 100644
--- a/src/gallium/drivers/i915simple/i915_prim_vbuf.c
+++ b/src/gallium/drivers/i915simple/i915_prim_vbuf.c
@@ -44,6 +44,7 @@
 #include "pipe/p_inlines.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
+#include "util/u_fifo.h"
 
 #include "i915_context.h"
 #include "i915_reg.h"
@@ -76,8 +77,13 @@ struct i915_vbuf_render {
    size_t vbo_size;
    size_t vbo_offset;
    void *vbo_ptr;
-   size_t vbo_alloc_size;
    size_t vbo_max_used;
+
+   /* stuff for the pool */
+   struct util_fifo *pool_fifo;
+   unsigned pool_used;
+   unsigned pool_buffer_size;
+   boolean pool_not_used;
 };
 
 
@@ -106,33 +112,72 @@ i915_vbuf_render_get_vertex_info(struct vbuf_render *render)
 }
 
 static boolean
+i915_vbuf_render_reserve(struct i915_vbuf_render *i915_render, size_t size)
+{
+   struct i915_context *i915 = i915_render->i915;
+
+   if (i915_render->vbo_size < size + i915_render->vbo_offset)
+      return FALSE;
+
+   if (i915->vbo_flushed)
+      return FALSE;
+
+   return TRUE;
+}
+
+static void
+i915_vbuf_render_new_buf(struct i915_vbuf_render *i915_render, size_t size)
+{
+   struct i915_context *i915 = i915_render->i915;
+   struct intel_winsys *iws = i915->iws;
+
+   if (i915_render->vbo) {
+      if (i915_render->pool_not_used)
+         iws->buffer_destroy(iws, i915_render->vbo);
+      else
+         u_fifo_add(i915_render->pool_fifo, i915_render->vbo);
+      i915_render->vbo = NULL;
+   }
+
+   i915->vbo_flushed = 0;
+
+   i915_render->vbo_size = MAX2(size, i915_render->pool_buffer_size);
+   i915_render->vbo_offset = 0;
+
+   if (i915_render->vbo_size != i915_render->pool_buffer_size) {
+      i915_render->pool_not_used = TRUE;
+      i915_render->vbo = iws->buffer_create(iws, i915_render->vbo_size, 64,
+            INTEL_NEW_VERTEX);
+   } else {
+      i915_render->pool_not_used = FALSE;
+
+      if (i915_render->pool_used >= 2) {
+         FLUSH_BATCH(NULL);
+         i915->vbo_flushed = 0;
+         i915_render->pool_used = 0;
+      }
+      u_fifo_pop(i915_render->pool_fifo, (void**)&i915_render->vbo);
+   }
+}
+
+static boolean
 i915_vbuf_render_allocate_vertices(struct vbuf_render *render,
                                    ushort vertex_size,
                                    ushort nr_vertices)
 {
    struct i915_vbuf_render *i915_render = i915_vbuf_render(render);
    struct i915_context *i915 = i915_render->i915;
-   struct intel_winsys *iws = i915->iws;
    size_t size = (size_t)vertex_size * (size_t)nr_vertices;
 
    /* FIXME: handle failure */
    assert(!i915->vbo);
 
-   if (i915_render->vbo_size > size + i915_render->vbo_offset && !i915->vbo_flushed) {
-   } else {
-      i915->vbo_flushed = 0;
-      if (i915_render->vbo) {
-         iws->buffer_destroy(iws, i915_render->vbo);
-         i915_render->vbo = NULL;
-      }
-   }
+   if (!i915_vbuf_render_reserve(i915_render, size)) {
 
-   if (!i915_render->vbo) {
-      i915_render->vbo_size = MAX2(size, i915_render->vbo_alloc_size);
-      i915_render->vbo_offset = 0;
-      i915_render->vbo = iws->buffer_create(iws, i915_render->vbo_size, 64,
-                                            INTEL_NEW_VERTEX);
+      if (i915->vbo_flushed)
+         i915_render->pool_used = 0;
 
+      i915_vbuf_render_new_buf(i915_render, size);
    }
 
    i915_render->vertex_size = vertex_size;
@@ -504,6 +549,7 @@ i915_vbuf_render_create(struct i915_context *i915)
 {
    struct i915_vbuf_render *i915_render = CALLOC_STRUCT(i915_vbuf_render);
    struct intel_winsys *iws = i915->iws;
+   int i;
 
    i915_render->i915 = i915;
    
@@ -524,14 +570,24 @@ i915_vbuf_render_create(struct i915_context *i915)
    i915_render->base.release_vertices = i915_vbuf_render_release_vertices;
    i915_render->base.destroy = i915_vbuf_render_destroy;
 
-   i915_render->vbo_alloc_size = 128 * 4096;
-   i915_render->vbo_size = i915_render->vbo_alloc_size;
+
+   i915_render->vbo = NULL;
+   i915_render->vbo_size = 0;
    i915_render->vbo_offset = 0;
-   i915_render->vbo = iws->buffer_create(iws, i915_render->vbo_size, 64,
-                                         INTEL_NEW_VERTEX);
+
+   i915_render->pool_used = FALSE;
+   i915_render->pool_buffer_size = 128 * 4096;
+   i915_render->pool_fifo = u_fifo_create(6);
+   for (i = 0; i < 6; i++)
+      u_fifo_add(i915_render->pool_fifo,
+                 iws->buffer_create(iws, i915_render->pool_buffer_size, 64,
+                                    INTEL_NEW_VERTEX));
+
+#if 0
    /* TODO JB: is this realy needed? */
    i915_render->vbo_ptr = iws->buffer_map(iws, i915_render->vbo, TRUE);
    iws->buffer_unmap(iws, i915_render->vbo);
+#endif
 
    return &i915_render->base;
 }
diff --git a/src/gallium/drivers/i915simple/i915_screen.c b/src/gallium/drivers/i915simple/i915_screen.c
index 9f017a14cc..a1dd43c1bc 100644
--- a/src/gallium/drivers/i915simple/i915_screen.c
+++ b/src/gallium/drivers/i915simple/i915_screen.c
@@ -101,8 +101,6 @@ i915_get_param(struct pipe_screen *screen, int param)
       return 1;
    case PIPE_CAP_GLSL:
       return 0;
-   case PIPE_CAP_S3TC:
-      return 0;
    case PIPE_CAP_ANISOTROPIC_FILTER:
       return 0;
    case PIPE_CAP_POINT_SPRITE:
diff --git a/src/gallium/drivers/i915simple/intel_winsys.h b/src/gallium/drivers/i915simple/intel_winsys.h
index f949f52a9c..42c5e7470e 100644
--- a/src/gallium/drivers/i915simple/intel_winsys.h
+++ b/src/gallium/drivers/i915simple/intel_winsys.h
@@ -150,6 +150,17 @@ struct intel_winsys {
    void (*buffer_unmap)(struct intel_winsys *iws,
                         struct intel_buffer *buffer);
 
+   /**
+    * Write to a buffer.
+    *
+    * Arguments follows pwrite(2)
+    */
+   int (*buffer_write)(struct intel_winsys *iws,
+                       struct intel_buffer *dst,
+                       const void *src,
+                       size_t size,
+                       size_t offset);
+
    void (*buffer_destroy)(struct intel_winsys *iws,
                           struct intel_buffer *buffer);
    /*@}*/
diff --git a/src/gallium/drivers/i965simple/brw_screen.c b/src/gallium/drivers/i965simple/brw_screen.c
index b22e105f10..fb68fd624b 100644
--- a/src/gallium/drivers/i965simple/brw_screen.c
+++ b/src/gallium/drivers/i965simple/brw_screen.c
@@ -85,8 +85,6 @@ brw_get_param(struct pipe_screen *screen, int param)
       return 1;
    case PIPE_CAP_GLSL:
       return 0;
-   case PIPE_CAP_S3TC:
-      return 0;
    case PIPE_CAP_ANISOTROPIC_FILTER:
       return 0;
    case PIPE_CAP_POINT_SPRITE:
diff --git a/src/gallium/drivers/llvmpipe/Makefile b/src/gallium/drivers/llvmpipe/Makefile
index 6e63a0c2b7..cd7b6356d2 100644
--- a/src/gallium/drivers/llvmpipe/Makefile
+++ b/src/gallium/drivers/llvmpipe/Makefile
@@ -3,6 +3,8 @@ include $(TOP)/configs/current
 
 LIBNAME = llvmpipe
 
+CFLAGS += -D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS
+
 C_SOURCES = \
 	lp_bld_alpha.c \
 	lp_bld_arit.c \
@@ -15,9 +17,11 @@ C_SOURCES = \
 	lp_bld_depth.c \
 	lp_bld_flow.c \
 	lp_bld_format_aos.c \
+	lp_bld_format_soa.c \
 	lp_bld_interp.c \
 	lp_bld_intr.c \
 	lp_bld_logic.c \
+	lp_bld_sample_soa.c \
 	lp_bld_swizzle.c \
 	lp_bld_struct.c \
 	lp_bld_tgsi_soa.c \
@@ -44,7 +48,8 @@ C_SOURCES = \
 	lp_state_vs.c \
 	lp_surface.c \
 	lp_tex_cache.c \
-	lp_tex_sample.c \
+	lp_tex_sample_c.c \
+	lp_tex_sample_llvm.c \
 	lp_texture.c \
 	lp_tile_cache.c \
 	lp_tile_soa.c
diff --git a/src/gallium/drivers/llvmpipe/README b/src/gallium/drivers/llvmpipe/README
index 498d21dea6..89d08834a3 100644
--- a/src/gallium/drivers/llvmpipe/README
+++ b/src/gallium/drivers/llvmpipe/README
@@ -8,13 +8,16 @@ Done so far is:
 
  - the whole fragment pipeline is code generated in a single function
  
+   - input interpolation
+   
    - depth testing
  
+   - texture sampling (not all state/formats are supported) 
+   
    - fragment shader TGSI translation
      - same level of support as the TGSI SSE2 exec machine, with the exception
        we don't fallback to TGSI interpretation when an unsupported opcode is
        found, but just ignore it
-     - texture sampling via an intrinsic call
      - done in SoA layout
      - input interpolation also code generated
  
@@ -28,16 +31,17 @@ Done so far is:
      any width and length
    - not all operations are implemented for these types yet though
 
-Most mesa/progs/demos/* work. Speed is on par with Keith's softpipe-opt branch,
-which includes hand written fast implementations for common cases.
+Most mesa/progs/demos/* work. 
 
 To do (probably by this order):
 
  - code generate stipple and stencil testing
 
- - code generate texture sampling
+ - translate the remaining bits of texture sampling state
 
  - translate TGSI control flow instructions, and all other remaining opcodes
+ 
+ - integrate with the draw module for VS code generation
 
  - code generate the triangle setup and rasterization
 
@@ -93,7 +97,7 @@ Alternatively, you can build it with GNU make, if you prefer, by invoking it as
 
   make linux-llvm
 
-but the rest of these instructions assume scons is used.
+but the rest of these instructions assume that scons is used.
 
 
 Using
@@ -108,6 +112,9 @@ or
 
   export LD_LIBRARY_PATH=$PWD/build/linux-x86-debug/lib:$LD_LIBRARY_PATH
 
+For performance evaluation pass debug=no to scons, and use the corresponding
+lib directory without the "-debug" suffix.
+
 
 Unit testing
 ============
@@ -119,7 +126,7 @@ build/linux-???-debug/gallium/drivers/llvmpipe:
  - lp_test_conv: SIMD vector conversion
  - lp_test_format: pixel unpacking/packing
 
-Some of this tests can output results and benchmarks to a tab-seperated-file
+Some of this tests can output results and benchmarks to a tab-separated-file
 for posterior analysis, e.g.:
 
   build/linux-x86_64-debug/gallium/drivers/llvmpipe/lp_test_blend -o blend.tsv
@@ -133,10 +140,10 @@ Development Notes
   at the top of the lp_bld_*.c functions.  
 
 - All lp_bld_*.[ch] are isolated from the rest of the driver, and could/may be 
-  put in a standalone Gallium state -> LLVM IR translation module.
+  put in a stand-alone Gallium state -> LLVM IR translation module.
 
 - We use LLVM-C bindings for now. They are not documented, but follow the C++
   interfaces very closely, and appear to be complete enough for code
   generation. See 
   http://npcontemplation.blogspot.com/2008/06/secret-of-llvm-c-bindings.html
-  for a standalone example.
+  for a stand-alone example.
diff --git a/src/gallium/drivers/llvmpipe/SConscript b/src/gallium/drivers/llvmpipe/SConscript
index 5c29bdac56..f4a9a3b22e 100644
--- a/src/gallium/drivers/llvmpipe/SConscript
+++ b/src/gallium/drivers/llvmpipe/SConscript
@@ -3,7 +3,7 @@ Import('*')
 env = env.Clone()
 
 env.Tool('llvm')
-if 'LLVM_VERSION' not in env:
+if not env.has_key('LLVM_VERSION'):
     print 'warning: LLVM not found: not building llvmpipe'
     Return()
 
@@ -23,8 +23,10 @@ llvmpipe = env.ConvenienceLibrary(
 		'lp_bld_depth.c',
 		'lp_bld_flow.c',
 		'lp_bld_format_aos.c',
+		'lp_bld_format_soa.c',
 		'lp_bld_interp.c',
 		'lp_bld_intr.c',
+		'lp_bld_sample_soa.c',
 		'lp_bld_struct.c',
 		'lp_bld_logic.c',
 		'lp_bld_swizzle.c',
@@ -52,7 +54,8 @@ llvmpipe = env.ConvenienceLibrary(
 		'lp_state_vs.c',
 		'lp_surface.c',
 		'lp_tex_cache.c',
-		'lp_tex_sample.c',
+		'lp_tex_sample_c.c',
+		'lp_tex_sample_llvm.c',
 		'lp_texture.c',
 		'lp_tile_cache.c',
 		'lp_tile_soa.c',
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_alpha.c b/src/gallium/drivers/llvmpipe/lp_bld_alpha.c
index 49c2f911af..2b4bc5c819 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_alpha.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_alpha.c
@@ -45,7 +45,7 @@
 void
 lp_build_alpha_test(LLVMBuilderRef builder,
                     const struct pipe_alpha_state *state,
-                    union lp_type type,
+                    struct lp_type type,
                     struct lp_build_mask_context *mask,
                     LLVMValueRef alpha,
                     LLVMValueRef ref)
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_alpha.h b/src/gallium/drivers/llvmpipe/lp_bld_alpha.h
index 9dbcdb4daa..634575670d 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_alpha.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_alpha.h
@@ -38,14 +38,14 @@
 #include <llvm-c/Core.h>  
 
 struct pipe_alpha_state;
-union lp_type;
+struct lp_type;
 struct lp_build_mask_context;
 
 
 void
 lp_build_alpha_test(LLVMBuilderRef builder,
                     const struct pipe_alpha_state *state,
-                    union lp_type type,
+                    struct lp_type type,
                     struct lp_build_mask_context *mask,
                     LLVMValueRef alpha,
                     LLVMValueRef ref);
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_arit.c b/src/gallium/drivers/llvmpipe/lp_bld_arit.c
index 09a57ff33d..0b115fc9b0 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_arit.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_arit.c
@@ -65,7 +65,7 @@ lp_build_min_simple(struct lp_build_context *bld,
                     LLVMValueRef a,
                     LLVMValueRef b)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    const char *intrinsic = NULL;
    LLVMValueRef cond;
 
@@ -113,7 +113,7 @@ lp_build_max_simple(struct lp_build_context *bld,
                     LLVMValueRef a,
                     LLVMValueRef b)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    const char *intrinsic = NULL;
    LLVMValueRef cond;
 
@@ -159,7 +159,7 @@ LLVMValueRef
 lp_build_comp(struct lp_build_context *bld,
               LLVMValueRef a)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
 
    if(a == bld->one)
       return bld->zero;
@@ -188,7 +188,7 @@ lp_build_add(struct lp_build_context *bld,
              LLVMValueRef a,
              LLVMValueRef b)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMValueRef res;
 
    if(a == bld->zero)
@@ -241,7 +241,7 @@ lp_build_sub(struct lp_build_context *bld,
              LLVMValueRef a,
              LLVMValueRef b)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMValueRef res;
 
    if(b == bld->zero)
@@ -405,7 +405,7 @@ lp_build_mul(struct lp_build_context *bld,
              LLVMValueRef a,
              LLVMValueRef b)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
 
    if(a == bld->zero)
       return bld->zero;
@@ -477,7 +477,7 @@ lp_build_div(struct lp_build_context *bld,
              LLVMValueRef a,
              LLVMValueRef b)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
 
    if(a == bld->zero)
       return bld->zero;
@@ -502,6 +502,31 @@ lp_build_div(struct lp_build_context *bld,
 }
 
 
+LLVMValueRef
+lp_build_lerp(struct lp_build_context *bld,
+              LLVMValueRef x,
+              LLVMValueRef v0,
+              LLVMValueRef v1)
+{
+   return lp_build_add(bld, v0, lp_build_mul(bld, x, lp_build_sub(bld, v1, v0)));
+}
+
+
+LLVMValueRef
+lp_build_lerp_2d(struct lp_build_context *bld,
+                 LLVMValueRef x,
+                 LLVMValueRef y,
+                 LLVMValueRef v00,
+                 LLVMValueRef v01,
+                 LLVMValueRef v10,
+                 LLVMValueRef v11)
+{
+   LLVMValueRef v0 = lp_build_lerp(bld, x, v00, v01);
+   LLVMValueRef v1 = lp_build_lerp(bld, x, v10, v11);
+   return lp_build_lerp(bld, y, v0, v1);
+}
+
+
 /**
  * Generate min(a, b)
  * Do checks for special cases.
@@ -565,21 +590,32 @@ LLVMValueRef
 lp_build_abs(struct lp_build_context *bld,
              LLVMValueRef a)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
+   LLVMTypeRef vec_type = lp_build_vec_type(type);
 
    if(!type.sign)
       return a;
 
-   /* XXX: is this really necessary? */
+   if(type.floating) {
+      /* Mask out the sign bit */
+      LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
+      LLVMValueRef mask = lp_build_int_const_scalar(type, ((unsigned long long)1 << type.width) - 1);
+      a = LLVMBuildBitCast(bld->builder, a, int_vec_type, "");
+      a = LLVMBuildAnd(bld->builder, a, mask, "");
+      a = LLVMBuildBitCast(bld->builder, a, vec_type, "");
+      return a;
+   }
+
 #if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
-   if(!type.floating && type.width*type.length == 128) {
-      LLVMTypeRef vec_type = lp_build_vec_type(type);
-      if(type.width == 8)
+   if(type.width*type.length == 128) {
+      switch(type.width) {
+      case 8:
          return lp_build_intrinsic_unary(bld->builder, "llvm.x86.ssse3.pabs.b.128", vec_type, a);
-      if(type.width == 16)
+      case 16:
          return lp_build_intrinsic_unary(bld->builder, "llvm.x86.ssse3.pabs.w.128", vec_type, a);
-      if(type.width == 32)
+      case 32:
          return lp_build_intrinsic_unary(bld->builder, "llvm.x86.ssse3.pabs.d.128", vec_type, a);
+      }
    }
 #endif
 
@@ -588,10 +624,188 @@ lp_build_abs(struct lp_build_context *bld,
 
 
 LLVMValueRef
+lp_build_sgn(struct lp_build_context *bld,
+             LLVMValueRef a)
+{
+   const struct lp_type type = bld->type;
+   LLVMTypeRef vec_type = lp_build_vec_type(type);
+   LLVMValueRef cond;
+   LLVMValueRef res;
+
+   /* Handle non-zero case */
+   if(!type.sign) {
+      /* if not zero then sign must be positive */
+      res = bld->one;
+   }
+   else if(type.floating) {
+      /* Take the sign bit and add it to 1 constant */
+      LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
+      LLVMValueRef mask = lp_build_int_const_scalar(type, (unsigned long long)1 << (type.width - 1));
+      LLVMValueRef sign;
+      LLVMValueRef one;
+      sign = LLVMBuildBitCast(bld->builder, a, int_vec_type, "");
+      sign = LLVMBuildAnd(bld->builder, sign, mask, "");
+      one = LLVMConstBitCast(bld->one, int_vec_type);
+      res = LLVMBuildOr(bld->builder, sign, one, "");
+      res = LLVMBuildBitCast(bld->builder, res, vec_type, "");
+   }
+   else
+   {
+      LLVMValueRef minus_one = lp_build_const_scalar(type, -1.0);
+      cond = lp_build_cmp(bld, PIPE_FUNC_GREATER, a, bld->zero);
+      res = lp_build_select(bld, cond, bld->one, minus_one);
+   }
+
+   /* Handle zero */
+   cond = lp_build_cmp(bld, PIPE_FUNC_EQUAL, a, bld->zero);
+   res = lp_build_select(bld, cond, bld->zero, bld->one);
+
+   return res;
+}
+
+
+enum lp_build_round_sse41_mode
+{
+   LP_BUILD_ROUND_SSE41_NEAREST = 0,
+   LP_BUILD_ROUND_SSE41_FLOOR = 1,
+   LP_BUILD_ROUND_SSE41_CEIL = 2,
+   LP_BUILD_ROUND_SSE41_TRUNCATE = 3
+};
+
+
+static INLINE LLVMValueRef
+lp_build_round_sse41(struct lp_build_context *bld,
+                     LLVMValueRef a,
+                     enum lp_build_round_sse41_mode mode)
+{
+   const struct lp_type type = bld->type;
+   LLVMTypeRef vec_type = lp_build_vec_type(type);
+   const char *intrinsic;
+
+   assert(type.floating);
+   assert(type.width*type.length == 128);
+
+   switch(type.width) {
+   case 32:
+      intrinsic = "llvm.x86.sse41.round.ps";
+      break;
+   case 64:
+      intrinsic = "llvm.x86.sse41.round.pd";
+      break;
+   default:
+      assert(0);
+      return bld->undef;
+   }
+
+   return lp_build_intrinsic_binary(bld->builder, intrinsic, vec_type, a,
+                                    LLVMConstInt(LLVMInt32Type(), mode, 0));
+}
+
+
+LLVMValueRef
+lp_build_round(struct lp_build_context *bld,
+               LLVMValueRef a)
+{
+   const struct lp_type type = bld->type;
+
+   assert(type.floating);
+
+#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+   return lp_build_round_sse41(bld, a, LP_BUILD_ROUND_SSE41_NEAREST);
+#endif
+
+   /* FIXME */
+   assert(0);
+   return bld->undef;
+}
+
+
+LLVMValueRef
+lp_build_floor(struct lp_build_context *bld,
+               LLVMValueRef a)
+{
+   const struct lp_type type = bld->type;
+
+   assert(type.floating);
+
+#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+   return lp_build_round_sse41(bld, a, LP_BUILD_ROUND_SSE41_FLOOR);
+#endif
+
+   /* FIXME */
+   assert(0);
+   return bld->undef;
+}
+
+
+LLVMValueRef
+lp_build_ceil(struct lp_build_context *bld,
+              LLVMValueRef a)
+{
+   const struct lp_type type = bld->type;
+
+   assert(type.floating);
+
+#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+   return lp_build_round_sse41(bld, a, LP_BUILD_ROUND_SSE41_CEIL);
+#endif
+
+   /* FIXME */
+   assert(0);
+   return bld->undef;
+}
+
+
+LLVMValueRef
+lp_build_trunc(struct lp_build_context *bld,
+               LLVMValueRef a)
+{
+   const struct lp_type type = bld->type;
+
+   assert(type.floating);
+
+#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+   return lp_build_round_sse41(bld, a, LP_BUILD_ROUND_SSE41_TRUNCATE);
+#endif
+
+   /* FIXME */
+   assert(0);
+   return bld->undef;
+}
+
+
+/**
+ * Convert to integer, through whichever rounding method that's fastest,
+ * typically truncating to zero.
+ */
+LLVMValueRef
+lp_build_int(struct lp_build_context *bld,
+             LLVMValueRef a)
+{
+   const struct lp_type type = bld->type;
+   LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
+
+   assert(type.floating);
+
+   return LLVMBuildFPToSI(bld->builder, a, int_vec_type, "");
+}
+
+
+LLVMValueRef
+lp_build_ifloor(struct lp_build_context *bld,
+                LLVMValueRef a)
+{
+   a = lp_build_floor(bld, a);
+   a = lp_build_int(bld, a);
+   return a;
+}
+
+
+LLVMValueRef
 lp_build_sqrt(struct lp_build_context *bld,
               LLVMValueRef a)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMTypeRef vec_type = lp_build_vec_type(type);
    char intrinsic[32];
 
@@ -609,7 +823,7 @@ LLVMValueRef
 lp_build_rcp(struct lp_build_context *bld,
              LLVMValueRef a)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
 
    if(a == bld->zero)
       return bld->undef;
@@ -640,7 +854,7 @@ LLVMValueRef
 lp_build_rsqrt(struct lp_build_context *bld,
                LLVMValueRef a)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
 
    assert(type.floating);
 
@@ -661,7 +875,7 @@ LLVMValueRef
 lp_build_cos(struct lp_build_context *bld,
               LLVMValueRef a)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMTypeRef vec_type = lp_build_vec_type(type);
    char intrinsic[32];
 
@@ -681,7 +895,7 @@ LLVMValueRef
 lp_build_sin(struct lp_build_context *bld,
               LLVMValueRef a)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMTypeRef vec_type = lp_build_vec_type(type);
    char intrinsic[32];
 
@@ -752,7 +966,7 @@ lp_build_polynomial(struct lp_build_context *bld,
                     const double *coeffs,
                     unsigned num_coeffs)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMValueRef res = NULL;
    unsigned i;
 
@@ -800,7 +1014,7 @@ lp_build_exp2_approx(struct lp_build_context *bld,
                      LLVMValueRef *p_frac_part,
                      LLVMValueRef *p_exp2)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMTypeRef vec_type = lp_build_vec_type(type);
    LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
    LLVMValueRef ipart = NULL;
@@ -893,7 +1107,7 @@ lp_build_log2_approx(struct lp_build_context *bld,
                      LLVMValueRef *p_floor_log2,
                      LLVMValueRef *p_log2)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMTypeRef vec_type = lp_build_vec_type(type);
    LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
 
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_arit.h b/src/gallium/drivers/llvmpipe/lp_bld_arit.h
index fc8cb25966..d68a97c4b8 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_arit.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_arit.h
@@ -40,7 +40,7 @@
 #include <llvm-c/Core.h>  
 
 
-union lp_type type;
+struct lp_type type;
 struct lp_build_context;
 
 
@@ -72,6 +72,26 @@ lp_build_div(struct lp_build_context *bld,
              LLVMValueRef b);
 
 LLVMValueRef
+lp_build_lerp(struct lp_build_context *bld,
+              LLVMValueRef x,
+              LLVMValueRef v0,
+              LLVMValueRef v1);
+
+/**
+ * Bilinear interpolation.
+ *
+ * Values indices are in v_{yx}.
+ */
+LLVMValueRef
+lp_build_lerp_2d(struct lp_build_context *bld,
+                 LLVMValueRef x,
+                 LLVMValueRef y,
+                 LLVMValueRef v00,
+                 LLVMValueRef v01,
+                 LLVMValueRef v10,
+                 LLVMValueRef v11);
+
+LLVMValueRef
 lp_build_min(struct lp_build_context *bld,
              LLVMValueRef a,
              LLVMValueRef b);
@@ -86,6 +106,34 @@ lp_build_abs(struct lp_build_context *bld,
              LLVMValueRef a);
 
 LLVMValueRef
+lp_build_sgn(struct lp_build_context *bld,
+             LLVMValueRef a);
+
+LLVMValueRef
+lp_build_round(struct lp_build_context *bld,
+               LLVMValueRef a);
+
+LLVMValueRef
+lp_build_floor(struct lp_build_context *bld,
+               LLVMValueRef a);
+
+LLVMValueRef
+lp_build_ceil(struct lp_build_context *bld,
+              LLVMValueRef a);
+
+LLVMValueRef
+lp_build_trunc(struct lp_build_context *bld,
+               LLVMValueRef a);
+
+LLVMValueRef
+lp_build_int(struct lp_build_context *bld,
+             LLVMValueRef a);
+
+LLVMValueRef
+lp_build_ifloor(struct lp_build_context *bld,
+                LLVMValueRef a);
+
+LLVMValueRef
 lp_build_sqrt(struct lp_build_context *bld,
               LLVMValueRef a);
 
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_blend.h b/src/gallium/drivers/llvmpipe/lp_bld_blend.h
index d19e18846c..da272e549f 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_blend.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_blend.h
@@ -46,7 +46,7 @@
 
 
 struct pipe_blend_state;
-union lp_type;
+struct lp_type;
 struct lp_build_context;
 
 
@@ -74,7 +74,7 @@ lp_build_blend_func(struct lp_build_context *bld,
 LLVMValueRef
 lp_build_blend_aos(LLVMBuilderRef builder,
                    const struct pipe_blend_state *blend,
-                   union lp_type type,
+                   struct lp_type type,
                    LLVMValueRef src,
                    LLVMValueRef dst,
                    LLVMValueRef const_,
@@ -84,7 +84,7 @@ lp_build_blend_aos(LLVMBuilderRef builder,
 void
 lp_build_blend_soa(LLVMBuilderRef builder,
                    const struct pipe_blend_state *blend,
-                   union lp_type type,
+                   struct lp_type type,
                    LLVMValueRef src[4],
                    LLVMValueRef dst[4],
                    LLVMValueRef const_[4],
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_blend_aos.c b/src/gallium/drivers/llvmpipe/lp_bld_blend_aos.c
index c11a9398f8..d14f468ba9 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_blend_aos.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_blend_aos.c
@@ -303,7 +303,7 @@ lp_build_blend_func(struct lp_build_context *bld,
 LLVMValueRef
 lp_build_blend_aos(LLVMBuilderRef builder,
                    const struct pipe_blend_state *blend,
-                   union lp_type type,
+                   struct lp_type type,
                    LLVMValueRef src,
                    LLVMValueRef dst,
                    LLVMValueRef const_,
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_blend_soa.c b/src/gallium/drivers/llvmpipe/lp_bld_blend_soa.c
index b92254a7d6..9511299d55 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_blend_soa.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_blend_soa.c
@@ -199,7 +199,7 @@ lp_build_blend_soa_factor(struct lp_build_blend_soa_context *bld,
 void
 lp_build_blend_soa(LLVMBuilderRef builder,
                    const struct pipe_blend_state *blend,
-                   union lp_type type,
+                   struct lp_type type,
                    LLVMValueRef src[4],
                    LLVMValueRef dst[4],
                    LLVMValueRef con[4],
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_const.c b/src/gallium/drivers/llvmpipe/lp_bld_const.c
index 21487365ea..c8eaa8c394 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_const.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_const.c
@@ -42,7 +42,7 @@
 
 
 unsigned
-lp_mantissa(union lp_type type)
+lp_mantissa(struct lp_type type)
 {
    assert(type.floating);
 
@@ -72,7 +72,7 @@ lp_mantissa(union lp_type type)
  * Same as lp_const_scale(), but in terms of shifts.
  */
 unsigned
-lp_const_shift(union lp_type type)
+lp_const_shift(struct lp_type type)
 {
    if(type.floating)
       return 0;
@@ -86,7 +86,7 @@ lp_const_shift(union lp_type type)
 
 
 unsigned
-lp_const_offset(union lp_type type)
+lp_const_offset(struct lp_type type)
 {
    if(type.floating || type.fixed)
       return 0;
@@ -104,7 +104,7 @@ lp_const_offset(union lp_type type)
  * else for the fixed points types and normalized integers.
  */
 double
-lp_const_scale(union lp_type type)
+lp_const_scale(struct lp_type type)
 {
    unsigned long long llscale;
    double dscale;
@@ -122,7 +122,7 @@ lp_const_scale(union lp_type type)
  * Minimum value representable by the type.
  */
 double
-lp_const_min(union lp_type type)
+lp_const_min(struct lp_type type)
 {
    unsigned bits;
 
@@ -158,7 +158,7 @@ lp_const_min(union lp_type type)
  * Maximum value representable by the type.
  */
 double
-lp_const_max(union lp_type type)
+lp_const_max(struct lp_type type)
 {
    unsigned bits;
 
@@ -190,7 +190,7 @@ lp_const_max(union lp_type type)
 
 
 double
-lp_const_eps(union lp_type type)
+lp_const_eps(struct lp_type type)
 {
    if (type.floating) {
       switch(type.width) {
@@ -211,7 +211,7 @@ lp_const_eps(union lp_type type)
 
 
 LLVMValueRef
-lp_build_undef(union lp_type type)
+lp_build_undef(struct lp_type type)
 {
    LLVMTypeRef vec_type = lp_build_vec_type(type);
    return LLVMGetUndef(vec_type);
@@ -219,7 +219,7 @@ lp_build_undef(union lp_type type)
                
 
 LLVMValueRef
-lp_build_zero(union lp_type type)
+lp_build_zero(struct lp_type type)
 {
    LLVMTypeRef vec_type = lp_build_vec_type(type);
    return LLVMConstNull(vec_type);
@@ -227,7 +227,7 @@ lp_build_zero(union lp_type type)
                
 
 LLVMValueRef
-lp_build_one(union lp_type type)
+lp_build_one(struct lp_type type)
 {
    LLVMTypeRef elem_type;
    LLVMValueRef elems[LP_MAX_VECTOR_LENGTH];
@@ -269,7 +269,7 @@ lp_build_one(union lp_type type)
                
 
 LLVMValueRef
-lp_build_const_scalar(union lp_type type,
+lp_build_const_scalar(struct lp_type type,
                       double val)
 {
    LLVMTypeRef elem_type = lp_build_elem_type(type);
@@ -295,7 +295,7 @@ lp_build_const_scalar(union lp_type type,
 
 
 LLVMValueRef
-lp_build_int_const_scalar(union lp_type type,
+lp_build_int_const_scalar(struct lp_type type,
                           long long val)
 {
    LLVMTypeRef elem_type = lp_build_int_elem_type(type);
@@ -312,7 +312,7 @@ lp_build_int_const_scalar(union lp_type type,
 
 
 LLVMValueRef
-lp_build_const_aos(union lp_type type, 
+lp_build_const_aos(struct lp_type type, 
                    double r, double g, double b, double a, 
                    const unsigned char *swizzle)
 {
@@ -352,8 +352,8 @@ lp_build_const_aos(union lp_type type,
 
 
 LLVMValueRef
-lp_build_const_mask_aos(union lp_type type,
-                        boolean cond[4])
+lp_build_const_mask_aos(struct lp_type type,
+                        const boolean cond[4])
 {
    LLVMTypeRef elem_type = LLVMIntType(type.width);
    LLVMValueRef masks[LP_MAX_VECTOR_LENGTH];
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_const.h b/src/gallium/drivers/llvmpipe/lp_bld_const.h
index 1934530ea3..ffb302f736 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_const.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_const.h
@@ -42,67 +42,67 @@
 #include <pipe/p_compiler.h>
 
 
-union lp_type type;
+struct lp_type type;
 
 
 unsigned
-lp_mantissa(union lp_type type);
+lp_mantissa(struct lp_type type);
 
 
 unsigned
-lp_const_shift(union lp_type type);
+lp_const_shift(struct lp_type type);
 
 
 unsigned
-lp_const_offset(union lp_type type);
+lp_const_offset(struct lp_type type);
 
 
 double
-lp_const_scale(union lp_type type);
+lp_const_scale(struct lp_type type);
 
 double
-lp_const_min(union lp_type type);
+lp_const_min(struct lp_type type);
 
 
 double
-lp_const_max(union lp_type type);
+lp_const_max(struct lp_type type);
 
 
 double
-lp_const_eps(union lp_type type);
+lp_const_eps(struct lp_type type);
 
 
 LLVMValueRef
-lp_build_undef(union lp_type type);
+lp_build_undef(struct lp_type type);
 
 
 LLVMValueRef
-lp_build_zero(union lp_type type);
+lp_build_zero(struct lp_type type);
 
 
 LLVMValueRef
-lp_build_one(union lp_type type);
+lp_build_one(struct lp_type type);
 
 
 LLVMValueRef
-lp_build_const_scalar(union lp_type type,
+lp_build_const_scalar(struct lp_type type,
                       double val);
 
 
 LLVMValueRef
-lp_build_int_const_scalar(union lp_type type,
+lp_build_int_const_scalar(struct lp_type type,
                           long long val);
 
 
 LLVMValueRef
-lp_build_const_aos(union lp_type type, 
+lp_build_const_aos(struct lp_type type, 
                    double r, double g, double b, double a, 
                    const unsigned char *swizzle);
 
 
 LLVMValueRef
-lp_build_const_mask_aos(union lp_type type,
-                        boolean cond[4]);
+lp_build_const_mask_aos(struct lp_type type,
+                        const boolean cond[4]);
 
 
 #endif /* !LP_BLD_CONST_H */
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_conv.c b/src/gallium/drivers/llvmpipe/lp_bld_conv.c
index c8954c8a34..186cac70f6 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_conv.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_conv.c
@@ -86,7 +86,7 @@
  */
 LLVMValueRef
 lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
-                                        union lp_type src_type,
+                                        struct lp_type src_type,
                                         unsigned dst_width,
                                         LLVMValueRef src)
 {
@@ -122,7 +122,7 @@ lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
       int shift = dst_width - n;
       res = LLVMBuildShl(builder, res, lp_build_int_const_scalar(src_type, shift), "");
 
-      /* Fill in the empty lower bits for added precision? */
+      /* TODO: Fill in the empty lower bits for additional precision? */
 #if 0
       {
          LLVMValueRef msb;
@@ -152,7 +152,7 @@ lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
 LLVMValueRef
 lp_build_unsigned_norm_to_float(LLVMBuilderRef builder,
                                 unsigned src_width,
-                                union lp_type dst_type,
+                                struct lp_type dst_type,
                                 LLVMValueRef src)
 {
    LLVMTypeRef vec_type = lp_build_vec_type(dst_type);
@@ -244,12 +244,12 @@ lp_build_const_pack_shuffle(unsigned n)
  * Expand the bit width.
  *
  * This will only change the number of bits the values are represented, not the
- * values themselved.
+ * values themselves.
  */
 static void
 lp_build_expand(LLVMBuilderRef builder,
-               union lp_type src_type,
-               union lp_type dst_type,
+               struct lp_type src_type,
+               struct lp_type dst_type,
                LLVMValueRef src,
                LLVMValueRef *dst, unsigned num_dsts)
 {
@@ -266,7 +266,7 @@ lp_build_expand(LLVMBuilderRef builder,
    dst[0] = src;
 
    while(src_type.width < dst_type.width) {
-      union lp_type new_type = src_type;
+      struct lp_type new_type = src_type;
       LLVMTypeRef new_vec_type;
 
       new_type.width *= 2;
@@ -314,8 +314,8 @@ lp_build_expand(LLVMBuilderRef builder,
  */
 static LLVMValueRef
 lp_build_pack2(LLVMBuilderRef builder,
-               union lp_type src_type,
-               union lp_type dst_type,
+               struct lp_type src_type,
+               struct lp_type dst_type,
                boolean clamped,
                LLVMValueRef lo,
                LLVMValueRef hi)
@@ -391,11 +391,11 @@ lp_build_pack2(LLVMBuilderRef builder,
  * TODO: Handle saturation consistently.
  */
 static LLVMValueRef
-lp_build_trunc(LLVMBuilderRef builder,
-               union lp_type src_type,
-               union lp_type dst_type,
-               boolean clamped,
-               const LLVMValueRef *src, unsigned num_srcs)
+lp_build_pack(LLVMBuilderRef builder,
+              struct lp_type src_type,
+              struct lp_type dst_type,
+              boolean clamped,
+              const LLVMValueRef *src, unsigned num_srcs)
 {
    LLVMValueRef tmp[LP_MAX_VECTOR_LENGTH];
    unsigned i;
@@ -410,7 +410,7 @@ lp_build_trunc(LLVMBuilderRef builder,
       tmp[i] = src[i];
 
    while(src_type.width > dst_type.width) {
-      union lp_type new_type = src_type;
+      struct lp_type new_type = src_type;
 
       new_type.width /= 2;
       new_type.length *= 2;
@@ -442,12 +442,12 @@ lp_build_trunc(LLVMBuilderRef builder,
  */
 void
 lp_build_conv(LLVMBuilderRef builder,
-              union lp_type src_type,
-              union lp_type dst_type,
+              struct lp_type src_type,
+              struct lp_type dst_type,
               const LLVMValueRef *src, unsigned num_srcs,
               LLVMValueRef *dst, unsigned num_dsts)
 {
-   union lp_type tmp_type;
+   struct lp_type tmp_type;
    LLVMValueRef tmp[LP_MAX_VECTOR_LENGTH];
    unsigned num_tmps;
    unsigned i;
@@ -470,7 +470,7 @@ lp_build_conv(LLVMBuilderRef builder,
     * Clamp if necessary
     */
 
-   if(src_type.value != dst_type.value) {
+   if(memcmp(&src_type, &dst_type, sizeof src_type) != 0) {
       struct lp_build_context bld;
       double src_min = lp_const_min(src_type);
       double dst_min = lp_const_min(dst_type);
@@ -565,7 +565,7 @@ lp_build_conv(LLVMBuilderRef builder,
 
    if(tmp_type.width > dst_type.width) {
       assert(num_dsts == 1);
-      tmp[0] = lp_build_trunc(builder, tmp_type, dst_type, TRUE, tmp, num_tmps);
+      tmp[0] = lp_build_pack(builder, tmp_type, dst_type, TRUE, tmp, num_tmps);
       tmp_type.width = dst_type.width;
       tmp_type.length = dst_type.length;
       num_tmps = 1;
@@ -656,8 +656,8 @@ lp_build_conv(LLVMBuilderRef builder,
  */
 void
 lp_build_conv_mask(LLVMBuilderRef builder,
-                   union lp_type src_type,
-                   union lp_type dst_type,
+                   struct lp_type src_type,
+                   struct lp_type dst_type,
                    const LLVMValueRef *src, unsigned num_srcs,
                    LLVMValueRef *dst, unsigned num_dsts)
 {
@@ -689,7 +689,7 @@ lp_build_conv_mask(LLVMBuilderRef builder,
 
    if(src_type.width > dst_type.width) {
       assert(num_dsts == 1);
-      dst[0] = lp_build_trunc(builder, src_type, dst_type, TRUE, src, num_srcs);
+      dst[0] = lp_build_pack(builder, src_type, dst_type, TRUE, src, num_srcs);
    }
    else if(src_type.width < dst_type.width) {
       assert(num_srcs == 1);
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_conv.h b/src/gallium/drivers/llvmpipe/lp_bld_conv.h
index 05c1ef2a10..ca378804d2 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_conv.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_conv.h
@@ -40,33 +40,33 @@
 #include <llvm-c/Core.h>  
 
 
-union lp_type type;
+struct lp_type type;
 
 
 LLVMValueRef
 lp_build_clamped_float_to_unsigned_norm(LLVMBuilderRef builder,
-                                        union lp_type src_type,
+                                        struct lp_type src_type,
                                         unsigned dst_width,
                                         LLVMValueRef src);
 
 LLVMValueRef
 lp_build_unsigned_norm_to_float(LLVMBuilderRef builder,
                                 unsigned src_width,
-                                union lp_type dst_type,
+                                struct lp_type dst_type,
                                 LLVMValueRef src);
 
 
 void
 lp_build_conv(LLVMBuilderRef builder,
-              union lp_type src_type,
-              union lp_type dst_type,
+              struct lp_type src_type,
+              struct lp_type dst_type,
               const LLVMValueRef *srcs, unsigned num_srcs,
               LLVMValueRef *dsts, unsigned num_dsts);
 
 void
 lp_build_conv_mask(LLVMBuilderRef builder,
-                   union lp_type src_type,
-                   union lp_type dst_type,
+                   struct lp_type src_type,
+                   struct lp_type dst_type,
                    const LLVMValueRef *src, unsigned num_srcs,
                    LLVMValueRef *dst, unsigned num_dsts);
 
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_debug.c b/src/gallium/drivers/llvmpipe/lp_bld_debug.c
index 30925b5f41..59d8f492e6 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_debug.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_debug.c
@@ -30,10 +30,27 @@
 #include <udis86.h>
 #endif
 
+#include "util/u_math.h"
 #include "util/u_debug.h"
 #include "lp_bld_debug.h"
 
 
+/**
+ * Check alignment.
+ *
+ * It is important that this check is not implemented as a macro or inlined
+ * function, as the compiler assumptions in respect to alignment of global
+ * and stack variables would often make the check a no op, defeating the
+ * whole purpose of the exercise.
+ */
+boolean
+lp_check_alignment(const void *ptr, unsigned alignment)
+{
+   assert(util_is_pot(alignment));
+   return ((uintptr_t)ptr & (alignment - 1)) == 0;
+}
+
+
 void
 lp_disassemble(const void* func)
 {
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_debug.h b/src/gallium/drivers/llvmpipe/lp_bld_debug.h
index ecdafef76d..583e6132b4 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_debug.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_debug.h
@@ -53,6 +53,10 @@ lp_build_name(LLVMValueRef val, const char *format, ...)
 }
 
 
+boolean
+lp_check_alignment(const void *ptr, unsigned alignment);
+
+
 void
 lp_disassemble(const void* func);
 
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_depth.c b/src/gallium/drivers/llvmpipe/lp_bld_depth.c
index 2cd6e6b921..21c665c4d4 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_depth.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_depth.c
@@ -71,11 +71,11 @@
 /**
  * Return a type appropriate for depth/stencil testing.
  */
-union lp_type
+struct lp_type
 lp_depth_type(const struct util_format_description *format_desc,
               unsigned length)
 {
-   union lp_type type;
+   struct lp_type type;
    unsigned swizzle;
 
    assert(format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS);
@@ -85,7 +85,7 @@ lp_depth_type(const struct util_format_description *format_desc,
    swizzle = format_desc->swizzle[0];
    assert(swizzle < 4);
 
-   type.value = 0;
+   memset(&type, 0, sizeof type);
    type.width = format_desc->block.bits;
 
    if(format_desc->channel[swizzle].type == UTIL_FORMAT_TYPE_FLOAT) {
@@ -114,7 +114,7 @@ lp_depth_type(const struct util_format_description *format_desc,
 void
 lp_build_depth_test(LLVMBuilderRef builder,
                     const struct pipe_depth_state *state,
-                    union lp_type type,
+                    struct lp_type type,
                     const struct util_format_description *format_desc,
                     struct lp_build_mask_context *mask,
                     LLVMValueRef src,
@@ -179,12 +179,13 @@ lp_build_depth_test(LLVMBuilderRef builder,
       padding_right = 0;
       for(chan = 0; chan < z_swizzle; ++chan)
          padding_right += format_desc->channel[chan].size;
-      padding_left = format_desc->block.bits - format_desc->channel[z_swizzle].size;
+      padding_left = format_desc->block.bits -
+                     (padding_right + format_desc->channel[z_swizzle].size);
 
       if(padding_left || padding_right) {
-         const long long mask_left = ((long long)1 << (format_desc->block.bits - padding_left)) - 1;
-         const long long mask_right = ((long long)1 << (padding_right)) - 1;
-         z_bitmask = lp_build_int_const_scalar(type, mask_left & mask_right);
+         const unsigned long long mask_left = ((unsigned long long)1 << (format_desc->block.bits - padding_left)) - 1;
+         const unsigned long long mask_right = ((unsigned long long)1 << (padding_right)) - 1;
+         z_bitmask = lp_build_int_const_scalar(type, mask_left ^ mask_right);
       }
 
       if(padding_left)
@@ -210,5 +211,6 @@ lp_build_depth_test(LLVMBuilderRef builder,
       LLVMBuildStore(builder, dst, dst_ptr);
    }
 
+   /* FIXME */
    assert(!state->occlusion_count);
 }
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_depth.h b/src/gallium/drivers/llvmpipe/lp_bld_depth.h
index 5d2e042fcc..79d6981bb5 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_depth.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_depth.h
@@ -41,11 +41,11 @@
  
 struct pipe_depth_state;
 struct util_format_description;
-union lp_type;
+struct lp_type;
 struct lp_build_mask_context;
 
 
-union lp_type
+struct lp_type
 lp_depth_type(const struct util_format_description *format_desc,
               unsigned length);
 
@@ -53,7 +53,7 @@ lp_depth_type(const struct util_format_description *format_desc,
 void
 lp_build_depth_test(LLVMBuilderRef builder,
                     const struct pipe_depth_state *state,
-                    union lp_type type,
+                    struct lp_type type,
                     const struct util_format_description *format_desc,
                     struct lp_build_mask_context *mask,
                     LLVMValueRef src,
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_flow.c b/src/gallium/drivers/llvmpipe/lp_bld_flow.c
index 9d99e1a9d9..dcc25fbff8 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_flow.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_flow.c
@@ -32,59 +32,261 @@
  */
 
 #include "util/u_debug.h"
+#include "util/u_memory.h"
 
 #include "lp_bld_type.h"
 #include "lp_bld_flow.h"
 
 
+#define LP_BUILD_FLOW_MAX_VARIABLES 32
+#define LP_BUILD_FLOW_MAX_DEPTH 32
+
+
+/**
+ * Enumeration of all possible flow constructs.
+ */
+enum lp_build_flow_construct_kind {
+   lP_BUILD_FLOW_SCOPE,
+   LP_BUILD_FLOW_SKIP,
+};
+
+
+/**
+ * Variable declaration scope.
+ */
+struct lp_build_flow_scope
+{
+   /** Number of variables declared in this scope */
+   unsigned num_variables;
+};
+
+
+/**
+ * Early exit. Useful to skip to the end of a function or block when
+ * the execution mask becomes zero or when there is an error condition.
+ */
+struct lp_build_flow_skip
+{
+   /** Block to skip to */
+   LLVMBasicBlockRef block;
+
+   /** Number of variables declared at the beginning */
+   unsigned num_variables;
+
+   LLVMValueRef *phi;
+};
+
+
+/**
+ * Union of all possible flow constructs' data
+ */
+union lp_build_flow_construct_data
+{
+   struct lp_build_flow_scope scope;
+   struct lp_build_flow_skip skip;
+};
+
+
+/**
+ * Element of the flow construct stack.
+ */
+struct lp_build_flow_construct
+{
+   enum lp_build_flow_construct_kind kind;
+   union lp_build_flow_construct_data data;
+};
+
+
+/**
+ * All necessary data to generate LLVM control flow constructs.
+ *
+ * Besides keeping track of the control flow construct themselves we also
+ * need to keep track of variables in order to generate SSA Phi values.
+ */
+struct lp_build_flow_context
+{
+   LLVMBuilderRef builder;
+
+   /**
+    * Control flow stack.
+    */
+   struct lp_build_flow_construct constructs[LP_BUILD_FLOW_MAX_DEPTH];
+   unsigned num_constructs;
+
+   /**
+    * Variable stack
+    */
+   LLVMValueRef *variables[LP_BUILD_FLOW_MAX_VARIABLES];
+   unsigned num_variables;
+};
+
+
+struct lp_build_flow_context *
+lp_build_flow_create(LLVMBuilderRef builder)
+{
+   struct lp_build_flow_context *flow;
+
+   flow = CALLOC_STRUCT(lp_build_flow_context);
+   if(!flow)
+      return NULL;
+
+   flow->builder = builder;
+
+   return flow;
+}
+
+
 void
-lp_build_mask_begin(struct lp_build_mask_context *mask,
-                    LLVMBuilderRef builder,
-                    union lp_type type,
-                    LLVMValueRef value)
+lp_build_flow_destroy(struct lp_build_flow_context *flow)
 {
-   memset(mask, 0, sizeof *mask);
+   assert(flow->num_constructs == 0);
+   assert(flow->num_variables == 0);
+   FREE(flow);
+}
 
-   mask->builder = builder;
-   mask->reg_type = LLVMIntType(type.width * type.length);
-   mask->value = value;
+
+static union lp_build_flow_construct_data *
+lp_build_flow_push(struct lp_build_flow_context *flow,
+                   enum lp_build_flow_construct_kind kind)
+{
+   assert(flow->num_constructs < LP_BUILD_FLOW_MAX_DEPTH);
+   if(flow->num_constructs >= LP_BUILD_FLOW_MAX_DEPTH)
+      return NULL;
+
+   flow->constructs[flow->num_constructs].kind = kind;
+   return &flow->constructs[flow->num_constructs++].data;
+}
+
+
+static union lp_build_flow_construct_data *
+lp_build_flow_peek(struct lp_build_flow_context *flow,
+                   enum lp_build_flow_construct_kind kind)
+{
+   assert(flow->num_constructs);
+   if(!flow->num_constructs)
+      return NULL;
+
+   assert(flow->constructs[flow->num_constructs - 1].kind == kind);
+   if(flow->constructs[flow->num_constructs - 1].kind != kind)
+      return NULL;
+
+   return &flow->constructs[flow->num_constructs - 1].data;
 }
 
 
+static union lp_build_flow_construct_data *
+lp_build_flow_pop(struct lp_build_flow_context *flow,
+                  enum lp_build_flow_construct_kind kind)
+{
+   assert(flow->num_constructs);
+   if(!flow->num_constructs)
+      return NULL;
+
+   assert(flow->constructs[flow->num_constructs - 1].kind == kind);
+   if(flow->constructs[flow->num_constructs - 1].kind != kind)
+      return NULL;
+
+   return &flow->constructs[--flow->num_constructs].data;
+}
+
+
+/**
+ * Begin a variable scope.
+ *
+ *
+ */
 void
-lp_build_mask_update(struct lp_build_mask_context *mask,
-                     LLVMValueRef value)
+lp_build_flow_scope_begin(struct lp_build_flow_context *flow)
 {
+   struct lp_build_flow_scope *scope;
 
-   LLVMValueRef cond;
-   LLVMBasicBlockRef current_block;
-   LLVMBasicBlockRef next_block;
-   LLVMBasicBlockRef new_block;
+   scope = &lp_build_flow_push(flow, lP_BUILD_FLOW_SCOPE)->scope;
+   if(!scope)
+      return;
 
-   if(mask->value)
-      mask->value = LLVMBuildAnd(mask->builder, mask->value, value, "");
-   else
-      mask->value = value;
+   scope->num_variables = 0;
+}
 
-   /* FIXME: disabled until we have proper control flow helpers */
-#if 0
-   cond = LLVMBuildICmp(mask->builder,
-                        LLVMIntEQ,
-                        LLVMBuildBitCast(mask->builder, mask->value, mask->reg_type, ""),
-                        LLVMConstNull(mask->reg_type),
-                        "");
 
-   current_block = LLVMGetInsertBlock(mask->builder);
+/**
+ * Declare a variable.
+ *
+ * A variable is a named entity which can have different LLVMValueRef's at
+ * different points of the program. This is relevant for control flow because
+ * when there are mutiple branches to a same location we need to replace
+ * the variable's value with a Phi function as explained in
+ * http://en.wikipedia.org/wiki/Static_single_assignment_form .
+ *
+ * We keep track of variables by keeping around a pointer to where their
+ * current.
+ *
+ * There are a few cautions to observe:
+ *
+ * - Variable's value must not be NULL. If there is no initial value then
+ *   LLVMGetUndef() should be used.
+ *
+ * - Variable's value must be kept up-to-date. If the variable is going to be
+ *   modified by a function then a pointer should be passed so that its value
+ *   is accurate. Failure to do this will cause some of the variables'
+ *   transient values to be lost, leading to wrong results.
+ *
+ * - A program should be written from top to bottom, by always appending
+ *   instructions to the bottom with a single LLVMBuilderRef. Inserting and/or
+ *   modifying existing statements will most likely lead to wrong results.
+ *
+ */
+void
+lp_build_flow_scope_declare(struct lp_build_flow_context *flow,
+                            LLVMValueRef *variable)
+{
+   struct lp_build_flow_scope *scope;
+
+   scope = &lp_build_flow_peek(flow, lP_BUILD_FLOW_SCOPE)->scope;
+   if(!scope)
+      return;
 
-   if(!mask->skip_block) {
-      LLVMValueRef function = LLVMGetBasicBlockParent(current_block);
-      mask->skip_block = LLVMAppendBasicBlock(function, "skip");
+   assert(*variable);
+   if(!*variable)
+      return;
+
+   assert(flow->num_variables < LP_BUILD_FLOW_MAX_VARIABLES);
+   if(flow->num_variables >= LP_BUILD_FLOW_MAX_VARIABLES)
+      return;
+
+   flow->variables[flow->num_variables++] = variable;
+   ++scope->num_variables;
+}
+
+
+void
+lp_build_flow_scope_end(struct lp_build_flow_context *flow)
+{
+   struct lp_build_flow_scope *scope;
+
+   scope = &lp_build_flow_pop(flow, lP_BUILD_FLOW_SCOPE)->scope;
+   if(!scope)
+      return;
 
-      mask->phi = LLVMBuildPhi(mask->builder, LLVMTypeOf(mask->value), "");
+   assert(flow->num_variables >= scope->num_variables);
+   if(flow->num_variables < scope->num_variables) {
+      flow->num_variables = 0;
+      return;
    }
 
+   flow->num_variables -= scope->num_variables;
+}
+
+
+static LLVMBasicBlockRef
+lp_build_flow_insert_block(struct lp_build_flow_context *flow)
+{
+   LLVMBasicBlockRef current_block;
+   LLVMBasicBlockRef next_block;
+   LLVMBasicBlockRef new_block;
+
+   current_block = LLVMGetInsertBlock(flow->builder);
+
    next_block = LLVMGetNextBasicBlock(current_block);
-   assert(next_block);
    if(next_block) {
       new_block = LLVMInsertBasicBlock(next_block, "");
    }
@@ -93,30 +295,148 @@ lp_build_mask_update(struct lp_build_mask_context *mask,
       new_block = LLVMAppendBasicBlock(function, "");
    }
 
-   LLVMAddIncoming(mask->phi, &mask->value, &current_block, 1);
-   LLVMBuildCondBr(mask->builder, cond, mask->skip_block, new_block);
+   return new_block;
+}
+
+void
+lp_build_flow_skip_begin(struct lp_build_flow_context *flow)
+{
+   struct lp_build_flow_skip *skip;
+   LLVMBuilderRef builder;
+   unsigned i;
+
+   skip = &lp_build_flow_push(flow, LP_BUILD_FLOW_SKIP)->skip;
+   if(!skip)
+      return;
+
+   skip->block = lp_build_flow_insert_block(flow);
+   skip->num_variables = flow->num_variables;
+   if(!skip->num_variables) {
+      skip->phi = NULL;
+      return;
+   }
 
-   LLVMPositionBuilderAtEnd(mask->builder, new_block);
-#endif
+   skip->phi = MALLOC(skip->num_variables * sizeof *skip->phi);
+   if(!skip->phi) {
+      skip->num_variables = 0;
+      return;
+   }
+
+   builder = LLVMCreateBuilder();
+   LLVMPositionBuilderAtEnd(builder, skip->block);
+
+   for(i = 0; i < skip->num_variables; ++i)
+      skip->phi[i] = LLVMBuildPhi(builder, LLVMTypeOf(*flow->variables[i]), "");
+
+   LLVMDisposeBuilder(builder);
 }
 
 
-LLVMValueRef
-lp_build_mask_end(struct lp_build_mask_context *mask)
+void
+lp_build_flow_skip_cond_break(struct lp_build_flow_context *flow,
+                              LLVMValueRef cond)
+{
+   struct lp_build_flow_skip *skip;
+   LLVMBasicBlockRef current_block;
+   LLVMBasicBlockRef new_block;
+   unsigned i;
+
+   skip = &lp_build_flow_peek(flow, LP_BUILD_FLOW_SKIP)->skip;
+   if(!skip)
+      return;
+
+   current_block = LLVMGetInsertBlock(flow->builder);
+
+   new_block = lp_build_flow_insert_block(flow);
+
+   for(i = 0; i < skip->num_variables; ++i) {
+      assert(*flow->variables[i]);
+      LLVMAddIncoming(skip->phi[i], flow->variables[i], &current_block, 1);
+   }
+
+   LLVMBuildCondBr(flow->builder, cond, skip->block, new_block);
+
+   LLVMPositionBuilderAtEnd(flow->builder, new_block);
+ }
+
+
+void
+lp_build_flow_skip_end(struct lp_build_flow_context *flow)
 {
-   if(mask->skip_block) {
-      LLVMBasicBlockRef current_block = LLVMGetInsertBlock(mask->builder);
+   struct lp_build_flow_skip *skip;
+   LLVMBasicBlockRef current_block;
+   unsigned i;
 
-      LLVMAddIncoming(mask->phi, &mask->value, &current_block, 1);
-      LLVMBuildBr(mask->builder, mask->skip_block);
+   skip = &lp_build_flow_pop(flow, LP_BUILD_FLOW_SKIP)->skip;
+   if(!skip)
+      return;
 
-      LLVMPositionBuilderAtEnd(mask->builder, mask->skip_block);
+   current_block = LLVMGetInsertBlock(flow->builder);
 
-      mask->value = mask->phi;
-      mask->phi = NULL;
-      mask->skip_block = NULL;
+   for(i = 0; i < skip->num_variables; ++i) {
+      assert(*flow->variables[i]);
+      LLVMAddIncoming(skip->phi[i], flow->variables[i], &current_block, 1);
+      *flow->variables[i] = skip->phi[i];
    }
 
+   LLVMBuildBr(flow->builder, skip->block);
+   LLVMPositionBuilderAtEnd(flow->builder, skip->block);
+
+   FREE(skip->phi);
+}
+
+
+static void
+lp_build_mask_check(struct lp_build_mask_context *mask)
+{
+   LLVMBuilderRef builder = mask->flow->builder;
+   LLVMValueRef cond;
+
+   cond = LLVMBuildICmp(builder,
+                        LLVMIntEQ,
+                        LLVMBuildBitCast(builder, mask->value, mask->reg_type, ""),
+                        LLVMConstNull(mask->reg_type),
+                        "");
+
+   lp_build_flow_skip_cond_break(mask->flow, cond);
+}
+
+
+void
+lp_build_mask_begin(struct lp_build_mask_context *mask,
+                    struct lp_build_flow_context *flow,
+                    struct lp_type type,
+                    LLVMValueRef value)
+{
+   memset(mask, 0, sizeof *mask);
+
+   mask->flow = flow;
+   mask->reg_type = LLVMIntType(type.width * type.length);
+   mask->value = value;
+
+   lp_build_flow_scope_begin(flow);
+   lp_build_flow_scope_declare(flow, &mask->value);
+   lp_build_flow_skip_begin(flow);
+
+   lp_build_mask_check(mask);
+}
+
+
+void
+lp_build_mask_update(struct lp_build_mask_context *mask,
+                     LLVMValueRef value)
+{
+   mask->value = LLVMBuildAnd( mask->flow->builder, mask->value, value, "");
+
+   lp_build_mask_check(mask);
+}
+
+
+LLVMValueRef
+lp_build_mask_end(struct lp_build_mask_context *mask)
+{
+   lp_build_flow_skip_end(mask->flow);
+   lp_build_flow_scope_end(mask->flow);
    return mask->value;
 }
 
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_flow.h b/src/gallium/drivers/llvmpipe/lp_bld_flow.h
index 1b634ff038..e61999ff06 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_flow.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_flow.h
@@ -38,27 +38,53 @@
 #include <llvm-c/Core.h>  
 
 
-union lp_type;
+struct lp_type;
+
+
+struct lp_build_flow_context;
+
+
+struct lp_build_flow_context *
+lp_build_flow_create(LLVMBuilderRef builder);
+
+void
+lp_build_flow_destroy(struct lp_build_flow_context *flow);
+
+void
+lp_build_flow_scope_begin(struct lp_build_flow_context *flow);
+
+void
+lp_build_flow_scope_declare(struct lp_build_flow_context *flow,
+                            LLVMValueRef *variable);
+
+void
+lp_build_flow_scope_end(struct lp_build_flow_context *flow);
+
+void
+lp_build_flow_skip_begin(struct lp_build_flow_context *flow);
+
+void
+lp_build_flow_skip_cond_break(struct lp_build_flow_context *flow,
+                              LLVMValueRef cond);
+
+void
+lp_build_flow_skip_end(struct lp_build_flow_context *flow);
 
 
 struct lp_build_mask_context
 {
-   LLVMBuilderRef builder;
+   struct lp_build_flow_context *flow;
 
    LLVMTypeRef reg_type;
 
    LLVMValueRef value;
-
-   LLVMValueRef phi;
-
-   LLVMBasicBlockRef skip_block;
 };
 
 
 void
 lp_build_mask_begin(struct lp_build_mask_context *mask,
-                    LLVMBuilderRef builder,
-                    union lp_type type,
+                    struct lp_build_flow_context *flow,
+                    struct lp_type type,
                     LLVMValueRef value);
 
 /**
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_format.h b/src/gallium/drivers/llvmpipe/lp_bld_format.h
index 01c8a752d1..6d3f692619 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_format.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_format.h
@@ -31,21 +31,15 @@
 
 /**
  * @file
- * LLVM IR building helpers interfaces.
- *
- * We use LLVM-C bindings for now. They are not documented, but follow the C++
- * interfaces very closely, and appear to be complete enough for code
- * genration. See
- * http://npcontemplation.blogspot.com/2008/06/secret-of-llvm-c-bindings.html
- * for a standalone example.
+ * Pixel format helpers.
  */
 
 #include <llvm-c/Core.h>  
- 
-#include "pipe/p_format.h"
 
+#include "pipe/p_format.h"
 
-union lp_type;
+struct util_format_description;
+struct lp_type;
 
 
 /**
@@ -56,9 +50,9 @@ union lp_type;
  * @return RGBA in a 4 floats vector.
  */
 LLVMValueRef
-lp_build_unpack_rgba(LLVMBuilderRef builder,
-                     enum pipe_format format, 
-                     LLVMValueRef packed);
+lp_build_unpack_rgba_aos(LLVMBuilderRef builder,
+                         enum pipe_format format,
+                         LLVMValueRef packed);
 
 
 /**
@@ -67,9 +61,9 @@ lp_build_unpack_rgba(LLVMBuilderRef builder,
  * @param rgba 4 float vector with the unpacked components.
  */
 LLVMValueRef
-lp_build_pack_rgba(LLVMBuilderRef builder,
-                   enum pipe_format format,
-                   LLVMValueRef rgba);
+lp_build_pack_rgba_aos(LLVMBuilderRef builder,
+                       enum pipe_format format,
+                       LLVMValueRef rgba);
 
 
 /**
@@ -81,9 +75,9 @@ lp_build_pack_rgba(LLVMBuilderRef builder,
  * @return RGBA in a 4 floats vector.
  */
 LLVMValueRef
-lp_build_load_rgba(LLVMBuilderRef builder,
-                   enum pipe_format format, 
-                   LLVMValueRef ptr);
+lp_build_load_rgba_aos(LLVMBuilderRef builder,
+                       enum pipe_format format,
+                       LLVMValueRef ptr);
 
 
 /**
@@ -92,10 +86,34 @@ lp_build_load_rgba(LLVMBuilderRef builder,
  * @param rgba 4 float vector with the unpacked components.
  */
 void 
-lp_build_store_rgba(LLVMBuilderRef builder,
-                    enum pipe_format format,
-                    LLVMValueRef ptr,
-                    LLVMValueRef rgba);
+lp_build_store_rgba_aos(LLVMBuilderRef builder,
+                        enum pipe_format format,
+                        LLVMValueRef ptr,
+                        LLVMValueRef rgba);
 
+LLVMValueRef
+lp_build_gather(LLVMBuilderRef builder,
+                unsigned length,
+                unsigned src_width,
+                unsigned dst_width,
+                LLVMValueRef base_ptr,
+                LLVMValueRef offsets);
+
+
+void
+lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
+                         const struct util_format_description *format_desc,
+                         struct lp_type type,
+                         LLVMValueRef packed,
+                         LLVMValueRef *rgba);
+
+
+void
+lp_build_load_rgba_soa(LLVMBuilderRef builder,
+                       const struct util_format_description *format_desc,
+                       struct lp_type type,
+                       LLVMValueRef base_ptr,
+                       LLVMValueRef offsets,
+                       LLVMValueRef *rgba);
 
 #endif /* !LP_BLD_H */
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_format_aos.c b/src/gallium/drivers/llvmpipe/lp_bld_format_aos.c
index dcbc0076c7..b9b5d84bed 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_format_aos.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_format_aos.c
@@ -32,9 +32,9 @@
 
 
 LLVMValueRef
-lp_build_unpack_rgba(LLVMBuilderRef builder,
-                     enum pipe_format format,
-                     LLVMValueRef packed)
+lp_build_unpack_rgba_aos(LLVMBuilderRef builder,
+                         enum pipe_format format,
+                         LLVMValueRef packed)
 {
    const struct util_format_description *desc;
    LLVMTypeRef type;
@@ -152,9 +152,9 @@ lp_build_unpack_rgba(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_pack_rgba(LLVMBuilderRef builder,
-                   enum pipe_format format,
-                   LLVMValueRef rgba)
+lp_build_pack_rgba_aos(LLVMBuilderRef builder,
+                       enum pipe_format format,
+                       LLVMValueRef rgba)
 {
    const struct util_format_description *desc;
    LLVMTypeRef type;
@@ -250,9 +250,9 @@ lp_build_pack_rgba(LLVMBuilderRef builder,
 
 
 LLVMValueRef
-lp_build_load_rgba(LLVMBuilderRef builder,
-                   enum pipe_format format,
-                   LLVMValueRef ptr)
+lp_build_load_rgba_aos(LLVMBuilderRef builder,
+                       enum pipe_format format,
+                       LLVMValueRef ptr)
 {
    const struct util_format_description *desc;
    LLVMTypeRef type;
@@ -272,15 +272,15 @@ lp_build_load_rgba(LLVMBuilderRef builder,
 
    packed = LLVMBuildLoad(builder, ptr, "");
 
-   return lp_build_unpack_rgba(builder, format, packed);
+   return lp_build_unpack_rgba_aos(builder, format, packed);
 }
 
 
 void
-lp_build_store_rgba(LLVMBuilderRef builder,
-                    enum pipe_format format,
-                    LLVMValueRef ptr,
-                    LLVMValueRef rgba)
+lp_build_store_rgba_aos(LLVMBuilderRef builder,
+                        enum pipe_format format,
+                        LLVMValueRef ptr,
+                        LLVMValueRef rgba)
 {
    const struct util_format_description *desc;
    LLVMTypeRef type;
@@ -294,7 +294,7 @@ lp_build_store_rgba(LLVMBuilderRef builder,
 
    type = LLVMIntType(desc->block.bits);
 
-   packed = lp_build_pack_rgba(builder, format, rgba);
+   packed = lp_build_pack_rgba_aos(builder, format, rgba);
 
    ptr = LLVMBuildBitCast(builder, ptr, LLVMPointerType(type, 0), "");
 
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_format_soa.c b/src/gallium/drivers/llvmpipe/lp_bld_format_soa.c
new file mode 100644
index 0000000000..b5ff434e1a
--- /dev/null
+++ b/src/gallium/drivers/llvmpipe/lp_bld_format_soa.c
@@ -0,0 +1,208 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
+ *
+ **************************************************************************/
+
+
+#include "util/u_format.h"
+
+#include "lp_bld_type.h"
+#include "lp_bld_const.h"
+#include "lp_bld_conv.h"
+#include "lp_bld_format.h"
+
+
+/**
+ * Gather elements from scatter positions in memory into a single vector.
+ *
+ * @param src_width src element width
+ * @param dst_width result element width (source will be expanded to fit)
+ * @param length length of the offsets,
+ * @param base_ptr base pointer, should be a i8 pointer type.
+ * @param offsets vector with offsets
+ */
+LLVMValueRef
+lp_build_gather(LLVMBuilderRef builder,
+                unsigned length,
+                unsigned src_width,
+                unsigned dst_width,
+                LLVMValueRef base_ptr,
+                LLVMValueRef offsets)
+{
+   LLVMTypeRef src_type = LLVMIntType(src_width);
+   LLVMTypeRef src_ptr_type = LLVMPointerType(src_type, 0);
+   LLVMTypeRef dst_elem_type = LLVMIntType(dst_width);
+   LLVMTypeRef dst_vec_type = LLVMVectorType(dst_elem_type, length);
+   LLVMValueRef res;
+   unsigned i;
+
+   res = LLVMGetUndef(dst_vec_type);
+   for(i = 0; i < length; ++i) {
+      LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+      LLVMValueRef elem_offset;
+      LLVMValueRef elem_ptr;
+      LLVMValueRef elem;
+
+      elem_offset = LLVMBuildExtractElement(builder, offsets, index, "");
+      elem_ptr = LLVMBuildGEP(builder, base_ptr, &elem_offset, 1, "");
+      elem_ptr = LLVMBuildBitCast(builder, elem_ptr, src_ptr_type, "");
+      elem = LLVMBuildLoad(builder, elem_ptr, "");
+
+      assert(src_width <= dst_width);
+      if(src_width > dst_width)
+         elem = LLVMBuildTrunc(builder, elem, dst_elem_type, "");
+      if(src_width < dst_width)
+         elem = LLVMBuildZExt(builder, elem, dst_elem_type, "");
+
+      res = LLVMBuildInsertElement(builder, res, elem, index, "");
+   }
+
+   return res;
+}
+
+
+static LLVMValueRef
+lp_build_format_swizzle(struct lp_type type,
+                        const LLVMValueRef *inputs,
+                        enum util_format_swizzle swizzle)
+{
+   switch (swizzle) {
+   case UTIL_FORMAT_SWIZZLE_X:
+   case UTIL_FORMAT_SWIZZLE_Y:
+   case UTIL_FORMAT_SWIZZLE_Z:
+   case UTIL_FORMAT_SWIZZLE_W:
+      return inputs[swizzle];
+   case UTIL_FORMAT_SWIZZLE_0:
+      return lp_build_zero(type);
+   case UTIL_FORMAT_SWIZZLE_1:
+      return lp_build_one(type);
+   case UTIL_FORMAT_SWIZZLE_NONE:
+      return lp_build_undef(type);
+   default:
+      assert(0);
+      return lp_build_undef(type);
+   }
+}
+
+
+void
+lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
+                         const struct util_format_description *format_desc,
+                         struct lp_type type,
+                         LLVMValueRef packed,
+                         LLVMValueRef *rgba)
+{
+   LLVMValueRef inputs[4];
+   unsigned start;
+   unsigned chan;
+
+   /* FIXME: Support more formats */
+   assert(format_desc->layout == UTIL_FORMAT_LAYOUT_ARITH);
+   assert(format_desc->block.width == 1);
+   assert(format_desc->block.height == 1);
+   assert(format_desc->block.bits <= 32);
+
+   /* Decode the input vector components */
+   start = 0;
+   for (chan = 0; chan < 4; ++chan) {
+      unsigned width = format_desc->channel[chan].size;
+      unsigned stop = start + width;
+      LLVMValueRef input;
+
+      input = packed;
+
+      switch(format_desc->channel[chan].type) {
+      case UTIL_FORMAT_TYPE_VOID:
+         input = NULL;
+         break;
+
+      case UTIL_FORMAT_TYPE_UNSIGNED:
+         if(type.floating) {
+            if(start)
+               input = LLVMBuildLShr(builder, input, lp_build_int_const_scalar(type, start), "");
+            if(stop < format_desc->block.bits) {
+               unsigned mask = ((unsigned long long)1 << width) - 1;
+               input = LLVMBuildAnd(builder, input, lp_build_int_const_scalar(type, mask), "");
+            }
+
+            if(format_desc->channel[chan].normalized)
+               input = lp_build_unsigned_norm_to_float(builder, width, type, input);
+            else
+               input = LLVMBuildFPToSI(builder, input, lp_build_vec_type(type), "");
+         }
+         else {
+            /* FIXME */
+            assert(0);
+            input = lp_build_undef(type);
+         }
+         break;
+
+      default:
+         /* fall through */
+         input = lp_build_undef(type);
+         break;
+      }
+
+      inputs[chan] = input;
+
+      start = stop;
+   }
+
+   if(format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS) {
+      enum util_format_swizzle swizzle = format_desc->swizzle[0];
+      LLVMValueRef depth = lp_build_format_swizzle(type, inputs, swizzle);
+      rgba[2] = rgba[1] = rgba[0] = depth;
+      rgba[3] = lp_build_one(type);
+   }
+   else {
+      for (chan = 0; chan < 4; ++chan) {
+         enum util_format_swizzle swizzle = format_desc->swizzle[chan];
+         rgba[chan] = lp_build_format_swizzle(type, inputs, swizzle);
+      }
+   }
+}
+
+
+void
+lp_build_load_rgba_soa(LLVMBuilderRef builder,
+                       const struct util_format_description *format_desc,
+                       struct lp_type type,
+                       LLVMValueRef base_ptr,
+                       LLVMValueRef offsets,
+                       LLVMValueRef *rgba)
+{
+   LLVMValueRef packed;
+
+   assert(format_desc->layout == UTIL_FORMAT_LAYOUT_ARITH);
+   assert(format_desc->block.width == 1);
+   assert(format_desc->block.height == 1);
+   assert(format_desc->block.bits <= 32);
+
+   packed = lp_build_gather(builder,
+                            type.length, format_desc->block.bits, type.width,
+                            base_ptr, offsets);
+
+   lp_build_unpack_rgba_soa(builder, format_desc, type, packed, rgba);
+}
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_interp.c b/src/gallium/drivers/llvmpipe/lp_bld_interp.c
index cfe20a0d75..338dbca6d1 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_interp.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_interp.c
@@ -292,7 +292,7 @@ void
 lp_build_interp_soa_init(struct lp_build_interp_soa_context *bld,
                          const struct tgsi_token *tokens,
                          LLVMBuilderRef builder,
-                         union lp_type type,
+                         struct lp_type type,
                          LLVMValueRef a0_ptr,
                          LLVMValueRef dadx_ptr,
                          LLVMValueRef dady_ptr,
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_interp.h b/src/gallium/drivers/llvmpipe/lp_bld_interp.h
index 9194f6233a..9c57a10879 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_interp.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_interp.h
@@ -83,7 +83,7 @@ void
 lp_build_interp_soa_init(struct lp_build_interp_soa_context *bld,
                          const struct tgsi_token *tokens,
                          LLVMBuilderRef builder,
-                         union lp_type type,
+                         struct lp_type type,
                          LLVMValueRef a0_ptr,
                          LLVMValueRef dadx_ptr,
                          LLVMValueRef dady_ptr,
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_logic.c b/src/gallium/drivers/llvmpipe/lp_bld_logic.c
index 8631efd6c3..6b6f820769 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_logic.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_logic.c
@@ -45,7 +45,7 @@ lp_build_cmp(struct lp_build_context *bld,
              LLVMValueRef a,
              LLVMValueRef b)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMTypeRef vec_type = lp_build_vec_type(type);
    LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
    LLVMValueRef zeros = LLVMConstNull(int_vec_type);
@@ -301,7 +301,7 @@ lp_build_select(struct lp_build_context *bld,
                 LLVMValueRef a,
                 LLVMValueRef b)
 {
-   union lp_type type = bld->type;
+   struct lp_type type = bld->type;
    LLVMValueRef res;
 
    if(a == b)
@@ -313,8 +313,6 @@ lp_build_select(struct lp_build_context *bld,
       b = LLVMBuildBitCast(bld->builder, b, int_vec_type, "");
    }
 
-   /* TODO: On SSE4 we could do this with a single instruction -- PBLENDVB */
-
    a = LLVMBuildAnd(bld->builder, a, mask, "");
 
    /* This often gets translated to PANDN, but sometimes the NOT is
@@ -339,9 +337,9 @@ LLVMValueRef
 lp_build_select_aos(struct lp_build_context *bld,
                     LLVMValueRef a,
                     LLVMValueRef b,
-                    boolean cond[4])
+                    const boolean cond[4])
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    const unsigned n = type.length;
    unsigned i, j;
 
@@ -376,9 +374,9 @@ lp_build_select_aos(struct lp_build_context *bld,
 
       return LLVMBuildShuffleVector(bld->builder, a, b, LLVMConstVector(shuffles, n), "");
    }
+   else {
 #if 0
-   else if(0) {
-      /* FIXME: Unfortunately select of vectors do not work */
+      /* XXX: Unfortunately select of vectors do not work */
       /* Use a select */
       LLVMTypeRef elem_type = LLVMInt1Type();
       LLVMValueRef cond[LP_MAX_VECTOR_LENGTH];
@@ -388,10 +386,9 @@ lp_build_select_aos(struct lp_build_context *bld,
             cond[j + i] = LLVMConstInt(elem_type, cond[i] ? 1 : 0, 0);
 
       return LLVMBuildSelect(bld->builder, LLVMConstVector(cond, n), a, b, "");
-   }
-#endif
-   else {
+#else
       LLVMValueRef mask = lp_build_const_mask_aos(type, cond);
       return lp_build_select(bld, mask, a, b);
+#endif
    }
 }
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_logic.h b/src/gallium/drivers/llvmpipe/lp_bld_logic.h
index 29b9e1c45b..a4ee7723b5 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_logic.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_logic.h
@@ -42,7 +42,7 @@
 #include "pipe/p_defines.h" /* For PIPE_FUNC_xxx */
 
 
-union lp_type type;
+struct lp_type type;
 struct lp_build_context;
 
 
@@ -66,7 +66,7 @@ LLVMValueRef
 lp_build_select_aos(struct lp_build_context *bld,
                     LLVMValueRef a,
                     LLVMValueRef b,
-                    boolean cond[4]);
+                    const boolean cond[4]);
 
 
 #endif /* !LP_BLD_LOGIC_H */
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_sample.h b/src/gallium/drivers/llvmpipe/lp_bld_sample.h
new file mode 100644
index 0000000000..403d0e4836
--- /dev/null
+++ b/src/gallium/drivers/llvmpipe/lp_bld_sample.h
@@ -0,0 +1,135 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * Texture sampling.
+ *
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+
+#ifndef LP_BLD_SAMPLE_H
+#define LP_BLD_SAMPLE_H
+
+
+#include <llvm-c/Core.h>
+
+struct pipe_texture;
+struct pipe_sampler_state;
+struct lp_type;
+
+
+/**
+ * Sampler static state.
+ *
+ * These are the bits of state from pipe_texture and pipe_sampler_state that
+ * are embedded in the generated code.
+ */
+struct lp_sampler_static_state
+{
+   /* pipe_texture's state */
+   enum pipe_format format;
+   unsigned target:2;
+   unsigned pot_width:1;
+   unsigned pot_height:1;
+   unsigned pot_depth:1;
+
+   /* pipe_sampler_state's state */
+   unsigned wrap_s:3;
+   unsigned wrap_t:3;
+   unsigned wrap_r:3;
+   unsigned min_img_filter:2;
+   unsigned min_mip_filter:2;
+   unsigned mag_img_filter:2;
+   unsigned compare_mode:1;
+   unsigned compare_func:3;
+   unsigned normalized_coords:1;
+   unsigned prefilter:4;
+};
+
+
+/**
+ * Sampler dynamic state.
+ *
+ * These are the bits of state from pipe_texture and pipe_sampler_state that
+ * are computed in runtime.
+ *
+ * There are obtained through callbacks, as we don't want to tie the texture
+ * sampling code generation logic to any particular texture layout or pipe
+ * driver.
+ */
+struct lp_sampler_dynamic_state
+{
+
+   /** Obtain the base texture width. */
+   LLVMValueRef
+   (*width)( struct lp_sampler_dynamic_state *state,
+             LLVMBuilderRef builder,
+             unsigned unit);
+
+   /** Obtain the base texture height. */
+   LLVMValueRef
+   (*height)( struct lp_sampler_dynamic_state *state,
+              LLVMBuilderRef builder,
+              unsigned unit);
+
+   LLVMValueRef
+   (*stride)( struct lp_sampler_dynamic_state *state,
+              LLVMBuilderRef builder,
+              unsigned unit);
+
+   LLVMValueRef
+   (*data_ptr)( struct lp_sampler_dynamic_state *state,
+                LLVMBuilderRef builder,
+                unsigned unit);
+
+};
+
+
+/**
+ * Derive the sampler static state.
+ */
+void
+lp_sampler_static_state(struct lp_sampler_static_state *state,
+                        const struct pipe_texture *texture,
+                        const struct pipe_sampler_state *sampler);
+
+
+void
+lp_build_sample_soa(LLVMBuilderRef builder,
+                    const struct lp_sampler_static_state *static_state,
+                    struct lp_sampler_dynamic_state *dynamic_state,
+                    struct lp_type fp_type,
+                    unsigned unit,
+                    unsigned num_coords,
+                    const LLVMValueRef *coords,
+                    LLVMValueRef lodbias,
+                    LLVMValueRef *texel);
+
+
+
+#endif /* LP_BLD_SAMPLE_H */
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_sample_soa.c b/src/gallium/drivers/llvmpipe/lp_bld_sample_soa.c
new file mode 100644
index 0000000000..8ca1be6f1b
--- /dev/null
+++ b/src/gallium/drivers/llvmpipe/lp_bld_sample_soa.c
@@ -0,0 +1,416 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * Texture sampling.
+ *
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+
+#include "pipe/p_defines.h"
+#include "pipe/p_state.h"
+#include "util/u_debug.h"
+#include "util/u_memory.h"
+#include "util/u_math.h"
+#include "util/u_format.h"
+#include "lp_bld_debug.h"
+#include "lp_bld_type.h"
+#include "lp_bld_const.h"
+#include "lp_bld_arit.h"
+#include "lp_bld_logic.h"
+#include "lp_bld_swizzle.h"
+#include "lp_bld_format.h"
+#include "lp_bld_sample.h"
+
+
+void
+lp_sampler_static_state(struct lp_sampler_static_state *state,
+                        const struct pipe_texture *texture,
+                        const struct pipe_sampler_state *sampler)
+{
+   memset(state, 0, sizeof *state);
+
+   if(!texture)
+      return;
+
+   if(!sampler)
+      return;
+
+   state->format            = texture->format;
+   state->target            = texture->target;
+   state->pot_width         = util_is_pot(texture->width[0]);
+   state->pot_height        = util_is_pot(texture->height[0]);
+   state->pot_depth         = util_is_pot(texture->depth[0]);
+
+   state->wrap_s            = sampler->wrap_s;
+   state->wrap_t            = sampler->wrap_t;
+   state->wrap_r            = sampler->wrap_r;
+   state->min_img_filter    = sampler->min_img_filter;
+   state->min_mip_filter    = sampler->min_mip_filter;
+   state->mag_img_filter    = sampler->mag_img_filter;
+   if(sampler->compare_mode) {
+      state->compare_mode      = sampler->compare_mode;
+      state->compare_func      = sampler->compare_func;
+   }
+   state->normalized_coords = sampler->normalized_coords;
+   state->prefilter         = sampler->prefilter;
+}
+
+
+
+/**
+ * Keep all information for sampling code generation in a single place.
+ */
+struct lp_build_sample_context
+{
+   LLVMBuilderRef builder;
+
+   const struct lp_sampler_static_state *static_state;
+
+   struct lp_sampler_dynamic_state *dynamic_state;
+
+   const struct util_format_description *format_desc;
+
+   /** Incoming coordinates type and build context */
+   struct lp_type coord_type;
+   struct lp_build_context coord_bld;
+
+   /** Integer coordinates */
+   struct lp_type int_coord_type;
+   struct lp_build_context int_coord_bld;
+
+   /** Output texels type and build context */
+   struct lp_type texel_type;
+   struct lp_build_context texel_bld;
+};
+
+
+static void
+lp_build_sample_texel(struct lp_build_sample_context *bld,
+                      LLVMValueRef x,
+                      LLVMValueRef y,
+                      LLVMValueRef y_stride,
+                      LLVMValueRef data_ptr,
+                      LLVMValueRef *texel)
+{
+   struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
+   LLVMValueRef x_stride;
+   LLVMValueRef offset;
+
+   x_stride = lp_build_const_scalar(bld->int_coord_type, bld->format_desc->block.bits/8);
+
+   if(bld->format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS) {
+      LLVMValueRef x_lo, x_hi;
+      LLVMValueRef y_lo, y_hi;
+      LLVMValueRef x_stride_lo, x_stride_hi;
+      LLVMValueRef y_stride_lo, y_stride_hi;
+      LLVMValueRef x_offset_lo, x_offset_hi;
+      LLVMValueRef y_offset_lo, y_offset_hi;
+      LLVMValueRef offset_lo, offset_hi;
+
+      x_lo = LLVMBuildAnd(bld->builder, x, int_coord_bld->one, "");
+      y_lo = LLVMBuildAnd(bld->builder, y, int_coord_bld->one, "");
+
+      x_hi = LLVMBuildLShr(bld->builder, x, int_coord_bld->one, "");
+      y_hi = LLVMBuildLShr(bld->builder, y, int_coord_bld->one, "");
+
+      x_stride_lo = x_stride;
+      y_stride_lo = lp_build_const_scalar(bld->int_coord_type, 2*bld->format_desc->block.bits/8);
+
+      x_stride_hi = lp_build_const_scalar(bld->int_coord_type, 4*bld->format_desc->block.bits/8);
+      y_stride_hi = LLVMBuildShl(bld->builder, y_stride, int_coord_bld->one, "");
+
+      x_offset_lo = lp_build_mul(int_coord_bld, x_lo, x_stride_lo);
+      y_offset_lo = lp_build_mul(int_coord_bld, y_lo, y_stride_lo);
+      offset_lo = lp_build_add(int_coord_bld, x_offset_lo, y_offset_lo);
+
+      x_offset_hi = lp_build_mul(int_coord_bld, x_hi, x_stride_hi);
+      y_offset_hi = lp_build_mul(int_coord_bld, y_hi, y_stride_hi);
+      offset_hi = lp_build_add(int_coord_bld, x_offset_hi, y_offset_hi);
+
+      offset = lp_build_add(int_coord_bld, offset_hi, offset_lo);
+   }
+   else {
+      LLVMValueRef x_offset;
+      LLVMValueRef y_offset;
+
+      x_offset = lp_build_mul(int_coord_bld, x, x_stride);
+      y_offset = lp_build_mul(int_coord_bld, y, y_stride);
+
+      offset = lp_build_add(int_coord_bld, x_offset, y_offset);
+   }
+
+   lp_build_load_rgba_soa(bld->builder,
+                          bld->format_desc,
+                          bld->texel_type,
+                          data_ptr,
+                          offset,
+                          texel);
+}
+
+
+static LLVMValueRef
+lp_build_sample_wrap(struct lp_build_sample_context *bld,
+                     LLVMValueRef coord,
+                     LLVMValueRef length,
+                     boolean is_pot,
+                     unsigned wrap_mode)
+{
+   struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
+   LLVMValueRef length_minus_one;
+
+   length_minus_one = lp_build_sub(int_coord_bld, length, int_coord_bld->one);
+
+   switch(wrap_mode) {
+   case PIPE_TEX_WRAP_REPEAT:
+      if(is_pot)
+         coord = LLVMBuildAnd(bld->builder, coord, length_minus_one, "");
+      else
+         /* Signed remainder won't give the right results for negative
+          * dividends but unsigned remainder does.*/
+         coord = LLVMBuildURem(bld->builder, coord, length, "");
+      break;
+
+   case PIPE_TEX_WRAP_CLAMP:
+      coord = lp_build_max(int_coord_bld, coord, int_coord_bld->zero);
+      coord = lp_build_min(int_coord_bld, coord, length_minus_one);
+      break;
+
+   case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
+   case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
+   case PIPE_TEX_WRAP_MIRROR_REPEAT:
+   case PIPE_TEX_WRAP_MIRROR_CLAMP:
+   case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
+   case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
+      /* FIXME */
+      _debug_printf("warning: failed to translate texture wrap mode %u\n", wrap_mode);
+      coord = lp_build_max(int_coord_bld, coord, int_coord_bld->zero);
+      coord = lp_build_min(int_coord_bld, coord, length_minus_one);
+      break;
+
+   default:
+      assert(0);
+   }
+
+   return coord;
+}
+
+
+static void
+lp_build_sample_2d_nearest_soa(struct lp_build_sample_context *bld,
+                               LLVMValueRef s,
+                               LLVMValueRef t,
+                               LLVMValueRef width,
+                               LLVMValueRef height,
+                               LLVMValueRef stride,
+                               LLVMValueRef data_ptr,
+                               LLVMValueRef *texel)
+{
+   LLVMValueRef x;
+   LLVMValueRef y;
+
+   x = lp_build_ifloor(&bld->coord_bld, s);
+   y = lp_build_ifloor(&bld->coord_bld, t);
+
+   x = lp_build_sample_wrap(bld, x, width,  bld->static_state->pot_width,  bld->static_state->wrap_s);
+   y = lp_build_sample_wrap(bld, y, height, bld->static_state->pot_height, bld->static_state->wrap_t);
+
+   lp_build_sample_texel(bld, x, y, stride, data_ptr, texel);
+}
+
+
+static void
+lp_build_sample_2d_linear_soa(struct lp_build_sample_context *bld,
+                              LLVMValueRef s,
+                              LLVMValueRef t,
+                              LLVMValueRef width,
+                              LLVMValueRef height,
+                              LLVMValueRef stride,
+                              LLVMValueRef data_ptr,
+                              LLVMValueRef *texel)
+{
+   LLVMValueRef half;
+   LLVMValueRef s_ipart;
+   LLVMValueRef t_ipart;
+   LLVMValueRef s_fpart;
+   LLVMValueRef t_fpart;
+   LLVMValueRef x0, x1;
+   LLVMValueRef y0, y1;
+   LLVMValueRef neighbors[2][2][4];
+   unsigned chan;
+
+   half = lp_build_const_scalar(bld->coord_type, 0.5);
+   s = lp_build_sub(&bld->coord_bld, s, half);
+   t = lp_build_sub(&bld->coord_bld, t, half);
+
+   s_ipart = lp_build_floor(&bld->coord_bld, s);
+   t_ipart = lp_build_floor(&bld->coord_bld, t);
+
+   s_fpart = lp_build_sub(&bld->coord_bld, s, s_ipart);
+   t_fpart = lp_build_sub(&bld->coord_bld, t, t_ipart);
+
+   x0 = lp_build_int(&bld->coord_bld, s_ipart);
+   y0 = lp_build_int(&bld->coord_bld, t_ipart);
+
+   x0 = lp_build_sample_wrap(bld, x0, width,  bld->static_state->pot_width,  bld->static_state->wrap_s);
+   y0 = lp_build_sample_wrap(bld, y0, height, bld->static_state->pot_height, bld->static_state->wrap_t);
+
+   x1 = lp_build_add(&bld->int_coord_bld, x0, bld->int_coord_bld.one);
+   y1 = lp_build_add(&bld->int_coord_bld, y0, bld->int_coord_bld.one);
+
+   x1 = lp_build_sample_wrap(bld, x1, width,  bld->static_state->pot_width,  bld->static_state->wrap_s);
+   y1 = lp_build_sample_wrap(bld, y1, height, bld->static_state->pot_height, bld->static_state->wrap_t);
+
+   lp_build_sample_texel(bld, x0, y0, stride, data_ptr, neighbors[0][0]);
+   lp_build_sample_texel(bld, x1, y0, stride, data_ptr, neighbors[0][1]);
+   lp_build_sample_texel(bld, x0, y1, stride, data_ptr, neighbors[1][0]);
+   lp_build_sample_texel(bld, x1, y1, stride, data_ptr, neighbors[1][1]);
+
+   /* TODO: Don't interpolate missing channels */
+   for(chan = 0; chan < 4; ++chan) {
+      texel[chan] = lp_build_lerp_2d(&bld->texel_bld,
+                                     s_fpart, t_fpart,
+                                     neighbors[0][0][chan],
+                                     neighbors[0][1][chan],
+                                     neighbors[1][0][chan],
+                                     neighbors[1][1][chan]);
+   }
+}
+
+
+static void
+lp_build_sample_compare(struct lp_build_sample_context *bld,
+                        LLVMValueRef p,
+                        LLVMValueRef *texel)
+{
+   struct lp_build_context *texel_bld = &bld->texel_bld;
+   LLVMValueRef res;
+   unsigned chan;
+
+   if(!bld->static_state->compare_mode)
+      return;
+
+   /* TODO: Compare before swizzling, to avoid redundant computations */
+   res = NULL;
+   for(chan = 0; chan < 4; ++chan) {
+      LLVMValueRef cmp;
+      cmp = lp_build_cmp(texel_bld, bld->static_state->compare_func, p, texel[chan]);
+      cmp = lp_build_select(texel_bld, cmp, texel_bld->one, texel_bld->zero);
+
+      if(res)
+         res = lp_build_add(texel_bld, res, cmp);
+      else
+         res = cmp;
+   }
+
+   assert(res);
+   res = lp_build_mul(texel_bld, res, lp_build_const_scalar(texel_bld->type, 0.25));
+
+   /* XXX returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE */
+   for(chan = 0; chan < 3; ++chan)
+      texel[chan] = res;
+   texel[3] = texel_bld->one;
+}
+
+
+void
+lp_build_sample_soa(LLVMBuilderRef builder,
+                    const struct lp_sampler_static_state *static_state,
+                    struct lp_sampler_dynamic_state *dynamic_state,
+                    struct lp_type type,
+                    unsigned unit,
+                    unsigned num_coords,
+                    const LLVMValueRef *coords,
+                    LLVMValueRef lodbias,
+                    LLVMValueRef *texel)
+{
+   struct lp_build_sample_context bld;
+   LLVMValueRef width;
+   LLVMValueRef height;
+   LLVMValueRef stride;
+   LLVMValueRef data_ptr;
+   LLVMValueRef s;
+   LLVMValueRef t;
+   LLVMValueRef p;
+
+   /* Setup our build context */
+   memset(&bld, 0, sizeof bld);
+   bld.builder = builder;
+   bld.static_state = static_state;
+   bld.dynamic_state = dynamic_state;
+   bld.format_desc = util_format_description(static_state->format);
+   bld.coord_type = type;
+   bld.int_coord_type = lp_int_type(type);
+   bld.texel_type = type;
+   lp_build_context_init(&bld.coord_bld, builder, bld.coord_type);
+   lp_build_context_init(&bld.int_coord_bld, builder, bld.int_coord_type);
+   lp_build_context_init(&bld.texel_bld, builder, bld.texel_type);
+
+   /* Get the dynamic state */
+   width = dynamic_state->width(dynamic_state, builder, unit);
+   height = dynamic_state->height(dynamic_state, builder, unit);
+   stride = dynamic_state->stride(dynamic_state, builder, unit);
+   data_ptr = dynamic_state->data_ptr(dynamic_state, builder, unit);
+
+   s = coords[0];
+   t = coords[1];
+   p = coords[2];
+
+   width = lp_build_broadcast_scalar(&bld.int_coord_bld, width);
+   height = lp_build_broadcast_scalar(&bld.int_coord_bld, height);
+   stride = lp_build_broadcast_scalar(&bld.int_coord_bld, stride);
+
+   if(static_state->target == PIPE_TEXTURE_1D)
+      t = bld.coord_bld.zero;
+
+   if(static_state->normalized_coords) {
+      LLVMTypeRef coord_vec_type = lp_build_vec_type(bld.coord_type);
+      LLVMValueRef fp_width = LLVMBuildSIToFP(builder, width, coord_vec_type, "");
+      LLVMValueRef fp_height = LLVMBuildSIToFP(builder, height, coord_vec_type, "");
+      s = lp_build_mul(&bld.coord_bld, s, fp_width);
+      t = lp_build_mul(&bld.coord_bld, t, fp_height);
+   }
+
+   switch (static_state->min_img_filter) {
+   case PIPE_TEX_FILTER_NEAREST:
+      lp_build_sample_2d_nearest_soa(&bld, s, t, width, height, stride, data_ptr, texel);
+      break;
+   case PIPE_TEX_FILTER_LINEAR:
+   case PIPE_TEX_FILTER_ANISO:
+      lp_build_sample_2d_linear_soa(&bld, s, t, width, height, stride, data_ptr, texel);
+      break;
+   default:
+      assert(0);
+   }
+
+   /* FIXME: respect static_state->min_mip_filter */;
+   /* FIXME: respect static_state->mag_img_filter */;
+   /* FIXME: respect static_state->prefilter */;
+
+   lp_build_sample_compare(&bld, p, texel);
+}
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_struct.c b/src/gallium/drivers/llvmpipe/lp_bld_struct.c
index 14d2b10df9..3998ac374f 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_struct.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_struct.c
@@ -42,17 +42,30 @@
 
 
 LLVMValueRef
+lp_build_struct_get_ptr(LLVMBuilderRef builder,
+                        LLVMValueRef ptr,
+                        unsigned member,
+                        const char *name)
+{
+   LLVMValueRef indices[2];
+   LLVMValueRef member_ptr;
+   indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+   indices[1] = LLVMConstInt(LLVMInt32Type(), member, 0);
+   member_ptr = LLVMBuildGEP(builder, ptr, indices, Elements(indices), "");
+   lp_build_name(member_ptr, "%s.%s_ptr", LLVMGetValueName(ptr), name);
+   return member_ptr;
+}
+
+
+LLVMValueRef
 lp_build_struct_get(LLVMBuilderRef builder,
                     LLVMValueRef ptr,
                     unsigned member,
                     const char *name)
 {
-   LLVMValueRef indices[2];
    LLVMValueRef member_ptr;
    LLVMValueRef res;
-   indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
-   indices[1] = LLVMConstInt(LLVMInt32Type(), member, 0);
-   member_ptr = LLVMBuildGEP(builder, ptr, indices, Elements(indices), "");
+   member_ptr = lp_build_struct_get_ptr(builder, ptr, member, name);
    res = LLVMBuildLoad(builder, member_ptr, "");
    lp_build_name(res, "%s.%s", LLVMGetValueName(ptr), name);
    return res;
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_struct.h b/src/gallium/drivers/llvmpipe/lp_bld_struct.h
index cbefdc9f81..740392f561 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_struct.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_struct.h
@@ -53,6 +53,18 @@
              offsetof(_ctype, _cmember))
 
 
+/**
+ * Get value pointer to a structure member.
+ */
+LLVMValueRef
+lp_build_struct_get_ptr(LLVMBuilderRef builder,
+                        LLVMValueRef ptr,
+                        unsigned member,
+                        const char *name);
+
+/**
+ * Get the value of a structure member.
+ */
 LLVMValueRef
 lp_build_struct_get(LLVMBuilderRef builder,
                     LLVMValueRef ptr,
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_swizzle.c b/src/gallium/drivers/llvmpipe/lp_bld_swizzle.c
index ac7eed9379..64e81f7b1f 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_swizzle.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_swizzle.c
@@ -64,7 +64,7 @@ LLVMValueRef
 lp_build_broadcast_scalar(struct lp_build_context *bld,
                           LLVMValueRef scalar)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    LLVMValueRef res;
    unsigned i;
 
@@ -83,7 +83,7 @@ lp_build_broadcast_aos(struct lp_build_context *bld,
                        LLVMValueRef a,
                        unsigned channel)
 {
-   const union lp_type type = bld->type;
+   const struct lp_type type = bld->type;
    const unsigned n = type.length;
    unsigned i, j;
 
@@ -115,7 +115,7 @@ lp_build_broadcast_aos(struct lp_build_context *bld,
        *   YY00 YY00 .... YY00
        *   YYYY YYYY .... YYYY  <= output
        */
-      union lp_type type4 = type;
+      struct lp_type type4 = type;
       const char shifts[4][2] = {
          { 1,  2},
          {-1,  2},
@@ -161,7 +161,7 @@ lp_build_broadcast_aos(struct lp_build_context *bld,
 LLVMValueRef
 lp_build_swizzle1_aos(struct lp_build_context *bld,
                       LLVMValueRef a,
-                      unsigned char swizzle[4])
+                      const unsigned char swizzle[4])
 {
    const unsigned n = bld->type.length;
    unsigned i, j;
@@ -192,7 +192,7 @@ LLVMValueRef
 lp_build_swizzle2_aos(struct lp_build_context *bld,
                       LLVMValueRef a,
                       LLVMValueRef b,
-                      unsigned char swizzle[4])
+                      const unsigned char swizzle[4])
 {
    const unsigned n = bld->type.length;
    unsigned i, j;
@@ -201,11 +201,12 @@ lp_build_swizzle2_aos(struct lp_build_context *bld,
       return lp_build_swizzle1_aos(bld, a, swizzle);
 
    if(a == b) {
-      swizzle[0] %= 4;
-      swizzle[1] %= 4;
-      swizzle[2] %= 4;
-      swizzle[3] %= 4;
-      return lp_build_swizzle1_aos(bld, a, swizzle);
+      unsigned char swizzle1[4];
+      swizzle1[0] = swizzle[0] % 4;
+      swizzle1[1] = swizzle[1] % 4;
+      swizzle1[2] = swizzle[2] % 4;
+      swizzle1[3] = swizzle[3] % 4;
+      return lp_build_swizzle1_aos(bld, a, swizzle1);
    }
 
    if(swizzle[0] % 4 == 0 &&
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_swizzle.h b/src/gallium/drivers/llvmpipe/lp_bld_swizzle.h
index d7dd6a8a60..1f6da80448 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_swizzle.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_swizzle.h
@@ -40,7 +40,7 @@
 #include <llvm-c/Core.h>  
 
 
-union lp_type type;
+struct lp_type type;
 struct lp_build_context;
 
 
@@ -73,7 +73,7 @@ lp_build_broadcast_aos(struct lp_build_context *bld,
 LLVMValueRef
 lp_build_swizzle1_aos(struct lp_build_context *bld,
                       LLVMValueRef a,
-                      unsigned char swizzle[4]);
+                      const unsigned char swizzle[4]);
 
 
 /**
@@ -85,7 +85,7 @@ LLVMValueRef
 lp_build_swizzle2_aos(struct lp_build_context *bld,
                       LLVMValueRef a,
                       LLVMValueRef b,
-                      unsigned char swizzle[4]);
+                      const unsigned char swizzle[4]);
 
 
 #endif /* !LP_BLD_SWIZZLE_H */
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_tgsi.h b/src/gallium/drivers/llvmpipe/lp_bld_tgsi.h
index 912db24aec..eddb7a83fa 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_tgsi.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_tgsi.h
@@ -39,31 +39,46 @@
 
 
 struct tgsi_token;
-union lp_type;
+struct lp_type;
 struct lp_build_context;
 struct lp_build_mask_context;
 
 
-typedef void
-(*lp_emit_fetch_texel_soa_callback)( LLVMBuilderRef builder,
-                                void *context,
-                                unsigned unit,
-                                unsigned num_coords,
-                                const LLVMValueRef *coords,
-                                LLVMValueRef lodbias,
-                                LLVMValueRef *texel);
+/**
+ * Sampler code generation interface.
+ *
+ * Although texture sampling is a requirement for TGSI translation, it is
+ * a very different problem with several different approaches to it. This
+ * structure establishes an interface for texture sampling code generation, so
+ * that we can easily use different texture sampling strategies.
+ */
+struct lp_build_sampler_soa
+{
+   void
+   (*destroy)( struct lp_build_sampler_soa *sampler );
+
+   void
+   (*emit_fetch_texel)( struct lp_build_sampler_soa *sampler,
+                        LLVMBuilderRef builder,
+                        struct lp_type type,
+                        unsigned unit,
+                        unsigned num_coords,
+                        const LLVMValueRef *coords,
+                        LLVMValueRef lodbias,
+                        LLVMValueRef *texel);
+};
+
 
 void
 lp_build_tgsi_soa(LLVMBuilderRef builder,
                   const struct tgsi_token *tokens,
-                  union lp_type type,
+                  struct lp_type type,
                   struct lp_build_mask_context *mask,
                   LLVMValueRef consts_ptr,
                   const LLVMValueRef *pos,
                   const LLVMValueRef (*inputs)[4],
                   LLVMValueRef (*outputs)[4],
-                  lp_emit_fetch_texel_soa_callback emit_fetch_texel,
-                  void *emit_fetch_texel_context);
+                  struct lp_build_sampler_soa *sampler);
 
 
 #endif /* LP_BLD_TGSI_H */
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_tgsi_soa.c b/src/gallium/drivers/llvmpipe/lp_bld_tgsi_soa.c
index d4d18febec..adc81569ed 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_tgsi_soa.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_tgsi_soa.c
@@ -78,6 +78,11 @@
 #define CHAN_Z 2
 #define CHAN_W 3
 
+#define QUAD_TOP_LEFT     0
+#define QUAD_TOP_RIGHT    1
+#define QUAD_BOTTOM_LEFT  2
+#define QUAD_BOTTOM_RIGHT 3
+
 
 struct lp_build_tgsi_soa_context
 {
@@ -88,8 +93,7 @@ struct lp_build_tgsi_soa_context
    const LLVMValueRef (*inputs)[NUM_CHANNELS];
    LLVMValueRef (*outputs)[NUM_CHANNELS];
 
-   lp_emit_fetch_texel_soa_callback emit_fetch_texel;
-   void *emit_fetch_texel_context;
+   struct lp_build_sampler_soa *sampler;
 
    LLVMValueRef immediates[LP_MAX_IMMEDIATES][NUM_CHANNELS];
    LLVMValueRef temps[LP_MAX_TEMPS][NUM_CHANNELS];
@@ -98,6 +102,51 @@ struct lp_build_tgsi_soa_context
 };
 
 
+static const unsigned char
+swizzle_left[4] = {
+   QUAD_TOP_LEFT,     QUAD_TOP_LEFT,
+   QUAD_BOTTOM_LEFT,  QUAD_BOTTOM_LEFT
+};
+
+static const unsigned char
+swizzle_right[4] = {
+   QUAD_TOP_RIGHT,    QUAD_TOP_RIGHT,
+   QUAD_BOTTOM_RIGHT, QUAD_BOTTOM_RIGHT
+};
+
+static const unsigned char
+swizzle_top[4] = {
+   QUAD_TOP_LEFT,     QUAD_TOP_RIGHT,
+   QUAD_TOP_LEFT,     QUAD_TOP_RIGHT
+};
+
+static const unsigned char
+swizzle_bottom[4] = {
+   QUAD_BOTTOM_LEFT,  QUAD_BOTTOM_RIGHT,
+   QUAD_BOTTOM_LEFT,  QUAD_BOTTOM_RIGHT
+};
+
+
+static LLVMValueRef
+emit_ddx(struct lp_build_tgsi_soa_context *bld,
+         LLVMValueRef src)
+{
+   LLVMValueRef src_left  = lp_build_swizzle1_aos(&bld->base, src, swizzle_left);
+   LLVMValueRef src_right = lp_build_swizzle1_aos(&bld->base, src, swizzle_right);
+   return lp_build_sub(&bld->base, src_right, src_left);
+}
+
+
+static LLVMValueRef
+emit_ddy(struct lp_build_tgsi_soa_context *bld,
+         LLVMValueRef src)
+{
+   LLVMValueRef src_top    = lp_build_swizzle1_aos(&bld->base, src, swizzle_top);
+   LLVMValueRef src_bottom = lp_build_swizzle1_aos(&bld->base, src, swizzle_bottom);
+   return lp_build_sub(&bld->base, src_top, src_bottom);
+}
+
+
 /**
  * Register fetch.
  */
@@ -168,6 +217,7 @@ emit_fetch(
       break;
 
    case TGSI_UTIL_SIGN_SET:
+      /* TODO: Use bitwese OR for floating point */
       res = lp_build_abs( &bld->base, res );
       res = LLVMBuildNeg( bld->base.builder, res, "" );
       break;
@@ -185,6 +235,36 @@ emit_fetch(
 
 
 /**
+ * Register fetch with derivatives.
+ */
+static void
+emit_fetch_deriv(
+   struct lp_build_tgsi_soa_context *bld,
+   const struct tgsi_full_instruction *inst,
+   unsigned index,
+   const unsigned chan_index,
+   LLVMValueRef *res,
+   LLVMValueRef *ddx,
+   LLVMValueRef *ddy)
+{
+   LLVMValueRef src;
+
+   src = emit_fetch(bld, inst, index, chan_index);
+
+   if(res)
+      *res = src;
+
+   /* TODO: use interpolation coeffs for inputs */
+
+   if(ddx)
+      *ddx = emit_ddx(bld, src);
+
+   if(ddy)
+      *ddy = emit_ddy(bld, src);
+}
+
+
+/**
  * Register store.
  */
 static void
@@ -239,17 +319,18 @@ emit_store(
  * High-level instruction translators.
  */
 
+
 static void
 emit_tex( struct lp_build_tgsi_soa_context *bld,
           const struct tgsi_full_instruction *inst,
           boolean apply_lodbias,
-          boolean projected)
+          boolean projected,
+          LLVMValueRef *texel)
 {
    const uint unit = inst->FullSrcRegisters[1].SrcRegister.Index;
    LLVMValueRef lodbias;
    LLVMValueRef oow;
    LLVMValueRef coords[3];
-   LLVMValueRef texel[4];
    unsigned num_coords;
    unsigned i;
 
@@ -289,12 +370,11 @@ emit_tex( struct lp_build_tgsi_soa_context *bld,
          coords[i] = lp_build_mul(&bld->base, coords[i], oow);
    }
 
-   bld->emit_fetch_texel(bld->base.builder, bld->emit_fetch_texel_context,
-                         unit, num_coords, coords, lodbias, texel);
-
-   FOR_EACH_DST0_ENABLED_CHANNEL( inst, i ) {
-      emit_store( bld, inst, 0, i, texel[i] );
-   }
+   bld->sampler->emit_fetch_texel(bld->sampler,
+                                  bld->base.builder,
+                                  bld->base.type,
+                                  unit, num_coords, coords, lodbias,
+                                  texel);
 }
 
 
@@ -347,14 +427,6 @@ emit_kil(
 }
 
 
-static void
-emit_kilp(
-   struct lp_build_tgsi_soa_context *bld )
-{
-   /* XXX todo / fix me */
-}
-
-
 /**
  * Check if inst src/dest regs use indirect addressing into temporary
  * register file.
@@ -382,25 +454,35 @@ indirect_temp_reference(const struct tgsi_full_instruction *inst)
 static int
 emit_instruction(
    struct lp_build_tgsi_soa_context *bld,
-   struct tgsi_full_instruction *inst )
+   const struct tgsi_full_instruction *inst,
+   const struct tgsi_opcode_info *info)
 {
    unsigned chan_index;
    LLVMValueRef src0, src1, src2;
    LLVMValueRef tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
-   LLVMValueRef dst0;
+   LLVMValueRef res;
+   LLVMValueRef dst0[NUM_CHANNELS];
 
    /* we can't handle indirect addressing into temp register file yet */
    if (indirect_temp_reference(inst))
       return FALSE;
 
+   assert(info->num_dst <= 1);
+   if(info->num_dst) {
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         dst0[chan_index] = bld->base.undef;
+      }
+   }
+
    switch (inst->Instruction.Opcode) {
 #if 0
    case TGSI_OPCODE_ARL:
+      /* FIXME */
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          tmp0 = emit_fetch( bld, inst, 0, chan_index );
          emit_flr(bld, 0, 0);
          emit_f2it( bld, 0 );
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
 #endif
@@ -408,19 +490,17 @@ emit_instruction(
    case TGSI_OPCODE_MOV:
    case TGSI_OPCODE_SWZ:
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         tmp0 = emit_fetch( bld, inst, 0, chan_index );
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = emit_fetch( bld, inst, 0, chan_index );
       }
       break;
 
    case TGSI_OPCODE_LIT:
       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) ) {
-         emit_store( bld, inst, 0, CHAN_X, bld->base.one);
+         dst0[CHAN_X] = bld->base.one;
       }
       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) ) {
          src0 = emit_fetch( bld, inst, 0, CHAN_X );
-         dst0 = lp_build_max( &bld->base, src0, bld->base.zero);
-         emit_store( bld, inst, 0, CHAN_Y, dst0);
+         dst0[CHAN_Y] = lp_build_max( &bld->base, src0, bld->base.zero);
       }
       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) ) {
          /* XMM[1] = SrcReg[0].yyyy */
@@ -432,20 +512,19 @@ emit_instruction(
          tmp1 = lp_build_pow( &bld->base, tmp1, tmp2);
          tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
          tmp2 = lp_build_cmp(&bld->base, PIPE_FUNC_GREATER, tmp0, bld->base.zero);
-         dst0 = lp_build_select(&bld->base, tmp2, tmp1, bld->base.zero);
-         emit_store( bld, inst, 0, CHAN_Z, dst0);
+         dst0[CHAN_Z] = lp_build_select(&bld->base, tmp2, tmp1, bld->base.zero);
       }
       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) ) {
-         emit_store( bld, inst, 0, CHAN_W, bld->base.one);
+         dst0[CHAN_W] = bld->base.one;
       }
       break;
 
    case TGSI_OPCODE_RCP:
    /* TGSI_OPCODE_RECIP */
       src0 = emit_fetch( bld, inst, 0, CHAN_X );
-      dst0 = lp_build_rcp(&bld->base, src0);
+      res = lp_build_rcp(&bld->base, src0);
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, dst0 );
+         dst0[chan_index] = res;
       }
       break;
 
@@ -453,9 +532,9 @@ emit_instruction(
    /* TGSI_OPCODE_RECIPSQRT */
       src0 = emit_fetch( bld, inst, 0, CHAN_X );
       src0 = lp_build_abs(&bld->base, src0);
-      dst0 = lp_build_rsqrt(&bld->base, src0);
+      res = lp_build_rsqrt(&bld->base, src0);
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, dst0 );
+         dst0[chan_index] = res;
       }
       break;
 
@@ -479,16 +558,15 @@ emit_instruction(
          lp_build_exp2_approx(&bld->base, src0, p_exp2_int_part, p_frac_part, p_exp2);
 
          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ))
-            emit_store( bld, inst, 0, CHAN_X, tmp0);
+            dst0[CHAN_X] = tmp0;
          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ))
-            emit_store( bld, inst, 0, CHAN_Y, tmp1);
+            dst0[CHAN_Y] = tmp1;
          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ))
-            emit_store( bld, inst, 0, CHAN_Z, tmp2);
+            dst0[CHAN_Z] = tmp2;
       }
       /* dst.w = 1.0 */
       if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_W )) {
-         tmp0 = bld->base.one;
-         emit_store( bld, inst, 0, CHAN_W, tmp0);
+         dst0[CHAN_W] = bld->base.one;
       }
       break;
 
@@ -514,20 +592,18 @@ emit_instruction(
 
          /* dst.x = floor(lg2(abs(src.x))) */
          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ))
-            emit_store( bld, inst, 0, CHAN_X, tmp0);
+            dst0[CHAN_X] = tmp0;
          /* dst.y = abs(src)/ex2(floor(lg2(abs(src.x)))) */
          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y )) {
-            tmp1 = lp_build_div( &bld->base, src0, tmp1);
-            emit_store( bld, inst, 0, CHAN_Y, tmp1);
+            dst0[CHAN_Y] = lp_build_div( &bld->base, src0, tmp1);
          }
          /* dst.z = lg2(abs(src.x)) */
          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ))
-            emit_store( bld, inst, 0, CHAN_Z, tmp2);
+            dst0[CHAN_Z] = tmp2;
       }
       /* dst.w = 1.0 */
       if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_W )) {
-         tmp0 = bld->base.one;
-         emit_store( bld, inst, 0, CHAN_W, tmp0);
+         dst0[CHAN_W] = bld->base.one;
       }
       break;
 
@@ -535,8 +611,7 @@ emit_instruction(
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
-         dst0 = lp_build_mul(&bld->base, src0, src1);
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_mul(&bld->base, src0, src1);
       }
       break;
 
@@ -544,8 +619,7 @@ emit_instruction(
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
-         dst0 = lp_build_add(&bld->base, src0, src1);
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_add(&bld->base, src0, src1);
       }
       break;
 
@@ -563,7 +637,7 @@ emit_instruction(
       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
 
@@ -585,28 +659,24 @@ emit_instruction(
       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
 
    case TGSI_OPCODE_DST:
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) {
-         tmp0 = bld->base.one;
-         emit_store( bld, inst, 0, CHAN_X, tmp0);
+         dst0[CHAN_X] = bld->base.one;
       }
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) {
          tmp0 = emit_fetch( bld, inst, 0, CHAN_Y );
          tmp1 = emit_fetch( bld, inst, 1, CHAN_Y );
-         tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);
-         emit_store( bld, inst, 0, CHAN_Y, tmp0);
+         dst0[CHAN_Y] = lp_build_mul( &bld->base, tmp0, tmp1);
       }
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) {
-         tmp0 = emit_fetch( bld, inst, 0, CHAN_Z );
-         emit_store( bld, inst, 0, CHAN_Z, tmp0);
+         dst0[CHAN_Z] = emit_fetch( bld, inst, 0, CHAN_Z );
       }
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) {
-         tmp0 = emit_fetch( bld, inst, 1, CHAN_W );
-         emit_store( bld, inst, 0, CHAN_W, tmp0);
+         dst0[CHAN_W] = emit_fetch( bld, inst, 1, CHAN_W );
       }
       break;
 
@@ -614,8 +684,7 @@ emit_instruction(
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
-         dst0 = lp_build_min( &bld->base, src0, src1 );
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_min( &bld->base, src0, src1 );
       }
       break;
 
@@ -623,8 +692,7 @@ emit_instruction(
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
-         dst0 = lp_build_max( &bld->base, src0, src1 );
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_max( &bld->base, src0, src1 );
       }
       break;
 
@@ -634,8 +702,7 @@ emit_instruction(
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_LESS, src0, src1 );
-         dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
       }
       break;
 
@@ -645,8 +712,7 @@ emit_instruction(
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GEQUAL, src0, src1 );
-         dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
       }
       break;
 
@@ -658,7 +724,7 @@ emit_instruction(
          tmp2 = emit_fetch( bld, inst, 2, chan_index );
          tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);
          tmp0 = lp_build_add( &bld->base, tmp0, tmp2);
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
 
@@ -666,8 +732,7 @@ emit_instruction(
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          tmp0 = emit_fetch( bld, inst, 0, chan_index );
          tmp1 = emit_fetch( bld, inst, 1, chan_index );
-         tmp0 = lp_build_sub( &bld->base, tmp0, tmp1);
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = lp_build_sub( &bld->base, tmp0, tmp1);
       }
       break;
 
@@ -678,13 +743,19 @@ emit_instruction(
          src2 = emit_fetch( bld, inst, 2, chan_index );
          tmp0 = lp_build_sub( &bld->base, src1, src2 );
          tmp0 = lp_build_mul( &bld->base, src0, tmp0 );
-         dst0 = lp_build_add( &bld->base, tmp0, src2 );
-         emit_store( bld, inst, 0, chan_index, dst0 );
+         dst0[chan_index] = lp_build_add( &bld->base, tmp0, src2 );
       }
       break;
 
    case TGSI_OPCODE_CND:
-      return 0;
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         src0 = emit_fetch( bld, inst, 0, chan_index );
+         src1 = emit_fetch( bld, inst, 1, chan_index );
+         src2 = emit_fetch( bld, inst, 2, chan_index );
+         tmp1 = lp_build_const_scalar(bld->base.type, 0.5);
+         tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GREATER, src2, tmp1);
+         dst0[chan_index] = lp_build_select( &bld->base, tmp0, src0, src1 );
+      }
       break;
 
    case TGSI_OPCODE_DP2A:
@@ -698,45 +769,49 @@ emit_instruction(
       tmp1 = emit_fetch( bld, inst, 2, CHAN_X );  /* xmm1 = src[2].x */
       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);              /* xmm0 = xmm0 + xmm1 */
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, tmp0);  /* dest[ch] = xmm0 */
+         dst0[chan_index] = tmp0;  /* dest[ch] = xmm0 */
       }
       break;
 
-#if 0
    case TGSI_OPCODE_FRC:
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         tmp0 = emit_fetch( bld, inst, 0, chan_index );
-         emit_frc( bld, 0, 0 );
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         src0 = emit_fetch( bld, inst, 0, chan_index );
+         tmp0 = lp_build_floor(&bld->base, src0);
+         tmp0 = lp_build_sub(&bld->base, tmp0, src0);
+         dst0[chan_index] = tmp0;
       }
       break;
 
    case TGSI_OPCODE_CLAMP:
-      return 0;
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         tmp0 = emit_fetch( bld, inst, 0, chan_index );
+         src1 = emit_fetch( bld, inst, 1, chan_index );
+         src2 = emit_fetch( bld, inst, 2, chan_index );
+         tmp0 = lp_build_max(&bld->base, tmp0, src1);
+         tmp0 = lp_build_min(&bld->base, tmp0, src2);
+         dst0[chan_index] = tmp0;
+      }
       break;
 
    case TGSI_OPCODE_FLR:
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          tmp0 = emit_fetch( bld, inst, 0, chan_index );
-         emit_flr( bld, 0, 0 );
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = lp_build_floor(&bld->base, tmp0);
       }
       break;
 
    case TGSI_OPCODE_ROUND:
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          tmp0 = emit_fetch( bld, inst, 0, chan_index );
-         emit_rnd( bld, 0, 0 );
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = lp_build_round(&bld->base, tmp0);
       }
       break;
-#endif
 
    case TGSI_OPCODE_EX2: {
       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
       tmp0 = lp_build_exp2( &bld->base, tmp0);
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
    }
@@ -745,16 +820,16 @@ emit_instruction(
       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
       tmp0 = lp_build_log2( &bld->base, tmp0);
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
 
    case TGSI_OPCODE_POW:
       src0 = emit_fetch( bld, inst, 0, CHAN_X );
       src1 = emit_fetch( bld, inst, 1, CHAN_X );
-      dst0 = lp_build_pow( &bld->base, src0, src1 );
+      res = lp_build_pow( &bld->base, src0, src1 );
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, dst0 );
+         dst0[chan_index] = res;
       }
       break;
 
@@ -775,7 +850,7 @@ emit_instruction(
          tmp5 = tmp3;
          tmp5 = lp_build_mul( &bld->base, tmp5, tmp4);
          tmp2 = lp_build_sub( &bld->base, tmp2, tmp5);
-         emit_store( bld, inst, 0, CHAN_X, tmp2);
+         dst0[CHAN_X] = tmp2;
       }
       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) ||
           IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) ) {
@@ -786,31 +861,30 @@ emit_instruction(
          tmp3 = lp_build_mul( &bld->base, tmp3, tmp2);
          tmp1 = lp_build_mul( &bld->base, tmp1, tmp5);
          tmp3 = lp_build_sub( &bld->base, tmp3, tmp1);
-         emit_store( bld, inst, 0, CHAN_Y, tmp3);
+         dst0[CHAN_Y] = tmp3;
       }
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) {
          tmp5 = lp_build_mul( &bld->base, tmp5, tmp4);
          tmp0 = lp_build_mul( &bld->base, tmp0, tmp2);
          tmp5 = lp_build_sub( &bld->base, tmp5, tmp0);
-         emit_store( bld, inst, 0, CHAN_Z, tmp5);
+         dst0[CHAN_Z] = tmp5;
       }
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) {
-         tmp0 = bld->base.one;
-         emit_store( bld, inst, 0, CHAN_W, tmp0);
+         dst0[CHAN_W] = bld->base.one;
       }
       break;
 
    case TGSI_OPCODE_ABS:
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          tmp0 = emit_fetch( bld, inst, 0, chan_index );
-         tmp0 = lp_build_abs( &bld->base, tmp0 ) ;
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = lp_build_abs( &bld->base, tmp0 );
       }
       break;
 
    case TGSI_OPCODE_RCC:
+      /* deprecated? */
+      assert(0);
       return 0;
-      break;
 
    case TGSI_OPCODE_DPH:
       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
@@ -827,7 +901,7 @@ emit_instruction(
       tmp1 = emit_fetch( bld, inst, 1, CHAN_W );
       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
 
@@ -835,25 +909,27 @@ emit_instruction(
       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
       tmp0 = lp_build_cos( &bld->base, tmp0 );
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
 
    case TGSI_OPCODE_DDX:
-      return 0;
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         emit_fetch_deriv( bld, inst, 0, chan_index, NULL, &dst0[chan_index], NULL);
+      }
       break;
 
    case TGSI_OPCODE_DDY:
-      return 0;
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         emit_fetch_deriv( bld, inst, 0, chan_index, NULL, NULL, &dst0[chan_index]);
+      }
       break;
 
-#if 0
    case TGSI_OPCODE_KILP:
       /* predicated kill */
-      emit_kilp( bld );
-      return 0; /* XXX fix me */
+      /* FIXME */
+      return 0;
       break;
-#endif
 
    case TGSI_OPCODE_KIL:
       /* conditional kill */
@@ -885,13 +961,14 @@ emit_instruction(
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_EQUAL, src0, src1 );
-         dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
       }
       break;
 
    case TGSI_OPCODE_SFL:
-      return 0;
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         dst0[chan_index] = bld->base.zero;
+      }
       break;
 
    case TGSI_OPCODE_SGT:
@@ -899,8 +976,7 @@ emit_instruction(
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GREATER, src0, src1 );
-         dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
       }
       break;
 
@@ -908,7 +984,7 @@ emit_instruction(
       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
       tmp0 = lp_build_sin( &bld->base, tmp0 );
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
 
@@ -917,8 +993,7 @@ emit_instruction(
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_LEQUAL, src0, src1 );
-         dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
       }
       break;
 
@@ -927,85 +1002,99 @@ emit_instruction(
          src0 = emit_fetch( bld, inst, 0, chan_index );
          src1 = emit_fetch( bld, inst, 1, chan_index );
          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_NOTEQUAL, src0, src1 );
-         dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
       }
       break;
 
    case TGSI_OPCODE_STR:
-      return 0;
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         dst0[chan_index] = bld->base.one;
+      }
       break;
 
    case TGSI_OPCODE_TEX:
-      emit_tex( bld, inst, FALSE, FALSE );
+      emit_tex( bld, inst, FALSE, FALSE, dst0 );
       break;
 
    case TGSI_OPCODE_TXD:
+      /* FIXME */
       return 0;
       break;
 
    case TGSI_OPCODE_UP2H:
+      /* deprecated */
+      assert (0);
       return 0;
       break;
 
    case TGSI_OPCODE_UP2US:
+      /* deprecated */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_UP4B:
+      /* deprecated */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_UP4UB:
+      /* deprecated */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_X2D:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_ARA:
+      /* deprecated */
+      assert(0);
       return 0;
       break;
 
 #if 0
    case TGSI_OPCODE_ARR:
+      /* FIXME */
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          tmp0 = emit_fetch( bld, inst, 0, chan_index );
          emit_rnd( bld, 0, 0 );
          emit_f2it( bld, 0 );
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = tmp0;
       }
       break;
 #endif
 
    case TGSI_OPCODE_BRA:
+      /* deprecated */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_CAL:
+      /* FIXME */
       return 0;
       break;
 
-#if 0
    case TGSI_OPCODE_RET:
-      emit_ret( bld );
+      /* FIXME */
+      return 0;
       break;
-#endif
 
    case TGSI_OPCODE_END:
       break;
 
-#if 0
    case TGSI_OPCODE_SSG:
    /* TGSI_OPCODE_SGN */
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          tmp0 = emit_fetch( bld, inst, 0, chan_index );
-         emit_sgn( bld, 0, 0 );
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = lp_build_sgn( &bld->base, tmp0 );
       }
       break;
-#endif
 
    case TGSI_OPCODE_CMP:
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
@@ -1013,34 +1102,29 @@ emit_instruction(
          src1 = emit_fetch( bld, inst, 1, chan_index );
          src2 = emit_fetch( bld, inst, 2, chan_index );
          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_LESS, src0, bld->base.zero );
-         dst0 = lp_build_select( &bld->base, tmp0, src1, src2);
-         emit_store( bld, inst, 0, chan_index, dst0);
+         dst0[chan_index] = lp_build_select( &bld->base, tmp0, src1, src2);
       }
       break;
 
    case TGSI_OPCODE_SCS:
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) {
          tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
-         tmp0 = lp_build_cos( &bld->base, tmp0 );
-         emit_store( bld, inst, 0, CHAN_X, tmp0);
+         dst0[CHAN_X] = lp_build_cos( &bld->base, tmp0 );
       }
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) {
          tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
-         tmp0 = lp_build_sin( &bld->base, tmp0 );
-         emit_store( bld, inst, 0, CHAN_Y, tmp0);
+         dst0[CHAN_Y] = lp_build_sin( &bld->base, tmp0 );
       }
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) {
-         tmp0 = bld->base.zero;
-         emit_store( bld, inst, 0, CHAN_Z, tmp0);
+         dst0[CHAN_Z] = bld->base.zero;
       }
       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) {
-         tmp0 = bld->base.one;
-         emit_store( bld, inst, 0, CHAN_W, tmp0);
+         dst0[CHAN_W] = bld->base.one;
       }
       break;
 
    case TGSI_OPCODE_TXB:
-      emit_tex( bld, inst, TRUE, FALSE );
+      emit_tex( bld, inst, TRUE, FALSE, dst0 );
       break;
 
    case TGSI_OPCODE_NRM:
@@ -1099,38 +1183,35 @@ emit_instruction(
 
             /* dst.x = xmm1 * src.x */
             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_X)) {
-               tmp4 = lp_build_mul( &bld->base, tmp4, tmp1);
-               emit_store(bld, inst, 0, CHAN_X, tmp4);
+               dst0[CHAN_X] = lp_build_mul( &bld->base, tmp4, tmp1);
             }
 
             /* dst.y = xmm1 * src.y */
             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_Y)) {
-               tmp5 = lp_build_mul( &bld->base, tmp5, tmp1);
-               emit_store(bld, inst, 0, CHAN_Y, tmp5);
+               dst0[CHAN_Y] = lp_build_mul( &bld->base, tmp5, tmp1);
             }
 
             /* dst.z = xmm1 * src.z */
             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_Z)) {
-               tmp6 = lp_build_mul( &bld->base, tmp6, tmp1);
-               emit_store(bld, inst, 0, CHAN_Z, tmp6);
+               dst0[CHAN_Z] = lp_build_mul( &bld->base, tmp6, tmp1);
             }
 
             /* dst.w = xmm1 * src.w */
             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_X) && dims == 4) {
-               tmp7 = lp_build_mul( &bld->base, tmp7, tmp1);
-               emit_store(bld, inst, 0, CHAN_W, tmp7);
+               dst0[CHAN_W] = lp_build_mul( &bld->base, tmp7, tmp1);
             }
          }
 
-         /* dst0.w = 1.0 */
+         /* dst.w = 1.0 */
          if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_W) && dims == 3) {
-            tmp0 = bld->base.one;
-            emit_store(bld, inst, 0, CHAN_W, tmp0);
+            dst0[CHAN_W] = bld->base.one;
          }
       }
       break;
 
    case TGSI_OPCODE_DIV:
+      /* deprecated */
+      assert( 0 );
       return 0;
       break;
 
@@ -1143,118 +1224,157 @@ emit_instruction(
       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);              /* xmm1 = xmm1 * xmm2 */
       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);              /* xmm0 = xmm0 + xmm1 */
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
-         emit_store( bld, inst, 0, chan_index, tmp0);  /* dest[ch] = xmm0 */
+         dst0[chan_index] = tmp0;  /* dest[ch] = xmm0 */
       }
       break;
 
    case TGSI_OPCODE_TXL:
-      emit_tex( bld, inst, TRUE, FALSE );
+      emit_tex( bld, inst, TRUE, FALSE, dst0 );
       break;
 
    case TGSI_OPCODE_TXP:
-      emit_tex( bld, inst, FALSE, TRUE );
+      emit_tex( bld, inst, FALSE, TRUE, dst0 );
       break;
       
    case TGSI_OPCODE_BRK:
+      /* FIXME */
       return 0;
       break;
 
    case TGSI_OPCODE_IF:
+      /* FIXME */
       return 0;
       break;
 
    case TGSI_OPCODE_BGNFOR:
+      /* deprecated */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_REP:
+      /* deprecated */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_ELSE:
+      /* FIXME */
       return 0;
       break;
 
    case TGSI_OPCODE_ENDIF:
+      /* FIXME */
       return 0;
       break;
 
    case TGSI_OPCODE_ENDFOR:
+      /* deprecated */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_ENDREP:
+      /* deprecated */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_PUSHA:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_POPA:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_CEIL:
-      return 0;
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         tmp0 = emit_fetch( bld, inst, 0, chan_index );
+         dst0[chan_index] = lp_build_ceil(&bld->base, tmp0);
+      }
       break;
 
    case TGSI_OPCODE_I2F:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_NOT:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
-#if 0
    case TGSI_OPCODE_TRUNC:
       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
          tmp0 = emit_fetch( bld, inst, 0, chan_index );
-         emit_f2it( bld, 0 );
-         emit_i2f( bld, 0 );
-         emit_store( bld, inst, 0, chan_index, tmp0);
+         dst0[chan_index] = lp_build_trunc(&bld->base, tmp0);
       }
       break;
-#endif
 
    case TGSI_OPCODE_SHL:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_SHR:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_AND:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_OR:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_MOD:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_XOR:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_SAD:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_TXF:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_TXQ:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
    case TGSI_OPCODE_CONT:
+      /* deprecated? */
+      assert(0);
       return 0;
       break;
 
@@ -1266,10 +1386,28 @@ emit_instruction(
       return 0;
       break;
 
+   case TGSI_OPCODE_NOISE1:
+   case TGSI_OPCODE_NOISE2:
+   case TGSI_OPCODE_NOISE3:
+   case TGSI_OPCODE_NOISE4:
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         dst0[chan_index] = bld->base.zero;
+      }
+      break;
+
+   case TGSI_OPCODE_NOP:
+      break;
+
    default:
       return 0;
    }
    
+   if(info->num_dst) {
+      FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+         emit_store( bld, inst, 0, chan_index, dst0[chan_index]);
+      }
+   }
+
    return 1;
 }
 
@@ -1277,14 +1415,13 @@ emit_instruction(
 void
 lp_build_tgsi_soa(LLVMBuilderRef builder,
                   const struct tgsi_token *tokens,
-                  union lp_type type,
+                  struct lp_type type,
                   struct lp_build_mask_context *mask,
                   LLVMValueRef consts_ptr,
                   const LLVMValueRef *pos,
                   const LLVMValueRef (*inputs)[NUM_CHANNELS],
                   LLVMValueRef (*outputs)[NUM_CHANNELS],
-                  lp_emit_fetch_texel_soa_callback emit_fetch_texel,
-                  void *emit_fetch_texel_context)
+                  struct lp_build_sampler_soa *sampler)
 {
    struct lp_build_tgsi_soa_context bld;
    struct tgsi_parse_context parse;
@@ -1299,8 +1436,7 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
    bld.inputs = inputs;
    bld.outputs = outputs;
    bld.consts_ptr = consts_ptr;
-   bld.emit_fetch_texel = emit_fetch_texel;
-   bld.emit_fetch_texel_context = emit_fetch_texel_context;
+   bld.sampler = sampler;
 
    tgsi_parse_init( &parse, tokens );
 
@@ -1309,16 +1445,18 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
 
       switch( parse.FullToken.Token.Type ) {
       case TGSI_TOKEN_TYPE_DECLARATION:
-         /* Input already interpolated */
+         /* Inputs already interpolated */
          break;
 
       case TGSI_TOKEN_TYPE_INSTRUCTION:
-         if (!emit_instruction( &bld, &parse.FullToken.FullInstruction )) {
+         {
             unsigned opcode = parse.FullToken.FullInstruction.Instruction.Opcode;
             const struct tgsi_opcode_info *info = tgsi_get_opcode_info(opcode);
-	    _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",
-	                  info ? info->mnemonic : "<invalid>");
-	 }
+            if (!emit_instruction( &bld, &parse.FullToken.FullInstruction, info ))
+               _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",
+                             info ? info->mnemonic : "<invalid>");
+         }
+
          break;
 
       case TGSI_TOKEN_TYPE_IMMEDIATE:
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_type.c b/src/gallium/drivers/llvmpipe/lp_bld_type.c
index 8e0026fd97..606243d6c5 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_type.c
+++ b/src/gallium/drivers/llvmpipe/lp_bld_type.c
@@ -33,7 +33,7 @@
 
 
 LLVMTypeRef
-lp_build_elem_type(union lp_type type)
+lp_build_elem_type(struct lp_type type)
 {
    if (type.floating) {
       switch(type.width) {
@@ -55,7 +55,7 @@ lp_build_elem_type(union lp_type type)
 
 
 LLVMTypeRef
-lp_build_vec_type(union lp_type type)
+lp_build_vec_type(struct lp_type type)
 {
    LLVMTypeRef elem_type = lp_build_elem_type(type);
    return LLVMVectorType(elem_type, type.length);
@@ -69,7 +69,7 @@ lp_build_vec_type(union lp_type type)
  * type and check for identity.
  */
 boolean
-lp_check_elem_type(union lp_type type, LLVMTypeRef elem_type) 
+lp_check_elem_type(struct lp_type type, LLVMTypeRef elem_type) 
 {
    LLVMTypeKind elem_kind;
 
@@ -107,7 +107,7 @@ lp_check_elem_type(union lp_type type, LLVMTypeRef elem_type)
 
 
 boolean
-lp_check_vec_type(union lp_type type, LLVMTypeRef vec_type) 
+lp_check_vec_type(struct lp_type type, LLVMTypeRef vec_type) 
 {
    LLVMTypeRef elem_type;
 
@@ -128,7 +128,7 @@ lp_check_vec_type(union lp_type type, LLVMTypeRef vec_type)
 
 
 boolean
-lp_check_value(union lp_type type, LLVMValueRef val) 
+lp_check_value(struct lp_type type, LLVMValueRef val) 
 {
    LLVMTypeRef vec_type;
 
@@ -143,24 +143,36 @@ lp_check_value(union lp_type type, LLVMValueRef val)
 
 
 LLVMTypeRef
-lp_build_int_elem_type(union lp_type type)
+lp_build_int_elem_type(struct lp_type type)
 {
    return LLVMIntType(type.width);
 }
 
 
 LLVMTypeRef
-lp_build_int_vec_type(union lp_type type)
+lp_build_int_vec_type(struct lp_type type)
 {
    LLVMTypeRef elem_type = lp_build_int_elem_type(type);
    return LLVMVectorType(elem_type, type.length);
 }
 
 
+struct lp_type
+lp_int_type(struct lp_type type)
+{
+   struct lp_type int_type;
+
+   memset(&int_type, 0, sizeof int_type);
+   int_type.width = type.width;
+   int_type.length = type.length;
+   return int_type;
+}
+
+
 void
 lp_build_context_init(struct lp_build_context *bld,
                       LLVMBuilderRef builder,
-                      union lp_type type)
+                      struct lp_type type)
 {
    bld->builder = builder;
    bld->type = type;
diff --git a/src/gallium/drivers/llvmpipe/lp_bld_type.h b/src/gallium/drivers/llvmpipe/lp_bld_type.h
index 3ce566be64..ee5ca3483c 100644
--- a/src/gallium/drivers/llvmpipe/lp_bld_type.h
+++ b/src/gallium/drivers/llvmpipe/lp_bld_type.h
@@ -56,58 +56,55 @@
  * on the types used for intermediate computations, such as signed vs unsigned,
  * normalized values, or fixed point.
  */
-union lp_type {
-   struct {
-      /** 
-       * Floating-point. Cannot be used with fixed. Integer numbers are
-       * represented by this zero.
-       */
-      unsigned floating:1;
-
-      /** 
-       * Fixed-point. Cannot be used with floating. Integer numbers are
-       * represented by this zero.
-       */
-      unsigned fixed:1;
-      
-      /** 
-       * Whether it can represent negative values or not.
-       *
-       * If this is not set for floating point, it means that all values are
-       * assumed to be positive.
-       */
-      unsigned sign:1;
-
-      /**
-       * Whether values are normalized to fit [0, 1] interval, or [-1, 1]
-       * interval for signed types.
-       *
-       * For integer types it means the representable integer range should be
-       * interpreted as the interval above.
-       *
-       * For floating and fixed point formats it means the values should be
-       * clamped to the interval above.
-       */
-      unsigned norm:1;
-
-      /**
-       * Element width.
-       *
-       * For fixed point values, the fixed point is assumed to be at half the
-       * width.
-       */
-      unsigned width:14;
-
-      /** 
-       * Vector length.
-       *
-       * width*length should be a power of two greater or equal to eight.
-       *
-       * @sa LP_MAX_VECTOR_LENGTH
-       */
-      unsigned length:14;
-   };
-   uint32_t value;
+struct lp_type {
+   /**
+    * Floating-point. Cannot be used with fixed. Integer numbers are
+    * represented by this zero.
+    */
+   unsigned floating:1;
+
+   /**
+    * Fixed-point. Cannot be used with floating. Integer numbers are
+    * represented by this zero.
+    */
+   unsigned fixed:1;
+
+   /**
+    * Whether it can represent negative values or not.
+    *
+    * If this is not set for floating point, it means that all values are
+    * assumed to be positive.
+    */
+   unsigned sign:1;
+
+   /**
+    * Whether values are normalized to fit [0, 1] interval, or [-1, 1]
+    * interval for signed types.
+    *
+    * For integer types it means the representable integer range should be
+    * interpreted as the interval above.
+    *
+    * For floating and fixed point formats it means the values should be
+    * clamped to the interval above.
+    */
+   unsigned norm:1;
+
+   /**
+    * Element width.
+    *
+    * For fixed point values, the fixed point is assumed to be at half the
+    * width.
+    */
+   unsigned width:14;
+
+   /**
+    * Vector length.
+    *
+    * width*length should be a power of two greater or equal to eight.
+    *
+    * @sa LP_MAX_VECTOR_LENGTH
+    */
+   unsigned length:14;
 };
 
 
@@ -124,7 +121,7 @@ struct lp_build_context
     * This not only describes the input/output LLVM types, but also whether
     * to normalize/clamp the results.
     */
-   union lp_type type;
+   struct lp_type type;
 
    /** Same as lp_build_undef(type) */
    LLVMValueRef undef;
@@ -138,37 +135,41 @@ struct lp_build_context
 
 
 LLVMTypeRef
-lp_build_elem_type(union lp_type type);
+lp_build_elem_type(struct lp_type type);
 
 
 LLVMTypeRef
-lp_build_vec_type(union lp_type type);
+lp_build_vec_type(struct lp_type type);
 
 
 boolean
-lp_check_elem_type(union lp_type type, LLVMTypeRef elem_type);
+lp_check_elem_type(struct lp_type type, LLVMTypeRef elem_type);
 
 
 boolean
-lp_check_vec_type(union lp_type type, LLVMTypeRef vec_type);
+lp_check_vec_type(struct lp_type type, LLVMTypeRef vec_type);
 
 
 boolean
-lp_check_value(union lp_type type, LLVMValueRef val);
+lp_check_value(struct lp_type type, LLVMValueRef val);
 
 
 LLVMTypeRef
-lp_build_int_elem_type(union lp_type type);
+lp_build_int_elem_type(struct lp_type type);
 
 
 LLVMTypeRef
-lp_build_int_vec_type(union lp_type type);
+lp_build_int_vec_type(struct lp_type type);
+
+
+struct lp_type
+lp_int_type(struct lp_type type);
 
 
 void
 lp_build_context_init(struct lp_build_context *bld,
                       LLVMBuilderRef builder,
-                      union lp_type type);
+                      struct lp_type type);
 
 
 #endif /* !LP_BLD_TYPE_H */
diff --git a/src/gallium/drivers/llvmpipe/lp_clear.c b/src/gallium/drivers/llvmpipe/lp_clear.c
index 580cca5b46..bdcff94b9b 100644
--- a/src/gallium/drivers/llvmpipe/lp_clear.c
+++ b/src/gallium/drivers/llvmpipe/lp_clear.c
@@ -67,6 +67,7 @@ llvmpipe_clear(struct pipe_context *pipe, unsigned buffers, const float *rgba,
          util_pack_color(rgba, ps->format, &cv);
          lp_tile_cache_clear(llvmpipe->cbuf_cache[i], rgba, cv);
       }
+      llvmpipe->dirty_render_cache = TRUE;
    }
 
    if (buffers & PIPE_CLEAR_DEPTHSTENCIL) {
diff --git a/src/gallium/drivers/llvmpipe/lp_context.c b/src/gallium/drivers/llvmpipe/lp_context.c
index 233d1df0e1..a4b2bd8c2a 100644
--- a/src/gallium/drivers/llvmpipe/lp_context.c
+++ b/src/gallium/drivers/llvmpipe/lp_context.c
@@ -141,8 +141,6 @@ llvmpipe_is_texture_referenced( struct pipe_context *pipe,
          return PIPE_REFERENCED_FOR_WRITE;
    }
    
-   /* FIXME: we also need to do the same for the texture cache */
-   
    return PIPE_UNREFERENCED;
 }
 
diff --git a/src/gallium/drivers/llvmpipe/lp_jit.c b/src/gallium/drivers/llvmpipe/lp_jit.c
index d288460a1b..b4a22ff4a9 100644
--- a/src/gallium/drivers/llvmpipe/lp_jit.c
+++ b/src/gallium/drivers/llvmpipe/lp_jit.c
@@ -44,15 +44,47 @@
 static void
 lp_jit_init_globals(struct llvmpipe_screen *screen)
 {
-   /* struct lp_jit_context */
+   LLVMTypeRef texture_type;
+
+   /* struct lp_jit_texture */
    {
       LLVMTypeRef elem_types[4];
+
+      elem_types[LP_JIT_TEXTURE_WIDTH]  = LLVMInt32Type();
+      elem_types[LP_JIT_TEXTURE_HEIGHT] = LLVMInt32Type();
+      elem_types[LP_JIT_TEXTURE_STRIDE] = LLVMInt32Type();
+      elem_types[LP_JIT_TEXTURE_DATA]   = LLVMPointerType(LLVMInt8Type(), 0);
+
+      texture_type = LLVMStructType(elem_types, Elements(elem_types), 0);
+
+      LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, width,
+                             screen->target, texture_type,
+                             LP_JIT_TEXTURE_WIDTH);
+      LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, height,
+                             screen->target, texture_type,
+                             LP_JIT_TEXTURE_HEIGHT);
+      LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, stride,
+                             screen->target, texture_type,
+                             LP_JIT_TEXTURE_STRIDE);
+      LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, data,
+                             screen->target, texture_type,
+                             LP_JIT_TEXTURE_DATA);
+      LP_CHECK_STRUCT_SIZE(struct lp_jit_texture,
+                           screen->target, texture_type);
+
+      LLVMAddTypeName(screen->module, "texture", texture_type);
+   }
+
+   /* struct lp_jit_context */
+   {
+      LLVMTypeRef elem_types[5];
       LLVMTypeRef context_type;
 
       elem_types[0] = LLVMPointerType(LLVMFloatType(), 0); /* constants */
       elem_types[1] = LLVMPointerType(LLVMInt8Type(), 0);  /* samplers */
       elem_types[2] = LLVMFloatType();                     /* alpha_ref_value */
       elem_types[3] = LLVMPointerType(LLVMInt8Type(), 0);  /* blend_color */
+      elem_types[4] = LLVMArrayType(texture_type, PIPE_MAX_SAMPLERS); /* textures */
 
       context_type = LLVMStructType(elem_types, Elements(elem_types), 0);
 
@@ -64,6 +96,9 @@ lp_jit_init_globals(struct llvmpipe_screen *screen)
                              screen->target, context_type, 2);
       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, blend_color,
                              screen->target, context_type, 3);
+      LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, textures,
+                             screen->target, context_type,
+                             LP_JIT_CONTEXT_TEXTURES_INDEX);
       LP_CHECK_STRUCT_SIZE(struct lp_jit_context,
                            screen->target, context_type);
 
@@ -117,7 +152,7 @@ lp_jit_screen_init(struct llvmpipe_screen *screen)
    screen->provider = LLVMCreateModuleProviderForExistingModule(screen->module);
 
    if (LLVMCreateJITCompiler(&screen->engine, screen->provider, 1, &error)) {
-      fprintf(stderr, "%s\n", error);
+      _debug_printf("%s\n", error);
       LLVMDisposeMessage(error);
       abort();
    }
diff --git a/src/gallium/drivers/llvmpipe/lp_jit.h b/src/gallium/drivers/llvmpipe/lp_jit.h
index a7fb60f9f5..58f716ede2 100644
--- a/src/gallium/drivers/llvmpipe/lp_jit.h
+++ b/src/gallium/drivers/llvmpipe/lp_jit.h
@@ -38,11 +38,31 @@
 
 #include "lp_bld_struct.h"
 
+#include "pipe/p_state.h"
+
 
 struct tgsi_sampler;
 struct llvmpipe_screen;
 
 
+struct lp_jit_texture
+{
+   uint32_t width;
+   uint32_t height;
+   uint32_t stride;
+   const void *data;
+};
+
+
+enum {
+   LP_JIT_TEXTURE_WIDTH = 0,
+   LP_JIT_TEXTURE_HEIGHT,
+   LP_JIT_TEXTURE_STRIDE,
+   LP_JIT_TEXTURE_DATA
+};
+
+
+
 /**
  * This structure is passed directly to the generated fragment shader.
  *
@@ -60,11 +80,12 @@ struct lp_jit_context
 
    struct tgsi_sampler **samplers;
 
-   /* TODO: alpha reference value */
    float alpha_ref_value;
 
-   /* TODO: blend constant color */
+   /* FIXME: store (also?) in floats */
    uint8_t *blend_color;
+
+   struct lp_jit_texture textures[PIPE_MAX_SAMPLERS];
 };
 
 
@@ -80,6 +101,11 @@ struct lp_jit_context
 #define lp_jit_context_blend_color(_builder, _ptr) \
    lp_build_struct_get(_builder, _ptr, 3, "blend_color")
 
+#define LP_JIT_CONTEXT_TEXTURES_INDEX 4
+
+#define lp_jit_context_textures(_builder, _ptr) \
+   lp_build_struct_get_ptr(_builder, _ptr, LP_JIT_CONTEXT_TEXTURES_INDEX, "textures")
+
 
 typedef void
 (*lp_jit_frag_func)(struct lp_jit_context *context,
diff --git a/src/gallium/drivers/llvmpipe/lp_screen.c b/src/gallium/drivers/llvmpipe/lp_screen.c
index 125035771e..ff7ef8658a 100644
--- a/src/gallium/drivers/llvmpipe/lp_screen.c
+++ b/src/gallium/drivers/llvmpipe/lp_screen.c
@@ -27,8 +27,6 @@
 
 
 #include "util/u_memory.h"
-#include "util/u_simple_screen.h"
-#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_screen.h"
 
@@ -67,8 +65,6 @@ llvmpipe_get_param(struct pipe_screen *screen, int param)
       return 1;
    case PIPE_CAP_GLSL:
       return 1;
-   case PIPE_CAP_S3TC:
-      return 0;
    case PIPE_CAP_ANISOTROPIC_FILTER:
       return 0;
    case PIPE_CAP_POINT_SPRITE:
@@ -196,8 +192,7 @@ static void
 llvmpipe_destroy_screen( struct pipe_screen *_screen )
 {
    struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
-
-   struct pipe_winsys *winsys = _screen->winsys;
+   struct llvmpipe_winsys *winsys = screen->winsys;
 
    lp_jit_screen_cleanup(screen);
 
diff --git a/src/gallium/drivers/llvmpipe/lp_setup.c b/src/gallium/drivers/llvmpipe/lp_setup.c
index d145f6d6bb..2d2fc19a65 100644
--- a/src/gallium/drivers/llvmpipe/lp_setup.c
+++ b/src/gallium/drivers/llvmpipe/lp_setup.c
@@ -44,6 +44,7 @@
 #include "pipe/p_thread.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
+#include "lp_bld_debug.h"
 #include "lp_tile_cache.h"
 #include "lp_tile_soa.h"
 
@@ -162,12 +163,12 @@ shade_quads(struct llvmpipe_context *llvmpipe,
    else
       depth = NULL;
 
-   /* TODO: blend color */
+   /* XXX: This will most likely fail on 32bit x86 without -mstackrealign */
+   assert(lp_check_alignment(mask, 16));
 
-   assert((((uintptr_t)mask) & 0xf) == 0);
-   assert((((uintptr_t)depth) & 0xf) == 0);
-   assert((((uintptr_t)color) & 0xf) == 0);
-   assert((((uintptr_t)llvmpipe->jit_context.blend_color) & 0xf) == 0);
+   assert(lp_check_alignment(depth, 16));
+   assert(lp_check_alignment(color, 16));
+   assert(lp_check_alignment(llvmpipe->jit_context.blend_color, 16));
 
    /* run shader */
    fs->current->jit_function( &llvmpipe->jit_context,
diff --git a/src/gallium/drivers/llvmpipe/lp_state.h b/src/gallium/drivers/llvmpipe/lp_state.h
index fb10329887..7b26ce61a3 100644
--- a/src/gallium/drivers/llvmpipe/lp_state.h
+++ b/src/gallium/drivers/llvmpipe/lp_state.h
@@ -36,6 +36,7 @@
 #include "pipe/p_state.h"
 #include "tgsi/tgsi_scan.h"
 #include "lp_jit.h"
+#include "lp_bld_sample.h" /* for struct lp_sampler_static_state */
 
 
 #define LP_NEW_VIEWPORT      0x1
@@ -57,16 +58,20 @@
 
 struct tgsi_sampler;
 struct vertex_info;
-
+struct pipe_context;
+struct llvmpipe_context;
 
 struct lp_fragment_shader;
 
 
 struct lp_fragment_shader_variant_key
 {
+   enum pipe_format zsbuf_format;
    struct pipe_depth_state depth;
    struct pipe_alpha_state alpha;
    struct pipe_blend_state blend;
+
+   struct lp_sampler_static_state sampler[PIPE_MAX_SAMPLERS];
 };
 
 
diff --git a/src/gallium/drivers/llvmpipe/lp_state_derived.c b/src/gallium/drivers/llvmpipe/lp_state_derived.c
index 6fbb057937..30fb41ea65 100644
--- a/src/gallium/drivers/llvmpipe/lp_state_derived.c
+++ b/src/gallium/drivers/llvmpipe/lp_state_derived.c
@@ -93,6 +93,23 @@ llvmpipe_get_vertex_info(struct llvmpipe_context *llvmpipe)
       vinfo->num_attribs = 0;
       for (i = 0; i < lpfs->info.num_inputs; i++) {
          int src;
+         enum interp_mode interp;
+
+         switch (lpfs->info.input_interpolate[i]) {
+         case TGSI_INTERPOLATE_CONSTANT:
+            interp = INTERP_CONSTANT;
+            break;
+         case TGSI_INTERPOLATE_LINEAR:
+            interp = INTERP_LINEAR;
+            break;
+         case TGSI_INTERPOLATE_PERSPECTIVE:
+            interp = INTERP_PERSPECTIVE;
+            break;
+         default:
+            assert(0);
+            interp = INTERP_LINEAR;
+         }
+
          switch (lpfs->info.input_semantic_name[i]) {
          case TGSI_SEMANTIC_POSITION:
             src = draw_find_vs_output(llvmpipe->draw,
@@ -108,7 +125,7 @@ llvmpipe_get_vertex_info(struct llvmpipe_context *llvmpipe)
 
          case TGSI_SEMANTIC_FOG:
             src = draw_find_vs_output(llvmpipe->draw, TGSI_SEMANTIC_FOG, 0);
-            draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_PERSPECTIVE, src);
+            draw_emit_vertex_attr(vinfo, EMIT_4F, interp, src);
             break;
 
          case TGSI_SEMANTIC_GENERIC:
@@ -116,7 +133,7 @@ llvmpipe_get_vertex_info(struct llvmpipe_context *llvmpipe)
             /* this includes texcoords and varying vars */
             src = draw_find_vs_output(llvmpipe->draw, TGSI_SEMANTIC_GENERIC,
                                       lpfs->info.input_semantic_index[i]);
-            draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_PERSPECTIVE, src);
+            draw_emit_vertex_attr(vinfo, EMIT_4F, interp, src);
             break;
 
          default:
@@ -250,7 +267,9 @@ void llvmpipe_update_derived( struct llvmpipe_context *llvmpipe )
 
    if (llvmpipe->dirty & (LP_NEW_FS |
                           LP_NEW_BLEND |
-                          LP_NEW_DEPTH_STENCIL_ALPHA))
+                          LP_NEW_DEPTH_STENCIL_ALPHA |
+                          LP_NEW_SAMPLER |
+                          LP_NEW_TEXTURE))
       llvmpipe_update_fs( llvmpipe );
 
 
diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c
index 94170bd716..9faed5a0b1 100644
--- a/src/gallium/drivers/llvmpipe/lp_state_fs.c
+++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c
@@ -85,6 +85,7 @@
 #include "lp_context.h"
 #include "lp_state.h"
 #include "lp_quad.h"
+#include "lp_tex_sample.h"
 
 
 static const unsigned char quad_offset_x[4] = {0, 1, 0, 1};
@@ -130,21 +131,20 @@ generate_pos0(LLVMBuilderRef builder,
  * Generate the depth test.
  */
 static void
-generate_depth(struct llvmpipe_context *lp,
-               LLVMBuilderRef builder,
-               const struct pipe_depth_state *state,
-               union lp_type src_type,
+generate_depth(LLVMBuilderRef builder,
+               const struct lp_fragment_shader_variant_key *key,
+               struct lp_type src_type,
                struct lp_build_mask_context *mask,
                LLVMValueRef src,
                LLVMValueRef dst_ptr)
 {
    const struct util_format_description *format_desc;
-   union lp_type dst_type;
+   struct lp_type dst_type;
 
-   if(!lp->framebuffer.zsbuf)
+   if(!key->depth.enabled)
       return;
 
-   format_desc = util_format_description(lp->framebuffer.zsbuf->format);
+   format_desc = util_format_description(key->zsbuf_format);
    assert(format_desc);
 
    /* Pick the depth type. */
@@ -164,7 +164,7 @@ generate_depth(struct llvmpipe_context *lp,
 #endif
 
    lp_build_depth_test(builder,
-                       state,
+                       &key->depth,
                        dst_type,
                        format_desc,
                        mask,
@@ -173,107 +173,6 @@ generate_depth(struct llvmpipe_context *lp,
 }
 
 
-struct build_fetch_texel_context
-{
-   LLVMValueRef context_ptr;
-
-   LLVMValueRef samplers_ptr;
-
-   /** Coords/texels store */
-   LLVMValueRef store_ptr;
-};
-
-
-void PIPE_CDECL
-lp_fetch_texel_soa( struct tgsi_sampler **samplers,
-                    uint32_t unit,
-                    float *store )
-{
-   struct tgsi_sampler *sampler = samplers[unit];
-
-#if 0
-   uint j;
-
-   debug_printf("%s sampler: %p (%p) store: %p\n",
-                __FUNCTION__,
-                sampler, *sampler,
-                store );
-
-   debug_printf("lodbias %f\n", store[12]);
-
-   for (j = 0; j < 4; j++)
-      debug_printf("sample %d texcoord %f %f\n",
-                   j,
-                   store[0+j],
-                   store[4+j]);
-#endif
-
-   {
-      float rgba[NUM_CHANNELS][QUAD_SIZE];
-      sampler->get_samples(sampler,
-                           &store[0],
-                           &store[4],
-                           &store[8],
-                           0.0f, /*store[12],  lodbias */
-                           rgba);
-      memcpy(store, rgba, sizeof rgba);
-   }
-
-#if 0
-   for (j = 0; j < 4; j++)
-      debug_printf("sample %d result %f %f %f %f\n",
-                   j,
-                   store[0+j],
-                   store[4+j],
-                   store[8+j],
-                   store[12+j]);
-#endif
-}
-
-
-static void
-emit_fetch_texel( LLVMBuilderRef builder,
-                  void *context,
-                  unsigned unit,
-                  unsigned num_coords,
-                  const LLVMValueRef *coords,
-                  LLVMValueRef lodbias,
-                  LLVMValueRef *texel)
-{
-   struct build_fetch_texel_context *bld = context;
-   LLVMTypeRef vec_type = LLVMTypeOf(coords[0]);
-   LLVMValueRef args[3];
-   unsigned i;
-
-   if(!bld->samplers_ptr)
-      bld->samplers_ptr = lp_jit_context_samplers(builder, bld->context_ptr);
-
-   if(!bld->store_ptr)
-      bld->store_ptr = LLVMBuildArrayAlloca(builder,
-                                            vec_type,
-                                            LLVMConstInt(LLVMInt32Type(), 4, 0),
-                                            "texel_store");
-
-   for (i = 0; i < num_coords; i++) {
-      LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
-      LLVMValueRef coord_ptr = LLVMBuildGEP(builder, bld->store_ptr, &index, 1, "");
-      LLVMBuildStore(builder, coords[i], coord_ptr);
-   }
-
-   args[0] = bld->samplers_ptr;
-   args[1] = LLVMConstInt(LLVMInt32Type(), unit, 0);
-   args[2] = bld->store_ptr;
-
-   lp_build_intrinsic(builder, "fetch_texel", LLVMVoidType(), args, 3);
-
-   for (i = 0; i < NUM_CHANNELS; ++i) {
-      LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
-      LLVMValueRef texel_ptr = LLVMBuildGEP(builder, bld->store_ptr, &index, 1, "");
-      texel[i] = LLVMBuildLoad(builder, texel_ptr, "");
-   }
-}
-
-
 /**
  * Generate the fragment shader, depth/stencil test, and alpha tests.
  */
@@ -282,11 +181,11 @@ generate_fs(struct llvmpipe_context *lp,
             struct lp_fragment_shader *shader,
             const struct lp_fragment_shader_variant_key *key,
             LLVMBuilderRef builder,
-            union lp_type type,
+            struct lp_type type,
             LLVMValueRef context_ptr,
             unsigned i,
             const struct lp_build_interp_soa_context *interp,
-            struct build_fetch_texel_context *sampler,
+            struct lp_build_sampler_soa *sampler,
             LLVMValueRef *pmask,
             LLVMValueRef *color,
             LLVMValueRef depth_ptr)
@@ -298,6 +197,7 @@ generate_fs(struct llvmpipe_context *lp,
    LLVMValueRef consts_ptr;
    LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][NUM_CHANNELS];
    LLVMValueRef z = interp->pos[2];
+   struct lp_build_flow_context *flow;
    struct lp_build_mask_context mask;
    boolean early_depth_test;
    unsigned attrib;
@@ -309,25 +209,35 @@ generate_fs(struct llvmpipe_context *lp,
 
    consts_ptr = lp_jit_context_constants(builder, context_ptr);
 
-   lp_build_mask_begin(&mask, builder, type, *pmask);
+   flow = lp_build_flow_create(builder);
+
+   memset(outputs, 0, sizeof outputs);
+
+   lp_build_flow_scope_begin(flow);
+
+   /* Declare the color and z variables */
+   for(chan = 0; chan < NUM_CHANNELS; ++chan) {
+      color[chan] = LLVMGetUndef(vec_type);
+      lp_build_flow_scope_declare(flow, &color[chan]);
+   }
+   lp_build_flow_scope_declare(flow, &z);
+
+   lp_build_mask_begin(&mask, flow, type, *pmask);
 
    early_depth_test =
-      lp->depth_stencil->depth.enabled &&
-      lp->framebuffer.zsbuf &&
-      !lp->depth_stencil->alpha.enabled &&
-      !lp->fs->info.uses_kill &&
-      !lp->fs->info.writes_z;
+      key->depth.enabled &&
+      !key->alpha.enabled &&
+      !shader->info.uses_kill &&
+      !shader->info.writes_z;
 
    if(early_depth_test)
-      generate_depth(lp, builder, &key->depth,
+      generate_depth(builder, key,
                      type, &mask,
                      z, depth_ptr);
 
-   memset(outputs, 0, sizeof outputs);
-
    lp_build_tgsi_soa(builder, tokens, type, &mask,
                      consts_ptr, interp->pos, interp->inputs,
-                     outputs, emit_fetch_texel, sampler);
+                     outputs, sampler);
 
    for (attrib = 0; attrib < shader->info.num_outputs; ++attrib) {
       for(chan = 0; chan < NUM_CHANNELS; ++chan) {
@@ -368,12 +278,16 @@ generate_fs(struct llvmpipe_context *lp,
    }
 
    if(!early_depth_test)
-      generate_depth(lp, builder, &key->depth,
+      generate_depth(builder, key,
                      type, &mask,
                      z, depth_ptr);
 
    lp_build_mask_end(&mask);
 
+   lp_build_flow_scope_end(flow);
+
+   lp_build_flow_destroy(flow);
+
    *pmask = mask.value;
 
 }
@@ -385,13 +299,15 @@ generate_fs(struct llvmpipe_context *lp,
 static void
 generate_blend(const struct pipe_blend_state *blend,
                LLVMBuilderRef builder,
-               union lp_type type,
+               struct lp_type type,
                LLVMValueRef context_ptr,
                LLVMValueRef mask,
                LLVMValueRef *src,
                LLVMValueRef dst_ptr)
 {
    struct lp_build_context bld;
+   struct lp_build_flow_context *flow;
+   struct lp_build_mask_context mask_ctx;
    LLVMTypeRef vec_type;
    LLVMTypeRef int_vec_type;
    LLVMValueRef const_ptr;
@@ -400,11 +316,14 @@ generate_blend(const struct pipe_blend_state *blend,
    LLVMValueRef res[4];
    unsigned chan;
 
+   lp_build_context_init(&bld, builder, type);
+
+   flow = lp_build_flow_create(builder);
+   lp_build_mask_begin(&mask_ctx, flow, type, mask);
+
    vec_type = lp_build_vec_type(type);
    int_vec_type = lp_build_int_vec_type(type);
 
-   lp_build_context_init(&bld, builder, type);
-
    const_ptr = lp_jit_context_blend_color(builder, context_ptr);
    const_ptr = LLVMBuildBitCast(builder, const_ptr,
                                 LLVMPointerType(vec_type, 0), "");
@@ -422,11 +341,16 @@ generate_blend(const struct pipe_blend_state *blend,
    lp_build_blend_soa(builder, blend, type, src, dst, con, res);
 
    for(chan = 0; chan < 4; ++chan) {
-      LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), chan, 0);
-      lp_build_name(res[chan], "res.%c", "rgba"[chan]);
-      res[chan] = lp_build_select(&bld, mask, res[chan], dst[chan]);
-      LLVMBuildStore(builder, res[chan], LLVMBuildGEP(builder, dst_ptr, &index, 1, ""));
+      if(blend->colormask & (1 << chan)) {
+         LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), chan, 0);
+         lp_build_name(res[chan], "res.%c", "rgba"[chan]);
+         res[chan] = lp_build_select(&bld, mask, res[chan], dst[chan]);
+         LLVMBuildStore(builder, res[chan], LLVMBuildGEP(builder, dst_ptr, &index, 1, ""));
+      }
    }
+
+   lp_build_mask_end(&mask_ctx);
+   lp_build_flow_destroy(flow);
 }
 
 
@@ -440,8 +364,8 @@ generate_fragment(struct llvmpipe_context *lp,
 {
    struct llvmpipe_screen *screen = llvmpipe_screen(lp->pipe.screen);
    struct lp_fragment_shader_variant *variant;
-   union lp_type fs_type;
-   union lp_type blend_type;
+   struct lp_type fs_type;
+   struct lp_type blend_type;
    LLVMTypeRef fs_elem_type;
    LLVMTypeRef fs_vec_type;
    LLVMTypeRef fs_int_vec_type;
@@ -462,7 +386,7 @@ generate_fragment(struct llvmpipe_context *lp,
    LLVMBuilderRef builder;
    LLVMValueRef x0;
    LLVMValueRef y0;
-   struct build_fetch_texel_context sampler;
+   struct lp_build_sampler_soa *sampler;
    struct lp_build_interp_soa_context interp;
    LLVMValueRef fs_mask[LP_MAX_VECTOR_LENGTH];
    LLVMValueRef fs_out_color[NUM_CHANNELS][LP_MAX_VECTOR_LENGTH];
@@ -507,7 +431,7 @@ generate_fragment(struct llvmpipe_context *lp,
    /* TODO: actually pick these based on the fs and color buffer
     * characteristics. */
 
-   fs_type.value = 0;
+   memset(&fs_type, 0, sizeof fs_type);
    fs_type.floating = TRUE; /* floating point values */
    fs_type.sign = TRUE;     /* values are signed */
    fs_type.norm = FALSE;    /* values are not limited to [0,1] or [-1,1] */
@@ -515,7 +439,7 @@ generate_fragment(struct llvmpipe_context *lp,
    fs_type.length = 4;      /* 4 element per vector */
    num_fs = 4;
 
-   blend_type.value = 0;
+   memset(&blend_type, 0, sizeof blend_type);
    blend_type.floating = FALSE; /* values are integers */
    blend_type.sign = FALSE;     /* values are unsigned */
    blend_type.norm = TRUE;      /* values are in [0,1] or [-1,1] */
@@ -586,8 +510,13 @@ generate_fragment(struct llvmpipe_context *lp,
                             a0_ptr, dadx_ptr, dady_ptr,
                             x0, y0, 2, 0);
 
-   memset(&sampler, 0, sizeof sampler);
-   sampler.context_ptr = context_ptr;
+#if 0
+   /* C texture sampling */
+   sampler = lp_c_sampler_soa_create(context_ptr);
+#else
+   /* code generated texture sampling */
+   sampler = lp_llvm_sampler_soa_create(key->sampler, context_ptr);
+#endif
 
    for(i = 0; i < num_fs; ++i) {
       LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
@@ -606,7 +535,7 @@ generate_fragment(struct llvmpipe_context *lp,
                   context_ptr,
                   i,
                   &interp,
-                  &sampler,
+                  sampler,
                   &fs_mask[i],
                   out_color,
                   depth_ptr_i);
@@ -615,6 +544,8 @@ generate_fragment(struct llvmpipe_context *lp,
          fs_out_color[chan][i] = out_color[chan];
    }
 
+   sampler->destroy(sampler);
+
    /* 
     * Convert the fs's output color and mask to fit to the blending type. 
     */
@@ -765,18 +696,45 @@ llvmpipe_set_constant_buffer(struct pipe_context *pipe,
  */
 static void
 make_variant_key(struct llvmpipe_context *lp,
+                 struct lp_fragment_shader *shader,
                  struct lp_fragment_shader_variant_key *key)
 {
+   unsigned i;
+
    memset(key, 0, sizeof *key);
 
-   memcpy(&key->depth, &lp->depth_stencil->depth, sizeof key->depth);
+   if(lp->framebuffer.zsbuf &&
+      lp->depth_stencil->depth.enabled) {
+      key->zsbuf_format = lp->framebuffer.zsbuf->format;
+      memcpy(&key->depth, &lp->depth_stencil->depth, sizeof key->depth);
+   }
 
    key->alpha.enabled = lp->depth_stencil->alpha.enabled;
    if(key->alpha.enabled)
       key->alpha.func = lp->depth_stencil->alpha.func;
    /* alpha.ref_value is passed in jit_context */
 
-   memcpy(&key->blend, lp->blend, sizeof key->blend);
+   if(lp->framebuffer.cbufs[0]) {
+      const struct util_format_description *format_desc;
+      unsigned chan;
+
+      memcpy(&key->blend, lp->blend, sizeof key->blend);
+
+      format_desc = util_format_description(lp->framebuffer.cbufs[0]->format);
+      assert(format_desc->layout == UTIL_FORMAT_COLORSPACE_RGB ||
+             format_desc->layout == UTIL_FORMAT_COLORSPACE_SRGB);
+
+      /* mask out color channels not present in the color buffer */
+      for(chan = 0; chan < 4; ++chan) {
+         enum util_format_swizzle swizzle = format_desc->swizzle[chan];
+         if(swizzle > 4)
+            key->blend.colormask &= ~(1 << chan);
+      }
+   }
+
+   for(i = 0; i < PIPE_MAX_SAMPLERS; ++i)
+      if(shader->info.file_mask[TGSI_FILE_SAMPLER] & (1 << i))
+         lp_sampler_static_state(&key->sampler[i], lp->texture[i], lp->sampler[i]);
 }
 
 
@@ -787,7 +745,7 @@ llvmpipe_update_fs(struct llvmpipe_context *lp)
    struct lp_fragment_shader_variant_key key;
    struct lp_fragment_shader_variant *variant;
 
-   make_variant_key(lp, &key);
+   make_variant_key(lp, shader, &key);
 
    variant = shader->variants;
    while(variant) {
diff --git a/src/gallium/drivers/llvmpipe/lp_state_sampler.c b/src/gallium/drivers/llvmpipe/lp_state_sampler.c
index 4fef541b1e..c69d90c723 100644
--- a/src/gallium/drivers/llvmpipe/lp_state_sampler.c
+++ b/src/gallium/drivers/llvmpipe/lp_state_sampler.c
@@ -98,6 +98,16 @@ llvmpipe_set_sampler_textures(struct pipe_context *pipe,
 
       pipe_texture_reference(&llvmpipe->texture[i], tex);
       lp_tex_tile_cache_set_texture(llvmpipe->tex_cache[i], tex);
+
+      if(tex) {
+         struct llvmpipe_texture *lp_tex = llvmpipe_texture(tex);
+         struct lp_jit_texture *jit_tex = &llvmpipe->jit_context.textures[i];
+         jit_tex->width = tex->width[0];
+         jit_tex->height = tex->height[0];
+         jit_tex->stride = lp_tex->stride[0];
+         if(!lp_tex->dt)
+            jit_tex->data = lp_tex->data;
+      }
    }
 
    llvmpipe->num_textures = num;
diff --git a/src/gallium/drivers/llvmpipe/lp_test.h b/src/gallium/drivers/llvmpipe/lp_test.h
index 69aaae26e0..a88e110c66 100644
--- a/src/gallium/drivers/llvmpipe/lp_test.h
+++ b/src/gallium/drivers/llvmpipe/lp_test.h
@@ -86,43 +86,43 @@ random_float(void);
 
 
 void
-dump_type(FILE *fp, union lp_type type);
+dump_type(FILE *fp, struct lp_type type);
 
 
 double
-read_elem(union lp_type type, const void *src, unsigned index);
+read_elem(struct lp_type type, const void *src, unsigned index);
 
 
 void
-write_elem(union lp_type type, void *dst, unsigned index, double src);
+write_elem(struct lp_type type, void *dst, unsigned index, double src);
 
 
 void
-random_elem(union lp_type type, void *dst, unsigned index);
+random_elem(struct lp_type type, void *dst, unsigned index);
 
 
 void
-read_vec(union lp_type type, const void *src, double *dst);
+read_vec(struct lp_type type, const void *src, double *dst);
 
 
 void
-write_vec(union lp_type type, void *dst, const double *src);
+write_vec(struct lp_type type, void *dst, const double *src);
 
 
 void
-random_vec(union lp_type type, void *dst);
+random_vec(struct lp_type type, void *dst);
 
 
 boolean
-compare_vec_with_eps(union lp_type type, const void *res, const void *ref, double eps);
+compare_vec_with_eps(struct lp_type type, const void *res, const void *ref, double eps);
 
 
 boolean
-compare_vec(union lp_type type, const void *res, const void *ref);
+compare_vec(struct lp_type type, const void *res, const void *ref);
 
 
 void
-dump_vec(FILE *fp, union lp_type type, const void *src);
+dump_vec(FILE *fp, struct lp_type type, const void *src);
 
 
 #endif /* !LP_TEST_H */
diff --git a/src/gallium/drivers/llvmpipe/lp_test_blend.c b/src/gallium/drivers/llvmpipe/lp_test_blend.c
index 8dfad468e3..94b661dcba 100644
--- a/src/gallium/drivers/llvmpipe/lp_test_blend.c
+++ b/src/gallium/drivers/llvmpipe/lp_test_blend.c
@@ -80,7 +80,7 @@ static void
 write_tsv_row(FILE *fp,
               const struct pipe_blend_state *blend,
               enum vector_mode mode,
-              union lp_type type,
+              struct lp_type type,
               double cycles,
               boolean success)
 {
@@ -125,7 +125,7 @@ static void
 dump_blend_type(FILE *fp,
                 const struct pipe_blend_state *blend,
                 enum vector_mode mode,
-                union lp_type type)
+                struct lp_type type)
 {
    fprintf(fp, "%s", mode ? "soa" : "aos");
 
@@ -153,7 +153,7 @@ static LLVMValueRef
 add_blend_test(LLVMModuleRef module,
                const struct pipe_blend_state *blend,
                enum vector_mode mode,
-               union lp_type type)
+               struct lp_type type)
 {
    LLVMTypeRef ret_type;
    LLVMTypeRef vec_type;
@@ -467,7 +467,7 @@ test_one(unsigned verbose,
          FILE *fp,
          const struct pipe_blend_state *blend,
          enum vector_mode mode,
-         union lp_type type)
+         struct lp_type type)
 {
    LLVMModuleRef module = NULL;
    LLVMValueRef func = NULL;
@@ -765,10 +765,10 @@ blend_funcs[] = {
 };
 
 
-const union lp_type blend_types[] = {
+const struct lp_type blend_types[] = {
    /* float, fixed,  sign,  norm, width, len */
-   {{  TRUE, FALSE, FALSE,  TRUE,    32,   4 }}, /* f32 x 4 */
-   {{ FALSE, FALSE, FALSE,  TRUE,     8,  16 }}, /* u8n x 16 */
+   {   TRUE, FALSE, FALSE,  TRUE,    32,   4 }, /* f32 x 4 */
+   {  FALSE, FALSE, FALSE,  TRUE,     8,  16 }, /* u8n x 16 */
 };
 
 
@@ -788,7 +788,7 @@ test_all(unsigned verbose, FILE *fp)
    const unsigned *alpha_dst_factor;
    struct pipe_blend_state blend;
    enum vector_mode mode;
-   const union lp_type *type;
+   const struct lp_type *type;
    bool success = TRUE;
 
    for(rgb_func = blend_funcs; rgb_func < &blend_funcs[num_funcs]; ++rgb_func) {
@@ -841,27 +841,27 @@ test_some(unsigned verbose, FILE *fp, unsigned long n)
    const unsigned *alpha_dst_factor;
    struct pipe_blend_state blend;
    enum vector_mode mode;
-   const union lp_type *type;
+   const struct lp_type *type;
    unsigned long i;
    bool success = TRUE;
 
    for(i = 0; i < n; ++i) {
-      rgb_func = &blend_funcs[random() % num_funcs];
-      alpha_func = &blend_funcs[random() % num_funcs];
-      rgb_src_factor = &blend_factors[random() % num_factors];
-      alpha_src_factor = &blend_factors[random() % num_factors];
+      rgb_func = &blend_funcs[rand() % num_funcs];
+      alpha_func = &blend_funcs[rand() % num_funcs];
+      rgb_src_factor = &blend_factors[rand() % num_factors];
+      alpha_src_factor = &blend_factors[rand() % num_factors];
       
       do {
-         rgb_dst_factor = &blend_factors[random() % num_factors];
+         rgb_dst_factor = &blend_factors[rand() % num_factors];
       } while(*rgb_dst_factor == PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE);
 
       do {
-         alpha_dst_factor = &blend_factors[random() % num_factors];
+         alpha_dst_factor = &blend_factors[rand() % num_factors];
       } while(*alpha_dst_factor == PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE);
 
-      mode = random() & 1;
+      mode = rand() & 1;
 
-      type = &blend_types[random() % num_types];
+      type = &blend_types[rand() % num_types];
 
       memset(&blend, 0, sizeof blend);
       blend.blend_enable      = 1;
diff --git a/src/gallium/drivers/llvmpipe/lp_test_conv.c b/src/gallium/drivers/llvmpipe/lp_test_conv.c
index e6489834af..9dcf58e5dc 100644
--- a/src/gallium/drivers/llvmpipe/lp_test_conv.c
+++ b/src/gallium/drivers/llvmpipe/lp_test_conv.c
@@ -59,8 +59,8 @@ write_tsv_header(FILE *fp)
 
 static void
 write_tsv_row(FILE *fp,
-              union lp_type src_type,
-              union lp_type dst_type,
+              struct lp_type src_type,
+              struct lp_type dst_type,
               double cycles,
               boolean success)
 {
@@ -80,8 +80,8 @@ write_tsv_row(FILE *fp,
 
 static void
 dump_conv_types(FILE *fp,
-               union lp_type src_type,
-               union lp_type dst_type)
+               struct lp_type src_type,
+               struct lp_type dst_type)
 {
    fprintf(fp, "src_type=");
    dump_type(fp, src_type);
@@ -96,8 +96,8 @@ dump_conv_types(FILE *fp,
 
 static LLVMValueRef
 add_conv_test(LLVMModuleRef module,
-              union lp_type src_type, unsigned num_srcs,
-              union lp_type dst_type, unsigned num_dsts)
+              struct lp_type src_type, unsigned num_srcs,
+              struct lp_type dst_type, unsigned num_dsts)
 {
    LLVMTypeRef args[2];
    LLVMValueRef func;
@@ -145,8 +145,8 @@ add_conv_test(LLVMModuleRef module,
 static boolean
 test_one(unsigned verbose,
          FILE *fp,
-         union lp_type src_type,
-         union lp_type dst_type)
+         struct lp_type src_type,
+         struct lp_type dst_type)
 {
    LLVMModuleRef module = NULL;
    LLVMValueRef func = NULL;
@@ -343,35 +343,35 @@ test_one(unsigned verbose,
 }
 
 
-const union lp_type conv_types[] = {
+const struct lp_type conv_types[] = {
    /* float, fixed,  sign,  norm, width, len */
 
-   {{  TRUE, FALSE,  TRUE,  TRUE,    32,   4 }},
-   {{  TRUE, FALSE,  TRUE, FALSE,    32,   4 }},
-   {{  TRUE, FALSE, FALSE,  TRUE,    32,   4 }},
-   {{  TRUE, FALSE, FALSE, FALSE,    32,   4 }},
+   {   TRUE, FALSE,  TRUE,  TRUE,    32,   4 },
+   {   TRUE, FALSE,  TRUE, FALSE,    32,   4 },
+   {   TRUE, FALSE, FALSE,  TRUE,    32,   4 },
+   {   TRUE, FALSE, FALSE, FALSE,    32,   4 },
 
    /* TODO: test fixed formats too */
 
-   {{ FALSE, FALSE,  TRUE,  TRUE,    16,   8 }},
-   {{ FALSE, FALSE,  TRUE, FALSE,    16,   8 }},
-   {{ FALSE, FALSE, FALSE,  TRUE,    16,   8 }},
-   {{ FALSE, FALSE, FALSE, FALSE,    16,   8 }},
-
-   {{ FALSE, FALSE,  TRUE,  TRUE,    32,   4 }},
-   {{ FALSE, FALSE,  TRUE, FALSE,    32,   4 }},
-   {{ FALSE, FALSE, FALSE,  TRUE,    32,   4 }},
-   {{ FALSE, FALSE, FALSE, FALSE,    32,   4 }},
-
-   {{ FALSE, FALSE,  TRUE,  TRUE,    16,   8 }},
-   {{ FALSE, FALSE,  TRUE, FALSE,    16,   8 }},
-   {{ FALSE, FALSE, FALSE,  TRUE,    16,   8 }},
-   {{ FALSE, FALSE, FALSE, FALSE,    16,   8 }},
-
-   {{ FALSE, FALSE,  TRUE,  TRUE,     8,  16 }},
-   {{ FALSE, FALSE,  TRUE, FALSE,     8,  16 }},
-   {{ FALSE, FALSE, FALSE,  TRUE,     8,  16 }},
-   {{ FALSE, FALSE, FALSE, FALSE,     8,  16 }},
+   {  FALSE, FALSE,  TRUE,  TRUE,    16,   8 },
+   {  FALSE, FALSE,  TRUE, FALSE,    16,   8 },
+   {  FALSE, FALSE, FALSE,  TRUE,    16,   8 },
+   {  FALSE, FALSE, FALSE, FALSE,    16,   8 },
+
+   {  FALSE, FALSE,  TRUE,  TRUE,    32,   4 },
+   {  FALSE, FALSE,  TRUE, FALSE,    32,   4 },
+   {  FALSE, FALSE, FALSE,  TRUE,    32,   4 },
+   {  FALSE, FALSE, FALSE, FALSE,    32,   4 },
+
+   {  FALSE, FALSE,  TRUE,  TRUE,    16,   8 },
+   {  FALSE, FALSE,  TRUE, FALSE,    16,   8 },
+   {  FALSE, FALSE, FALSE,  TRUE,    16,   8 },
+   {  FALSE, FALSE, FALSE, FALSE,    16,   8 },
+
+   {  FALSE, FALSE,  TRUE,  TRUE,     8,  16 },
+   {  FALSE, FALSE,  TRUE, FALSE,     8,  16 },
+   {  FALSE, FALSE, FALSE,  TRUE,     8,  16 },
+   {  FALSE, FALSE, FALSE, FALSE,     8,  16 },
 };
 
 
@@ -381,8 +381,8 @@ const unsigned num_types = sizeof(conv_types)/sizeof(conv_types[0]);
 boolean
 test_all(unsigned verbose, FILE *fp)
 {
-   const union lp_type *src_type;
-   const union lp_type *dst_type;
+   const struct lp_type *src_type;
+   const struct lp_type *dst_type;
    bool success = TRUE;
 
    for(src_type = conv_types; src_type < &conv_types[num_types]; ++src_type) {
@@ -407,16 +407,16 @@ test_all(unsigned verbose, FILE *fp)
 boolean
 test_some(unsigned verbose, FILE *fp, unsigned long n)
 {
-   const union lp_type *src_type;
-   const union lp_type *dst_type;
+   const struct lp_type *src_type;
+   const struct lp_type *dst_type;
    unsigned long i;
    bool success = TRUE;
 
    for(i = 0; i < n; ++i) {
-      src_type = &conv_types[random() % num_types];
+      src_type = &conv_types[rand() % num_types];
       
       do {
-         dst_type = &conv_types[random() % num_types];
+         dst_type = &conv_types[rand() % num_types];
       } while (src_type == dst_type || src_type->norm != dst_type->norm);
 
       if(!test_one(verbose, fp, *src_type, *dst_type))
diff --git a/src/gallium/drivers/llvmpipe/lp_test_format.c b/src/gallium/drivers/llvmpipe/lp_test_format.c
index 1d192355ee..d8455e5649 100644
--- a/src/gallium/drivers/llvmpipe/lp_test_format.c
+++ b/src/gallium/drivers/llvmpipe/lp_test_format.c
@@ -119,7 +119,7 @@ add_load_rgba_test(LLVMModuleRef module,
 
    lp_build_loop_begin(builder, LLVMConstInt(LLVMInt32Type(), 1, 0), &loop);
 
-   rgba = lp_build_load_rgba(builder, format, ptr);
+   rgba = lp_build_load_rgba_aos(builder, format, ptr);
    LLVMBuildStore(builder, rgba, rgba_ptr);
 
    lp_build_loop_end(builder, LLVMConstInt(LLVMInt32Type(), 4, 0), NULL, &loop);
@@ -160,7 +160,7 @@ add_store_rgba_test(LLVMModuleRef module,
 
    rgba = LLVMBuildLoad(builder, rgba_ptr, "");
 
-   lp_build_store_rgba(builder, format, ptr, rgba);
+   lp_build_store_rgba_aos(builder, format, ptr, rgba);
 
    LLVMBuildRetVoid(builder);
 
diff --git a/src/gallium/drivers/llvmpipe/lp_test_main.c b/src/gallium/drivers/llvmpipe/lp_test_main.c
index 49213fb4f0..4592dc0b2d 100644
--- a/src/gallium/drivers/llvmpipe/lp_test_main.c
+++ b/src/gallium/drivers/llvmpipe/lp_test_main.c
@@ -40,7 +40,7 @@
 
 void
 dump_type(FILE *fp,
-          union lp_type type)
+          struct lp_type type)
 {
    fprintf(fp, "%s%s%u%sx%u",
            type.sign ? (type.floating || type.fixed ? "" : "s") : "u",
@@ -52,7 +52,7 @@ dump_type(FILE *fp,
 
 
 double
-read_elem(union lp_type type, const void *src, unsigned index)
+read_elem(struct lp_type type, const void *src, unsigned index)
 {
    double scale = lp_const_scale(type);
    double value;
@@ -115,7 +115,7 @@ read_elem(union lp_type type, const void *src, unsigned index)
 
 
 void
-write_elem(union lp_type type, void *dst, unsigned index, double value)
+write_elem(struct lp_type type, void *dst, unsigned index, double value)
 {
    assert(index < type.length);
    if(!type.sign && value < 0.0)
@@ -184,11 +184,11 @@ write_elem(union lp_type type, void *dst, unsigned index, double value)
 
 
 void
-random_elem(union lp_type type, void *dst, unsigned index)
+random_elem(struct lp_type type, void *dst, unsigned index)
 {
    double value;
    assert(index < type.length);
-   value = (double)random()/(double)RAND_MAX;
+   value = (double)rand()/(double)RAND_MAX;
    if(!type.norm) {
       unsigned long long mask;
       if (type.floating)
@@ -199,17 +199,17 @@ random_elem(union lp_type type, void *dst, unsigned index)
          mask = ((unsigned long long)1 << (type.width - 1)) - 1;
       else
          mask = ((unsigned long long)1 << type.width) - 1;
-      value += (double)(mask & random());
+      value += (double)(mask & rand());
    }
    if(!type.sign)
-      if(random() & 1)
+      if(rand() & 1)
          value = -value;
    write_elem(type, dst, index, value);
 }
 
 
 void
-read_vec(union lp_type type, const void *src, double *dst)
+read_vec(struct lp_type type, const void *src, double *dst)
 {
    unsigned i;
    for (i = 0; i < type.length; ++i)
@@ -218,7 +218,7 @@ read_vec(union lp_type type, const void *src, double *dst)
 
 
 void
-write_vec(union lp_type type, void *dst, const double *src)
+write_vec(struct lp_type type, void *dst, const double *src)
 {
    unsigned i;
    for (i = 0; i < type.length; ++i)
@@ -229,12 +229,12 @@ write_vec(union lp_type type, void *dst, const double *src)
 float
 random_float(void)
 {
-    return (float)((double)random()/(double)RAND_MAX);
+    return (float)((double)rand()/(double)RAND_MAX);
 }
 
 
 void
-random_vec(union lp_type type, void *dst)
+random_vec(struct lp_type type, void *dst)
 {
    unsigned i;
    for (i = 0; i < type.length; ++i)
@@ -243,7 +243,7 @@ random_vec(union lp_type type, void *dst)
 
 
 boolean
-compare_vec_with_eps(union lp_type type, const void *res, const void *ref, double eps)
+compare_vec_with_eps(struct lp_type type, const void *res, const void *ref, double eps)
 {
    unsigned i;
    for (i = 0; i < type.length; ++i) {
@@ -259,7 +259,7 @@ compare_vec_with_eps(union lp_type type, const void *res, const void *ref, doubl
 
 
 boolean
-compare_vec(union lp_type type, const void *res, const void *ref)
+compare_vec(struct lp_type type, const void *res, const void *ref)
 {
    double eps = lp_const_eps(type);
    return compare_vec_with_eps(type, res, ref, eps);
@@ -267,7 +267,7 @@ compare_vec(union lp_type type, const void *res, const void *ref)
 
 
 void
-dump_vec(FILE *fp, union lp_type type, const void *src)
+dump_vec(FILE *fp, struct lp_type type, const void *src)
 {
    unsigned i;
    for (i = 0; i < type.length; ++i) {
diff --git a/src/gallium/drivers/llvmpipe/lp_tex_cache.c b/src/gallium/drivers/llvmpipe/lp_tex_cache.c
index 23a94b5b0d..773e848242 100644
--- a/src/gallium/drivers/llvmpipe/lp_tex_cache.c
+++ b/src/gallium/drivers/llvmpipe/lp_tex_cache.c
@@ -154,7 +154,7 @@ lp_tex_tile_cache_validate_texture(struct llvmpipe_tex_tile_cache *tc)
       if (lpt->timestamp != tc->timestamp) {
          /* texture was modified, invalidate all cached tiles */
          uint i;
-         _debug_printf("INV %d %d\n", tc->timestamp, lpt->timestamp);
+         debug_printf("INV %d %d\n", tc->timestamp, lpt->timestamp);
          for (i = 0; i < NUM_ENTRIES; i++) {
             tc->entries[i].addr.bits.invalid = 1;
          }
diff --git a/src/gallium/drivers/llvmpipe/lp_tex_sample.h b/src/gallium/drivers/llvmpipe/lp_tex_sample.h
index 628ec3f1ef..9ad1bde956 100644
--- a/src/gallium/drivers/llvmpipe/lp_tex_sample.h
+++ b/src/gallium/drivers/llvmpipe/lp_tex_sample.h
@@ -29,10 +29,13 @@
 #define LP_TEX_SAMPLE_H
 
 
+#include <llvm-c/Core.h>
+
 #include "tgsi/tgsi_exec.h"
 
 
 struct llvmpipe_tex_tile_cache;
+struct lp_sampler_static_state;
 
 
 /**
@@ -75,4 +78,24 @@ lp_get_samples(struct tgsi_sampler *tgsi_sampler,
                float rgba[NUM_CHANNELS][QUAD_SIZE]);
 
 
+/**
+ * Texture sampling code generator that just calls lp_get_samples C function
+ * for the actual sampling computation.
+ *
+ * @param context_ptr LLVM value with the pointer to the struct lp_jit_context.
+ */
+struct lp_build_sampler_soa *
+lp_c_sampler_soa_create(LLVMValueRef context_ptr);
+
+
+/**
+ * Pure-LLVM texture sampling code generator.
+ *
+ * @param context_ptr LLVM value with the pointer to the struct lp_jit_context.
+ */
+struct lp_build_sampler_soa *
+lp_llvm_sampler_soa_create(const struct lp_sampler_static_state *key,
+                           LLVMValueRef context_ptr);
+
+
 #endif /* LP_TEX_SAMPLE_H */
diff --git a/src/gallium/drivers/llvmpipe/lp_tex_sample.c b/src/gallium/drivers/llvmpipe/lp_tex_sample_c.c
index 94eb6dad5a..a1365a045f 100644
--- a/src/gallium/drivers/llvmpipe/lp_tex_sample.c
+++ b/src/gallium/drivers/llvmpipe/lp_tex_sample_c.c
@@ -1578,3 +1578,136 @@ out:
    tgsi_sampler->get_samples( tgsi_sampler, s, t, p, lodbias, rgba );
 }
 
+
+void PIPE_CDECL
+lp_fetch_texel_soa( struct tgsi_sampler **samplers,
+                    uint32_t unit,
+                    float *store )
+{
+   struct tgsi_sampler *sampler = samplers[unit];
+
+#if 0
+   uint j;
+
+   debug_printf("%s sampler: %p (%p) store: %p\n",
+                __FUNCTION__,
+                sampler, *sampler,
+                store );
+
+   debug_printf("lodbias %f\n", store[12]);
+
+   for (j = 0; j < 4; j++)
+      debug_printf("sample %d texcoord %f %f\n",
+                   j,
+                   store[0+j],
+                   store[4+j]);
+#endif
+
+   {
+      float rgba[NUM_CHANNELS][QUAD_SIZE];
+      sampler->get_samples(sampler,
+                           &store[0],
+                           &store[4],
+                           &store[8],
+                           0.0f, /*store[12],  lodbias */
+                           rgba);
+      memcpy(store, rgba, sizeof rgba);
+   }
+
+#if 0
+   for (j = 0; j < 4; j++)
+      debug_printf("sample %d result %f %f %f %f\n",
+                   j,
+                   store[0+j],
+                   store[4+j],
+                   store[8+j],
+                   store[12+j]);
+#endif
+}
+
+
+#include "lp_bld_type.h"
+#include "lp_bld_intr.h"
+#include "lp_bld_tgsi.h"
+
+
+struct lp_c_sampler_soa
+{
+   struct lp_build_sampler_soa base;
+
+   LLVMValueRef context_ptr;
+
+   LLVMValueRef samplers_ptr;
+
+   /** Coords/texels store */
+   LLVMValueRef store_ptr;
+};
+
+
+static void
+lp_c_sampler_soa_destroy(struct lp_build_sampler_soa *sampler)
+{
+   FREE(sampler);
+}
+
+
+static void
+lp_c_sampler_soa_emit_fetch_texel(struct lp_build_sampler_soa *_sampler,
+                                  LLVMBuilderRef builder,
+                                  struct lp_type type,
+                                  unsigned unit,
+                                  unsigned num_coords,
+                                  const LLVMValueRef *coords,
+                                  LLVMValueRef lodbias,
+                                  LLVMValueRef *texel)
+{
+   struct lp_c_sampler_soa *sampler = (struct lp_c_sampler_soa *)_sampler;
+   LLVMTypeRef vec_type = LLVMTypeOf(coords[0]);
+   LLVMValueRef args[3];
+   unsigned i;
+
+   if(!sampler->samplers_ptr)
+      sampler->samplers_ptr = lp_jit_context_samplers(builder, sampler->context_ptr);
+
+   if(!sampler->store_ptr)
+      sampler->store_ptr = LLVMBuildArrayAlloca(builder,
+                                            vec_type,
+                                            LLVMConstInt(LLVMInt32Type(), 4, 0),
+                                            "texel_store");
+
+   for (i = 0; i < num_coords; i++) {
+      LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+      LLVMValueRef coord_ptr = LLVMBuildGEP(builder, sampler->store_ptr, &index, 1, "");
+      LLVMBuildStore(builder, coords[i], coord_ptr);
+   }
+
+   args[0] = sampler->samplers_ptr;
+   args[1] = LLVMConstInt(LLVMInt32Type(), unit, 0);
+   args[2] = sampler->store_ptr;
+
+   lp_build_intrinsic(builder, "fetch_texel", LLVMVoidType(), args, 3);
+
+   for (i = 0; i < NUM_CHANNELS; ++i) {
+      LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+      LLVMValueRef texel_ptr = LLVMBuildGEP(builder, sampler->store_ptr, &index, 1, "");
+      texel[i] = LLVMBuildLoad(builder, texel_ptr, "");
+   }
+}
+
+
+struct lp_build_sampler_soa *
+lp_c_sampler_soa_create(LLVMValueRef context_ptr)
+{
+   struct lp_c_sampler_soa *sampler;
+
+   sampler = CALLOC_STRUCT(lp_c_sampler_soa);
+   if(!sampler)
+      return NULL;
+
+   sampler->base.destroy = lp_c_sampler_soa_destroy;
+   sampler->base.emit_fetch_texel = lp_c_sampler_soa_emit_fetch_texel;
+   sampler->context_ptr = context_ptr;
+
+   return &sampler->base;
+}
+
diff --git a/src/gallium/drivers/llvmpipe/lp_tex_sample_llvm.c b/src/gallium/drivers/llvmpipe/lp_tex_sample_llvm.c
new file mode 100644
index 0000000000..d2a6ae21f5
--- /dev/null
+++ b/src/gallium/drivers/llvmpipe/lp_tex_sample_llvm.c
@@ -0,0 +1,196 @@
+/**************************************************************************
+ * 
+ * Copyright 2009 VMware, Inc.
+ * All rights reserved.
+ *
+ * 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, sub license, 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
+ * 
+ **************************************************************************/
+
+/**
+ * Texture sampling code generation
+ *
+ * This file is nothing more than ugly glue between three largely independent
+ * entities:
+ * - TGSI -> LLVM translation (i.e., lp_build_tgsi_soa)
+ * - texture sampling code generation (i.e., lp_build_sample_soa)
+ * - LLVM pipe driver
+ *
+ * All interesting code is in the functions mentioned above. There is really
+ * nothing to see here.
+ *
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+
+#include "pipe/p_defines.h"
+#include "pipe/p_shader_tokens.h"
+#include "lp_bld_debug.h"
+#include "lp_bld_type.h"
+#include "lp_bld_intr.h"
+#include "lp_bld_sample.h"
+#include "lp_bld_tgsi.h"
+#include "lp_state.h"
+#include "lp_tex_sample.h"
+
+
+/**
+ * This provides the bridge between the sampler state store in lp_jit_context
+ * and lp_jit_texture and the sampler code generator. It provides the
+ * texture layout information required by the texture sampler code generator
+ * in terms of the state stored in lp_jit_context and lp_jit_texture in runtime.
+ */
+struct llvmpipe_sampler_dynamic_state
+{
+   struct lp_sampler_dynamic_state base;
+
+   const struct lp_sampler_static_state *static_state;
+
+   LLVMValueRef context_ptr;
+};
+
+
+/**
+ * This is the bridge between our sampler and the TGSI translator.
+ */
+struct lp_llvm_sampler_soa
+{
+   struct lp_build_sampler_soa base;
+
+   struct llvmpipe_sampler_dynamic_state dynamic_state;
+};
+
+
+/**
+ * Fetch the specified member of the lp_jit_texture structure.
+ *
+ * @sa http://llvm.org/docs/GetElementPtr.html
+ */
+static LLVMValueRef
+lp_llvm_texture_member(struct lp_sampler_dynamic_state *base,
+                       LLVMBuilderRef builder,
+                       unsigned unit,
+                       unsigned member_index,
+                       const char *member_name)
+{
+   struct llvmpipe_sampler_dynamic_state *state = (struct llvmpipe_sampler_dynamic_state *)base;
+   LLVMValueRef indices[4];
+   LLVMValueRef ptr;
+   LLVMValueRef res;
+
+   assert(unit < PIPE_MAX_SAMPLERS);
+
+   /* context[0] */
+   indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+   /* context[0].textures */
+   indices[1] = LLVMConstInt(LLVMInt32Type(), LP_JIT_CONTEXT_TEXTURES_INDEX, 0);
+   /* context[0].textures[unit] */
+   indices[2] = LLVMConstInt(LLVMInt32Type(), unit, 0);
+   /* context[0].textures[unit].member */
+   indices[3] = LLVMConstInt(LLVMInt32Type(), member_index, 0);
+
+   ptr = LLVMBuildGEP(builder, state->context_ptr, indices, Elements(indices), "");
+
+   res = LLVMBuildLoad(builder, ptr, "");
+
+   lp_build_name(res, "context.texture%u.%s", unit, member_name);
+
+   return res;
+}
+
+
+/**
+ * Helper macro to instantiate the functions that generate the code to fetch
+ * the members of lp_jit_texture to fulfill the sampler code generator requests.
+ *
+ * This complexity is the price we have to pay to keep the texture sampler code
+ * generator a reusable module without dependencies to llvmpipe internals.
+ */
+#define LP_LLVM_TEXTURE_MEMBER(_name, _index) \
+   static LLVMValueRef \
+   lp_llvm_texture_##_name( struct lp_sampler_dynamic_state *base, \
+                            LLVMBuilderRef builder, \
+                            unsigned unit) \
+   { \
+      return lp_llvm_texture_member(base, builder, unit, _index, #_name ); \
+   }
+
+
+LP_LLVM_TEXTURE_MEMBER(width,    LP_JIT_TEXTURE_WIDTH)
+LP_LLVM_TEXTURE_MEMBER(height,   LP_JIT_TEXTURE_HEIGHT)
+LP_LLVM_TEXTURE_MEMBER(stride,   LP_JIT_TEXTURE_STRIDE)
+LP_LLVM_TEXTURE_MEMBER(data_ptr, LP_JIT_TEXTURE_DATA)
+
+
+static void
+lp_llvm_sampler_soa_destroy(struct lp_build_sampler_soa *sampler)
+{
+   FREE(sampler);
+}
+
+
+static void
+lp_llvm_sampler_soa_emit_fetch_texel(struct lp_build_sampler_soa *base,
+                                     LLVMBuilderRef builder,
+                                     struct lp_type type,
+                                     unsigned unit,
+                                     unsigned num_coords,
+                                     const LLVMValueRef *coords,
+                                     LLVMValueRef lodbias,
+                                     LLVMValueRef *texel)
+{
+   struct lp_llvm_sampler_soa *sampler = (struct lp_llvm_sampler_soa *)base;
+
+   assert(unit < PIPE_MAX_SAMPLERS);
+
+   lp_build_sample_soa(builder,
+                       &sampler->dynamic_state.static_state[unit],
+                       &sampler->dynamic_state.base,
+                       type,
+                       unit,
+                       num_coords,
+                       coords,
+                       lodbias,
+                       texel);
+}
+
+
+struct lp_build_sampler_soa *
+lp_llvm_sampler_soa_create(const struct lp_sampler_static_state *static_state,
+                           LLVMValueRef context_ptr)
+{
+   struct lp_llvm_sampler_soa *sampler;
+
+   sampler = CALLOC_STRUCT(lp_llvm_sampler_soa);
+   if(!sampler)
+      return NULL;
+
+   sampler->base.destroy = lp_llvm_sampler_soa_destroy;
+   sampler->base.emit_fetch_texel = lp_llvm_sampler_soa_emit_fetch_texel;
+   sampler->dynamic_state.base.width = lp_llvm_texture_width;
+   sampler->dynamic_state.base.height = lp_llvm_texture_height;
+   sampler->dynamic_state.base.stride = lp_llvm_texture_stride;
+   sampler->dynamic_state.base.data_ptr = lp_llvm_texture_data_ptr;
+   sampler->dynamic_state.static_state = static_state;
+   sampler->dynamic_state.context_ptr = context_ptr;
+
+   return &sampler->base;
+}
+
diff --git a/src/gallium/drivers/llvmpipe/lp_tile_cache.c b/src/gallium/drivers/llvmpipe/lp_tile_cache.c
index 143afec3d3..2e576e6039 100644
--- a/src/gallium/drivers/llvmpipe/lp_tile_cache.c
+++ b/src/gallium/drivers/llvmpipe/lp_tile_cache.c
@@ -225,11 +225,14 @@ lp_flush_tile_cache(struct llvmpipe_tile_cache *tc)
                            tc->clear_val);
 
             screen->transfer_unmap(screen, pt);
+
+            tile->status = LP_TILE_STATUS_UNDEFINED;
             break;
          }
 
          case LP_TILE_STATUS_DEFINED:
             lp_put_tile_rgba_soa(pt, x, y, tile->color);
+            tile->status = LP_TILE_STATUS_UNDEFINED;
             break;
          }
       }
@@ -257,7 +260,7 @@ lp_get_cached_tile(struct llvmpipe_tile_cache *tc,
 
    case LP_TILE_STATUS_UNDEFINED:
       /* get new tile data from transfer */
-      lp_get_tile_rgba_soa(pt, x, y, tile->color);
+      lp_get_tile_rgba_soa(pt, x & ~(TILE_SIZE - 1), y & ~(TILE_SIZE - 1), tile->color);
       tile->status = LP_TILE_STATUS_DEFINED;
       break;
 
diff --git a/src/gallium/drivers/nv04/nv04_screen.c b/src/gallium/drivers/nv04/nv04_screen.c
index ff2febb668..170ce3eb7e 100644
--- a/src/gallium/drivers/nv04/nv04_screen.c
+++ b/src/gallium/drivers/nv04/nv04_screen.c
@@ -16,8 +16,6 @@ nv04_screen_get_param(struct pipe_screen *screen, int param)
 		return 0;
 	case PIPE_CAP_GLSL:
 		return 0;
-	case PIPE_CAP_S3TC:
-		return 0;
 	case PIPE_CAP_ANISOTROPIC_FILTER:
 		return 0;
 	case PIPE_CAP_POINT_SPRITE:
diff --git a/src/gallium/drivers/nv10/nv10_screen.c b/src/gallium/drivers/nv10/nv10_screen.c
index 4469b22d91..ee5901e743 100644
--- a/src/gallium/drivers/nv10/nv10_screen.c
+++ b/src/gallium/drivers/nv10/nv10_screen.c
@@ -15,8 +15,6 @@ nv10_screen_get_param(struct pipe_screen *screen, int param)
 		return 0;
 	case PIPE_CAP_GLSL:
 		return 0;
-	case PIPE_CAP_S3TC:
-		return 0;
 	case PIPE_CAP_ANISOTROPIC_FILTER:
 		return 1;
 	case PIPE_CAP_POINT_SPRITE:
diff --git a/src/gallium/drivers/nv20/nv20_screen.c b/src/gallium/drivers/nv20/nv20_screen.c
index e6924ad71e..4eeacd1afd 100644
--- a/src/gallium/drivers/nv20/nv20_screen.c
+++ b/src/gallium/drivers/nv20/nv20_screen.c
@@ -15,8 +15,6 @@ nv20_screen_get_param(struct pipe_screen *screen, int param)
 		return 0;
 	case PIPE_CAP_GLSL:
 		return 0;
-	case PIPE_CAP_S3TC:
-		return 0;
 	case PIPE_CAP_ANISOTROPIC_FILTER:
 		return 1;
 	case PIPE_CAP_POINT_SPRITE:
diff --git a/src/gallium/drivers/nv30/nv30_screen.c b/src/gallium/drivers/nv30/nv30_screen.c
index f8285e4455..41af38450b 100644
--- a/src/gallium/drivers/nv30/nv30_screen.c
+++ b/src/gallium/drivers/nv30/nv30_screen.c
@@ -22,8 +22,6 @@ nv30_screen_get_param(struct pipe_screen *pscreen, int param)
 		return 1;
 	case PIPE_CAP_GLSL:
 		return 0;
-	case PIPE_CAP_S3TC:
-		return 0;
 	case PIPE_CAP_ANISOTROPIC_FILTER:
 		return 1;
 	case PIPE_CAP_POINT_SPRITE:
diff --git a/src/gallium/drivers/nv40/nv40_screen.c b/src/gallium/drivers/nv40/nv40_screen.c
index 5d2a4216c5..bd13dfddd1 100644
--- a/src/gallium/drivers/nv40/nv40_screen.c
+++ b/src/gallium/drivers/nv40/nv40_screen.c
@@ -21,8 +21,6 @@ nv40_screen_get_param(struct pipe_screen *pscreen, int param)
 		return 1;
 	case PIPE_CAP_GLSL:
 		return 0;
-	case PIPE_CAP_S3TC:
-		return 1;
 	case PIPE_CAP_ANISOTROPIC_FILTER:
 		return 1;
 	case PIPE_CAP_POINT_SPRITE:
diff --git a/src/gallium/drivers/nv50/nv50_context.c b/src/gallium/drivers/nv50/nv50_context.c
index 6e8f4f9750..fca078b174 100644
--- a/src/gallium/drivers/nv50/nv50_context.c
+++ b/src/gallium/drivers/nv50/nv50_context.c
@@ -37,11 +37,12 @@ nv50_flush(struct pipe_context *pipe, unsigned flags,
 
 	/* We need this in the ddx for reliable composite, not sure what we're
 	 * actually flushing. We generate all our own flushes with flags = 0. */
-	WAIT_RING(chan, 3);
+	WAIT_RING(chan, 2);
 	BEGIN_RING(chan, eng2d, 0x0110, 1);
 	OUT_RING  (chan, 0);
 
-	FIRE_RING(chan);
+	if (flags & PIPE_FLUSH_FRAME)
+		FIRE_RING(chan);
 }
 
 static void
@@ -110,6 +111,9 @@ nv50_create(struct pipe_screen *pscreen, unsigned pctx_id)
 	nv50->pipe.is_texture_referenced = nv50_is_texture_referenced;
 	nv50->pipe.is_buffer_referenced = nv50_is_buffer_referenced;
 
+	screen->base.channel->user_private = nv50;
+	screen->base.channel->flush_notify = nv50_state_flush_notify;
+
 	nv50_init_surface_functions(nv50);
 	nv50_init_state_functions(nv50);
 	nv50_init_query_functions(nv50);
diff --git a/src/gallium/drivers/nv50/nv50_context.h b/src/gallium/drivers/nv50/nv50_context.h
index 1e9e8e49bf..4608854d71 100644
--- a/src/gallium/drivers/nv50/nv50_context.h
+++ b/src/gallium/drivers/nv50/nv50_context.h
@@ -116,6 +116,7 @@ struct nv50_state {
 	unsigned miptree_nr;
 	struct nouveau_stateobj *vertprog;
 	struct nouveau_stateobj *fragprog;
+	struct nouveau_stateobj *programs;
 	struct nouveau_stateobj *vtxfmt;
 	struct nouveau_stateobj *vtxbuf;
 	struct nouveau_stateobj *vtxattr;
@@ -190,10 +191,12 @@ extern void nv50_clear(struct pipe_context *pipe, unsigned buffers,
 /* nv50_program.c */
 extern void nv50_vertprog_validate(struct nv50_context *nv50);
 extern void nv50_fragprog_validate(struct nv50_context *nv50);
+extern void nv50_linkage_validate(struct nv50_context *nv50);
 extern void nv50_program_destroy(struct nv50_context *nv50, struct nv50_program *p);
 
 /* nv50_state_validate.c */
 extern boolean nv50_state_validate(struct nv50_context *nv50);
+extern void nv50_state_flush_notify(struct nouveau_channel *chan);
 
 /* nv50_tex.c */
 extern void nv50_tex_validate(struct nv50_context *);
diff --git a/src/gallium/drivers/nv50/nv50_miptree.c b/src/gallium/drivers/nv50/nv50_miptree.c
index 03b9243b82..93479a0314 100644
--- a/src/gallium/drivers/nv50/nv50_miptree.c
+++ b/src/gallium/drivers/nv50/nv50_miptree.c
@@ -148,6 +148,7 @@ nv50_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
 	mt->image_nr = 1;
 	mt->level[0].pitch = *stride;
 	mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
+	mt->level[0].tile_mode = bo->tile_mode;
 
 	nouveau_bo_ref(bo, &mt->base.bo);
 	return &mt->base.base;
diff --git a/src/gallium/drivers/nv50/nv50_program.c b/src/gallium/drivers/nv50/nv50_program.c
index 4a838529de..eb90d5e66f 100644
--- a/src/gallium/drivers/nv50/nv50_program.c
+++ b/src/gallium/drivers/nv50/nv50_program.c
@@ -112,6 +112,10 @@ struct nv50_pc {
 	struct nv50_reg *temp_temp[16];
 	unsigned temp_temp_nr;
 
+	/* broadcast and destination replacement regs */
+	struct nv50_reg *r_brdc;
+	struct nv50_reg *r_dst[4];
+
 	unsigned interp_mode[32];
 	/* perspective interpolation registers */
 	struct nv50_reg *iv_p;
@@ -124,6 +128,25 @@ struct nv50_pc {
 	boolean allow32;
 };
 
+static INLINE void
+ctor_reg(struct nv50_reg *reg, unsigned type, int index, int hw)
+{
+	reg->type = type;
+	reg->index = index;
+	reg->hw = hw;
+	reg->neg = 0;
+	reg->rhw = -1;
+	reg->acc = 0;
+}
+
+static INLINE unsigned
+popcnt4(uint32_t val)
+{
+	static const unsigned cnt[16]
+	= { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
+	return cnt[val & 0xf];
+}
+
 static void
 alloc_reg(struct nv50_pc *pc, struct nv50_reg *reg)
 {
@@ -184,11 +207,8 @@ alloc_temp(struct nv50_pc *pc, struct nv50_reg *dst)
 
 	for (i = 0; i < NV50_SU_MAX_TEMP; i++) {
 		if (!pc->r_temp[i]) {
-			r = CALLOC_STRUCT(nv50_reg);
-			r->type = P_TEMP;
-			r->index = -1;
-			r->hw = i;
-			r->rhw = -1;
+			r = MALLOC_STRUCT(nv50_reg);
+			ctor_reg(r, P_TEMP, -1, i);
 			pc->r_temp[i] = r;
 			return r;
 		}
@@ -254,10 +274,8 @@ alloc_temp4(struct nv50_pc *pc, struct nv50_reg *dst[4], int idx)
 		return alloc_temp4(pc, dst, idx + 4);
 
 	for (i = 0; i < 4; i++) {
-		dst[i] = CALLOC_STRUCT(nv50_reg);
-		dst[i]->type = P_TEMP;
-		dst[i]->index = -1;
-		dst[i]->hw = idx + i;
+		dst[i] = MALLOC_STRUCT(nv50_reg);
+		ctor_reg(dst[i], P_TEMP, -1, idx + i);
 		pc->r_temp[idx + i] = dst[i];
 	}
 
@@ -309,7 +327,7 @@ ctor_immd(struct nv50_pc *pc, float x, float y, float z, float w)
 static struct nv50_reg *
 alloc_immd(struct nv50_pc *pc, float f)
 {
-	struct nv50_reg *r = CALLOC_STRUCT(nv50_reg);
+	struct nv50_reg *r = MALLOC_STRUCT(nv50_reg);
 	unsigned hw;
 
 	for (hw = 0; hw < pc->immd_nr * 4; hw++)
@@ -319,9 +337,7 @@ alloc_immd(struct nv50_pc *pc, float f)
 	if (hw == pc->immd_nr * 4)
 		hw = ctor_immd(pc, f, -f, 0.5 * f, 0) * 4;
 
-	r->type = P_IMMD;
-	r->hw = hw;
-	r->index = -1;
+	ctor_reg(r, P_IMMD, -1, hw);
 	return r;
 }
 
@@ -786,6 +802,9 @@ emit_precossin(struct nv50_pc *pc, struct nv50_reg *dst, struct nv50_reg *src)
 #define CVTOP_SAT	0x08
 #define CVTOP_ABS	0x10
 
+/* 0x04 == 32 bit */
+/* 0x40 == dst is float */
+/* 0x80 == src is float */
 #define CVT_F32_F32 0xc4
 #define CVT_F32_S32 0x44
 #define CVT_F32_U32 0x64
@@ -795,7 +814,7 @@ emit_precossin(struct nv50_pc *pc, struct nv50_reg *dst, struct nv50_reg *src)
 
 static void
 emit_cvt(struct nv50_pc *pc, struct nv50_reg *dst, struct nv50_reg *src,
-	 int wp, unsigned cop, unsigned fmt)
+	 int wp, unsigned cvn, unsigned fmt)
 {
 	struct nv50_program_exec *e;
 
@@ -804,7 +823,7 @@ emit_cvt(struct nv50_pc *pc, struct nv50_reg *dst, struct nv50_reg *src,
 
 	e->inst[0] |= 0xa0000000;
 	e->inst[1] |= 0x00004000;
-	e->inst[1] |= (cop << 16);
+	e->inst[1] |= (cvn << 16);
 	e->inst[1] |= (fmt << 24);
 	set_src_0(pc, src, e);
 
@@ -821,49 +840,80 @@ emit_cvt(struct nv50_pc *pc, struct nv50_reg *dst, struct nv50_reg *src,
 	emit(pc, e);
 }
 
+/* nv50 Condition codes:
+ *  0x1 = LT
+ *  0x2 = EQ
+ *  0x3 = LE
+ *  0x4 = GT
+ *  0x5 = NE
+ *  0x6 = GE
+ *  0x7 = set condition code ? (used before bra.lt/le/gt/ge)
+ *  0x8 = unordered bit (allows NaN)
+ */
 static void
-emit_set(struct nv50_pc *pc, unsigned c_op, struct nv50_reg *dst,
+emit_set(struct nv50_pc *pc, unsigned ccode, struct nv50_reg *dst, int wp,
 	 struct nv50_reg *src0, struct nv50_reg *src1)
 {
+	static const unsigned cc_swapped[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
+
 	struct nv50_program_exec *e = exec(pc);
-	unsigned inv_cop[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
 	struct nv50_reg *rdst;
 
-	assert(c_op <= 7);
+	assert(ccode < 16);
 	if (check_swap_src_0_1(pc, &src0, &src1))
-		c_op = inv_cop[c_op];
+		ccode = cc_swapped[ccode & 7] | (ccode & 8);
 
 	rdst = dst;
-	if (dst->type != P_TEMP)
+	if (dst && dst->type != P_TEMP)
 		dst = alloc_temp(pc, NULL);
 
 	/* set.u32 */
 	set_long(pc, e);
 	e->inst[0] |= 0xb0000000;
-	e->inst[1] |= (3 << 29);
-	e->inst[1] |= (c_op << 14);
-	/*XXX: breaks things, .u32 by default?
-	 *     decuda will disasm as .u16 and use .lo/.hi regs, but this
-	 *     doesn't seem to match what the hw actually does.
-	inst[1] |= 0x04000000; << breaks things.. .u32 by default?
+	e->inst[1] |= 0x60000000 | (ccode << 14);
+
+	/* XXX: decuda will disasm as .u16 and use .lo/.hi regs, but
+	 * that doesn't seem to match what the hw actually does
+	e->inst[1] |= 0x04000000; << breaks things, u32 by default ?
 	 */
-	set_dst(pc, dst, e);
+
+	if (wp >= 0)
+		set_pred_wr(pc, 1, wp, e);
+	if (dst)
+		set_dst(pc, dst, e);
+	else {
+		e->inst[0] |= 0x000001fc;
+		e->inst[1] |= 0x00000008;
+	}
+
 	set_src_0(pc, src0, e);
 	set_src_1(pc, src1, e);
-	emit(pc, e);
 
-	/* cvt.f32.u32 */
-	e = exec(pc);
-	e->inst[0] = 0xa0000001;
-	e->inst[1] = 0x64014780;
-	set_dst(pc, rdst, e);
-	set_src_0(pc, dst, e);
 	emit(pc, e);
 
-	if (dst != rdst)
+	/* cvt.f32.u32/s32 (?) if we didn't only write the predicate */
+	if (rdst)
+		emit_cvt(pc, rdst, dst, -1, CVTOP_ABS | CVTOP_RN, CVT_F32_S32);
+	if (rdst && rdst != dst)
 		free_temp(pc, dst);
 }
 
+static INLINE unsigned
+map_tgsi_setop_cc(unsigned op)
+{
+	switch (op) {
+	case TGSI_OPCODE_SLT: return 0x1;
+	case TGSI_OPCODE_SGE: return 0x6;
+	case TGSI_OPCODE_SEQ: return 0x2;
+	case TGSI_OPCODE_SGT: return 0x4;
+	case TGSI_OPCODE_SLE: return 0x3;
+	case TGSI_OPCODE_SNE: return 0xd;
+	default:
+		assert(0);
+		return 0;
+	}
+}
+
 static INLINE void
 emit_flr(struct nv50_pc *pc, struct nv50_reg *dst, struct nv50_reg *src)
 {
@@ -890,6 +940,12 @@ emit_abs(struct nv50_pc *pc, struct nv50_reg *dst, struct nv50_reg *src)
 	emit_cvt(pc, dst, src, -1, CVTOP_ABS, CVT_F32_F32);
 }
 
+static INLINE void
+emit_sat(struct nv50_pc *pc, struct nv50_reg *dst, struct nv50_reg *src)
+{
+	emit_cvt(pc, dst, src, -1, CVTOP_SAT, CVT_F32_F32);
+}
+
 static void
 emit_lit(struct nv50_pc *pc, struct nv50_reg **dst, unsigned mask,
 	 struct nv50_reg **src)
@@ -1159,6 +1215,70 @@ negate_supported(const struct tgsi_full_instruction *insn, int i)
 	}
 }
 
+/* Return a read mask for source registers deduced from opcode & write mask. */
+static unsigned
+nv50_tgsi_src_mask(const struct tgsi_full_instruction *insn, int c)
+{
+	unsigned x, mask = insn->FullDstRegisters[0].DstRegister.WriteMask;
+
+	switch (insn->Instruction.Opcode) {
+	case TGSI_OPCODE_COS:
+	case TGSI_OPCODE_SIN:
+		return (mask & 0x8) | ((mask & 0x7) ? 0x1 : 0x0);
+	case TGSI_OPCODE_DP3:
+		return 0x7;
+	case TGSI_OPCODE_DP4:
+	case TGSI_OPCODE_DPH:
+	case TGSI_OPCODE_KIL: /* WriteMask ignored */
+		return 0xf;
+	case TGSI_OPCODE_DST:
+		return mask & (c ? 0xa : 0x6);
+	case TGSI_OPCODE_EX2:
+	case TGSI_OPCODE_LG2:
+	case TGSI_OPCODE_POW:
+	case TGSI_OPCODE_RCP:
+	case TGSI_OPCODE_RSQ:
+	case TGSI_OPCODE_SCS:
+		return 0x1;
+	case TGSI_OPCODE_LIT:
+		return 0xb;
+	case TGSI_OPCODE_TEX:
+	case TGSI_OPCODE_TXP:
+	{
+		const struct tgsi_instruction_ext_texture *tex;
+
+		assert(insn->Instruction.Extended);
+		tex = &insn->InstructionExtTexture;
+
+		mask = 0x7;
+		if (insn->Instruction.Opcode == TGSI_OPCODE_TXP)
+			mask |= 0x8;
+
+		switch (tex->Texture) {
+		case TGSI_TEXTURE_1D:
+			mask &= 0x9;
+			break;
+		case TGSI_TEXTURE_2D:
+			mask &= 0xb;
+			break;
+		default:
+			break;
+		}
+	}
+		return mask;
+	case TGSI_OPCODE_XPD:
+		x = 0;
+		if (mask & 1) x |= 0x6;
+		if (mask & 2) x |= 0x5;
+		if (mask & 4) x |= 0x3;
+		return x;
+	default:
+		break;
+	}
+
+	return mask;
+}
+
 static struct nv50_reg *
 tgsi_dst(struct nv50_pc *pc, int c, const struct tgsi_full_dst_register *dst)
 {
@@ -1258,93 +1378,126 @@ tgsi_src(struct nv50_pc *pc, int chan, const struct tgsi_full_src_register *src,
 	return r;
 }
 
-/* returns TRUE if instruction can overwrite sources before they're read */
+/* return TRUE for ops that produce only a single result */
 static boolean
-direct2dest_op(const struct tgsi_full_instruction *insn)
+is_scalar_op(unsigned op)
 {
-	if (insn->Instruction.Saturate)
-		return FALSE;
-
-	switch (insn->Instruction.Opcode) {
+	switch (op) {
 	case TGSI_OPCODE_COS:
+	case TGSI_OPCODE_DP2:
 	case TGSI_OPCODE_DP3:
 	case TGSI_OPCODE_DP4:
 	case TGSI_OPCODE_DPH:
-	case TGSI_OPCODE_KIL:
-	case TGSI_OPCODE_LIT:
+	case TGSI_OPCODE_EX2:
+	case TGSI_OPCODE_LG2:
 	case TGSI_OPCODE_POW:
 	case TGSI_OPCODE_RCP:
 	case TGSI_OPCODE_RSQ:
-	case TGSI_OPCODE_SCS:
 	case TGSI_OPCODE_SIN:
+		/*
+	case TGSI_OPCODE_KIL:
+	case TGSI_OPCODE_LIT:
+	case TGSI_OPCODE_SCS:
+		*/
+		return TRUE;
+	default:
+		return FALSE;
+	}
+}
+
+/* Returns a bitmask indicating which dst components depend
+ * on source s, component c (reverse of nv50_tgsi_src_mask).
+ */
+static unsigned
+nv50_tgsi_dst_revdep(unsigned op, int s, int c)
+{
+	if (is_scalar_op(op))
+		return 0x1;
+
+	switch (op) {
+	case TGSI_OPCODE_DST:
+		return (1 << c) & (s ? 0xa : 0x6);
+	case TGSI_OPCODE_XPD:
+		switch (c) {
+		case 0: return 0x6;
+		case 1: return 0x5;
+		case 2: return 0x3;
+		case 3: return 0x0;
+		default:
+			assert(0);
+			return 0x0;
+		}
+	case TGSI_OPCODE_LIT:
+	case TGSI_OPCODE_SCS:
 	case TGSI_OPCODE_TEX:
 	case TGSI_OPCODE_TXP:
-		return FALSE;
+		/* these take care of dangerous swizzles themselves */
+		return 0x0;
+	case TGSI_OPCODE_IF:
+	case TGSI_OPCODE_KIL:
+		/* don't call this function for these ops */
+		assert(0);
+		return 0;
 	default:
-		return TRUE;
+		/* linear vector instruction */
+		return (1 << c);
 	}
 }
 
 static boolean
-nv50_program_tx_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
+nv50_program_tx_insn(struct nv50_pc *pc,
+		     const struct tgsi_full_instruction *inst)
 {
-	const struct tgsi_full_instruction *inst = &tok->FullInstruction;
-	struct nv50_reg *rdst[4], *dst[4], *src[3][4], *temp;
+	struct nv50_reg *rdst[4], *dst[4], *brdc, *src[3][4], *temp;
 	unsigned mask, sat, unit;
-	boolean assimilate = FALSE;
 	int i, c;
 
 	mask = inst->FullDstRegisters[0].DstRegister.WriteMask;
 	sat = inst->Instruction.Saturate == TGSI_SAT_ZERO_ONE;
 
+	memset(src, 0, sizeof(src));
+
 	for (c = 0; c < 4; c++) {
-		if (mask & (1 << c))
+		if ((mask & (1 << c)) && !pc->r_dst[c])
 			dst[c] = tgsi_dst(pc, c, &inst->FullDstRegisters[0]);
 		else
-			dst[c] = NULL;
-		rdst[c] = NULL;
-		src[0][c] = NULL;
-		src[1][c] = NULL;
-		src[2][c] = NULL;
+			dst[c] = pc->r_dst[c];
+		rdst[c] = dst[c];
 	}
 
 	for (i = 0; i < inst->Instruction.NumSrcRegs; i++) {
 		const struct tgsi_full_src_register *fs = &inst->FullSrcRegisters[i];
+		unsigned src_mask;
+		boolean neg_supp;
+
+		src_mask = nv50_tgsi_src_mask(inst, i);
+		neg_supp = negate_supported(inst, i);
 
 		if (fs->SrcRegister.File == TGSI_FILE_SAMPLER)
 			unit = fs->SrcRegister.Index;
 
 		for (c = 0; c < 4; c++)
-			src[i][c] = tgsi_src(pc, c, fs,
-					     negate_supported(inst, i));
+			if (src_mask & (1 << c))
+				src[i][c] = tgsi_src(pc, c, fs, neg_supp);
 	}
 
-	if (sat) {
-		for (c = 0; c < 4; c++) {
-			rdst[c] = dst[c];
-			dst[c] = temp_temp(pc);
-		}
+	brdc = temp = pc->r_brdc;
+	if (brdc && brdc->type != P_TEMP) {
+		temp = temp_temp(pc);
+		if (sat)
+			brdc = temp;
 	} else
-	if (direct2dest_op(inst)) {
+	if (sat) {
 		for (c = 0; c < 4; c++) {
-			if (!dst[c] || dst[c]->type != P_TEMP)
+			if (!(mask & (1 << c)) || dst[c]->type == P_TEMP)
 				continue;
-
-			for (i = c + 1; i < 4; i++) {
-				if (dst[c] == src[0][i] ||
-				    dst[c] == src[1][i] ||
-				    dst[c] == src[2][i])
-					break;
-			}
-			if (i == 4)
-				continue;
-
-			assimilate = TRUE;
 			rdst[c] = dst[c];
-			dst[c] = alloc_temp(pc, NULL);
+			dst[c] = temp_temp(pc);
 		}
 	}
 
+	assert(brdc || !is_scalar_op(inst->Instruction.Opcode));
+
 	switch (inst->Instruction.Opcode) {
 	case TGSI_OPCODE_ABS:
 		for (c = 0; c < 4; c++) {
@@ -1360,74 +1513,56 @@ nv50_program_tx_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
 			emit_add(pc, dst[c], src[0][c], src[1][c]);
 		}
 		break;
-	case TGSI_OPCODE_COS:
-		temp = temp_temp(pc);
-		emit_precossin(pc, temp, src[0][0]);
-		emit_flop(pc, 5, temp, temp);
+	case TGSI_OPCODE_CEIL:
 		for (c = 0; c < 4; c++) {
 			if (!(mask & (1 << c)))
 				continue;
-			emit_mov(pc, dst[c], temp);
+			emit_cvt(pc, dst[c], src[0][c], -1,
+				 CVTOP_CEIL, CVT_F32_F32);
+		}
+		break;
+	case TGSI_OPCODE_COS:
+		if (mask & 8) {
+			emit_precossin(pc, temp, src[0][3]);
+			emit_flop(pc, 5, dst[3], temp);
+			if (!(mask &= 7))
+				break;
+			if (temp == dst[3])
+				temp = brdc = temp_temp(pc);
 		}
+		emit_precossin(pc, temp, src[0][0]);
+		emit_flop(pc, 5, brdc, temp);
 		break;
 	case TGSI_OPCODE_DP3:
-		temp = temp_temp(pc);
 		emit_mul(pc, temp, src[0][0], src[1][0]);
 		emit_mad(pc, temp, src[0][1], src[1][1], temp);
-		emit_mad(pc, temp, src[0][2], src[1][2], temp);
-		for (c = 0; c < 4; c++) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_mov(pc, dst[c], temp);
-		}
+		emit_mad(pc, brdc, src[0][2], src[1][2], temp);
 		break;
 	case TGSI_OPCODE_DP4:
-		temp = temp_temp(pc);
 		emit_mul(pc, temp, src[0][0], src[1][0]);
 		emit_mad(pc, temp, src[0][1], src[1][1], temp);
 		emit_mad(pc, temp, src[0][2], src[1][2], temp);
-		emit_mad(pc, temp, src[0][3], src[1][3], temp);
-		for (c = 0; c < 4; c++) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_mov(pc, dst[c], temp);
-		}
+		emit_mad(pc, brdc, src[0][3], src[1][3], temp);
 		break;
 	case TGSI_OPCODE_DPH:
-		temp = temp_temp(pc);
 		emit_mul(pc, temp, src[0][0], src[1][0]);
 		emit_mad(pc, temp, src[0][1], src[1][1], temp);
 		emit_mad(pc, temp, src[0][2], src[1][2], temp);
-		emit_add(pc, temp, src[1][3], temp);
-		for (c = 0; c < 4; c++) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_mov(pc, dst[c], temp);
-		}
+		emit_add(pc, brdc, src[1][3], temp);
 		break;
 	case TGSI_OPCODE_DST:
-	{
-		struct nv50_reg *one = alloc_immd(pc, 1.0);
-		if (mask & (1 << 0))
-			emit_mov(pc, dst[0], one);
 		if (mask & (1 << 1))
 			emit_mul(pc, dst[1], src[0][1], src[1][1]);
 		if (mask & (1 << 2))
 			emit_mov(pc, dst[2], src[0][2]);
 		if (mask & (1 << 3))
 			emit_mov(pc, dst[3], src[1][3]);
-		FREE(one);
-	}
+		if (mask & (1 << 0))
+			emit_mov_immdval(pc, dst[0], 1.0f);
 		break;
 	case TGSI_OPCODE_EX2:
-		temp = temp_temp(pc);
 		emit_preex2(pc, temp, src[0][0]);
-		emit_flop(pc, 6, temp, temp);
-		for (c = 0; c < 4; c++) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_mov(pc, dst[c], temp);
-		}
+		emit_flop(pc, 6, brdc, temp);
 		break;
 	case TGSI_OPCODE_FLR:
 		for (c = 0; c < 4; c++) {
@@ -1450,19 +1585,12 @@ nv50_program_tx_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
 		emit_kil(pc, src[0][1]);
 		emit_kil(pc, src[0][2]);
 		emit_kil(pc, src[0][3]);
-		pc->p->cfg.fp.regs[2] |= 0x00100000;
 		break;
 	case TGSI_OPCODE_LIT:
 		emit_lit(pc, &dst[0], mask, &src[0][0]);
 		break;
 	case TGSI_OPCODE_LG2:
-		temp = temp_temp(pc);
-		emit_flop(pc, 3, temp, src[0][0]);
-		for (c = 0; c < 4; c++) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_mov(pc, dst[c], temp);
-		}
+		emit_flop(pc, 3, brdc, src[0][0]);
 		break;
 	case TGSI_OPCODE_LRP:
 		temp = temp_temp(pc);
@@ -1510,31 +1638,18 @@ nv50_program_tx_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
 		}
 		break;
 	case TGSI_OPCODE_POW:
-		temp = temp_temp(pc);
-		emit_pow(pc, temp, src[0][0], src[1][0]);
-		for (c = 0; c < 4; c++) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_mov(pc, dst[c], temp);
-		}
+		emit_pow(pc, brdc, src[0][0], src[1][0]);
 		break;
 	case TGSI_OPCODE_RCP:
-		for (c = 3; c >= 0; c--) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_flop(pc, 0, dst[c], src[0][0]);
-		}
+		emit_flop(pc, 0, brdc, src[0][0]);
 		break;
 	case TGSI_OPCODE_RSQ:
-		for (c = 3; c >= 0; c--) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_flop(pc, 2, dst[c], src[0][0]);
-		}
+		emit_flop(pc, 2, brdc, src[0][0]);
 		break;
 	case TGSI_OPCODE_SCS:
 		temp = temp_temp(pc);
-		emit_precossin(pc, temp, src[0][0]);
+		if (mask & 3)
+			emit_precossin(pc, temp, src[0][0]);
 		if (mask & (1 << 0))
 			emit_flop(pc, 5, dst[0], temp);
 		if (mask & (1 << 1))
@@ -1544,28 +1659,29 @@ nv50_program_tx_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
 		if (mask & (1 << 3))
 			emit_mov_immdval(pc, dst[3], 1.0);
 		break;
-	case TGSI_OPCODE_SGE:
-		for (c = 0; c < 4; c++) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_set(pc, 6, dst[c], src[0][c], src[1][c]);
-		}
-		break;
 	case TGSI_OPCODE_SIN:
-		temp = temp_temp(pc);
-		emit_precossin(pc, temp, src[0][0]);
-		emit_flop(pc, 4, temp, temp);
-		for (c = 0; c < 4; c++) {
-			if (!(mask & (1 << c)))
-				continue;
-			emit_mov(pc, dst[c], temp);
+		if (mask & 8) {
+			emit_precossin(pc, temp, src[0][3]);
+			emit_flop(pc, 4, dst[3], temp);
+			if (!(mask &= 7))
+				break;
+			if (temp == dst[3])
+				temp = brdc = temp_temp(pc);
 		}
+		emit_precossin(pc, temp, src[0][0]);
+		emit_flop(pc, 4, brdc, temp);
 		break;
 	case TGSI_OPCODE_SLT:
+	case TGSI_OPCODE_SGE:
+	case TGSI_OPCODE_SEQ:
+	case TGSI_OPCODE_SGT:
+	case TGSI_OPCODE_SLE:
+	case TGSI_OPCODE_SNE:
+		i = map_tgsi_setop_cc(inst->Instruction.Opcode);
 		for (c = 0; c < 4; c++) {
 			if (!(mask & (1 << c)))
 				continue;
-			emit_set(pc, 1, dst[c], src[0][c], src[1][c]);
+			emit_set(pc, i, dst[c], -1, src[0][c], src[1][c]);
 		}
 		break;
 	case TGSI_OPCODE_SUB:
@@ -1583,6 +1699,14 @@ nv50_program_tx_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
 		emit_tex(pc, dst, mask, src[0], unit,
 			 inst->InstructionExtTexture.Texture, TRUE);
 		break;
+	case TGSI_OPCODE_TRUNC:
+		for (c = 0; c < 4; c++) {
+			if (!(mask & (1 << c)))
+				continue;
+			emit_cvt(pc, dst[c], src[0][c], -1,
+				 CVTOP_TRUNC, CVT_F32_F32);
+		}
+		break;
 	case TGSI_OPCODE_XPD:
 		temp = temp_temp(pc);
 		if (mask & (1 << 0)) {
@@ -1607,17 +1731,22 @@ nv50_program_tx_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
 		return FALSE;
 	}
 
+	if (brdc) {
+		if (sat)
+			emit_sat(pc, brdc, brdc);
+		for (c = 0; c < 4; c++)
+			if ((mask & (1 << c)) && dst[c] != brdc)
+				emit_mov(pc, dst[c], brdc);
+	} else
 	if (sat) {
 		for (c = 0; c < 4; c++) {
 			if (!(mask & (1 << c)))
 				continue;
-			emit_cvt(pc, rdst[c], dst[c], -1, CVTOP_SAT,
-				 CVT_F32_F32);
+			/* in this case we saturate later */
+			if (dst[c]->type == P_TEMP && dst[c]->index < 0)
+				continue;
+			emit_sat(pc, rdst[c], dst[c]);
 		}
-	} else if (assimilate) {
-		for (c = 0; c < 4; c++)
-			if (rdst[c])
-				assimilate_temp(pc, rdst[c], dst[c]);
 	}
 
 	for (i = 0; i < inst->Instruction.NumSrcRegs; i++) {
@@ -1626,9 +1755,6 @@ nv50_program_tx_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
 				continue;
 			if (src[i][c]->index == -1 && src[i][c]->type == P_IMMD)
 				FREE(src[i][c]);
-			else
-			if (src[i][c]->acc == pc->insn_cur)
-				release_hw(pc, src[i][c]);
 		}
 	}
 
@@ -1636,180 +1762,271 @@ nv50_program_tx_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
 	return TRUE;
 }
 
-/* Adjust a bitmask that indicates what components of a source are used,
- * we use this in tx_prep so we only load interpolants that are needed.
- */
 static void
-insn_adjust_mask(const struct tgsi_full_instruction *insn, unsigned *mask)
+prep_inspect_insn(struct nv50_pc *pc, const struct tgsi_full_instruction *insn)
 {
-	const struct tgsi_instruction_ext_texture *tex;
-
-	switch (insn->Instruction.Opcode) {
-	case TGSI_OPCODE_DP3:
-		*mask = 0x7;
-		break;
-	case TGSI_OPCODE_DP4:
-	case TGSI_OPCODE_DPH:
-		*mask = 0xF;
-		break;
-	case TGSI_OPCODE_LIT:
-		*mask = 0xB;
-		break;
-	case TGSI_OPCODE_RCP:
-	case TGSI_OPCODE_RSQ:
-		*mask = 0x1;
-		break;
-	case TGSI_OPCODE_TEX:
-	case TGSI_OPCODE_TXP:
-		assert(insn->Instruction.Extended);
-		tex = &insn->InstructionExtTexture;
-
-		*mask = 0x7;
-		if (tex->Texture == TGSI_TEXTURE_1D)
-			*mask = 0x1;
-		else
-		if (tex->Texture == TGSI_TEXTURE_2D)
-			*mask = 0x3;
-
-		if (insn->Instruction.Opcode == TGSI_OPCODE_TXP)
-			*mask |= 0x8;
-		break;
-	default:
-		break;
-	}
-}
-
-static void
-prep_inspect_insn(struct nv50_pc *pc, const union tgsi_full_token *tok,
-		  unsigned *r_usage[2])
-{
-	const struct tgsi_full_instruction *insn;
+	struct nv50_reg *reg = NULL;
 	const struct tgsi_full_src_register *src;
 	const struct tgsi_dst_register *dst;
+	unsigned i, c, k, mask;
 
-	unsigned i, c, k, n, mask, *acc_p;
-
-	insn = &tok->FullInstruction;
 	dst = &insn->FullDstRegisters[0].DstRegister;
 	mask = dst->WriteMask;
 
-	if (!r_usage[0])
-		r_usage[0] = CALLOC(pc->temp_nr * 4, sizeof(unsigned));
-	if (!r_usage[1])
-		r_usage[1] = CALLOC(pc->attr_nr * 4, sizeof(unsigned));
+        if (dst->File == TGSI_FILE_TEMPORARY)
+                reg = pc->temp;
+        else
+        if (dst->File == TGSI_FILE_OUTPUT)
+                reg = pc->result;
 
-	if (dst->File == TGSI_FILE_TEMPORARY) {
+	if (reg) {
 		for (c = 0; c < 4; c++) {
 			if (!(mask & (1 << c)))
 				continue;
-			r_usage[0][dst->Index * 4 + c] = pc->insn_nr;
+			reg[dst->Index * 4 + c].acc = pc->insn_nr;
 		}
 	}
 
 	for (i = 0; i < insn->Instruction.NumSrcRegs; i++) {
 		src = &insn->FullSrcRegisters[i];
 
-		switch (src->SrcRegister.File) {
-		case TGSI_FILE_TEMPORARY:
-			acc_p = r_usage[0];
-			break;
-		case TGSI_FILE_INPUT:
-			acc_p = r_usage[1];
-			break;
-		default:
+		if (src->SrcRegister.File == TGSI_FILE_TEMPORARY)
+			reg = pc->temp;
+		else
+		if (src->SrcRegister.File == TGSI_FILE_INPUT)
+			reg = pc->attr;
+		else
 			continue;
-		}
 
-		insn_adjust_mask(insn, &mask);
+		mask = nv50_tgsi_src_mask(insn, i);
 
 		for (c = 0; c < 4; c++) {
 			if (!(mask & (1 << c)))
 				continue;
-
 			k = tgsi_util_get_full_src_register_extswizzle(src, c);
-			switch (k) {
-			case TGSI_EXTSWIZZLE_X:
-			case TGSI_EXTSWIZZLE_Y:
-			case TGSI_EXTSWIZZLE_Z:
-			case TGSI_EXTSWIZZLE_W:
-				n = src->SrcRegister.Index * 4 + k;
-				acc_p[n] = pc->insn_nr;
-				break;
-			default:
-				break;
-			}
+
+			if (k > TGSI_EXTSWIZZLE_W)
+				continue;
+
+			reg[src->SrcRegister.Index * 4 + k].acc = pc->insn_nr;
 		}
 	}
 }
 
+/* Returns a bitmask indicating which dst components need to be
+ * written to temporaries first to avoid 'corrupting' sources.
+ *
+ * m[i]   (out) indicate component to write in the i-th position
+ * rdep[c] (in) bitmasks of dst[i] that require dst[c] as source
+ */
 static unsigned
-load_fp_attrib(struct nv50_pc *pc, int i, unsigned *acc, int *mid,
-	       int *aid, int *p_oid)
+nv50_revdep_reorder(unsigned m[4], unsigned rdep[4])
 {
-	struct nv50_reg *iv;
-	int oid, c, n;
-	unsigned mask = 0;
+	unsigned i, c, x, unsafe;
 
-	iv = (pc->interp_mode[i] & INTERP_CENTROID) ? pc->iv_c : pc->iv_p;
+	for (c = 0; c < 4; c++)
+		m[c] = c;
 
-	for (c = 0, n = i * 4; c < 4; c++, n++) {
-		oid = (*p_oid)++;
-		pc->attr[n].type = P_TEMP;
-		pc->attr[n].index = i;
+	/* Swap as long as a dst component written earlier is depended on
+	 * by one written later, but the next one isn't depended on by it.
+	 */
+	for (c = 0; c < 3; c++) {
+		if (rdep[m[c + 1]] & (1 << m[c]))
+			continue; /* if next one is depended on by us */
+		for (i = c + 1; i < 4; i++)
+			/* if we are depended on by a later one */
+			if (rdep[m[c]] & (1 << m[i]))
+				break;
+		if (i == 4)
+			continue;
+		/* now, swap */
+		x = m[c];
+		m[c] = m[c + 1];
+		m[c + 1] = x;
+
+		/* restart */
+		c = 0;
+	}
+
+	/* mark dependencies that could not be resolved by reordering */
+	for (i = 0; i < 3; ++i)
+		for (c = i + 1; c < 4; ++c)
+			if (rdep[m[i]] & (1 << m[c]))
+				unsafe |= (1 << i);
+
+	/* NOTE: $unsafe is with respect to order, not component */
+	return unsafe;
+}
 
-		if (pc->attr[n].acc == acc[n])
+/* Select a suitable dst register for broadcasting scalar results,
+ * or return NULL if we have to allocate an extra TEMP.
+ *
+ * If e.g. only 1 component is written, we may also emit the final
+ * result to a write-only register.
+ */
+static struct nv50_reg *
+tgsi_broadcast_dst(struct nv50_pc *pc,
+		   const struct tgsi_full_dst_register *fd, unsigned mask)
+{
+	if (fd->DstRegister.File == TGSI_FILE_TEMPORARY) {
+		int c = ffs(~mask & fd->DstRegister.WriteMask);
+		if (c)
+			return tgsi_dst(pc, c - 1, fd);
+	} else {
+		int c = ffs(fd->DstRegister.WriteMask) - 1;
+		if ((1 << c) == fd->DstRegister.WriteMask)
+			return tgsi_dst(pc, c, fd);
+	}
+
+	return NULL;
+}
+
+/* Scan source swizzles and return a bitmask indicating dst regs that
+ * also occur among the src regs, and fill rdep for nv50_revdep_reoder.
+ */
+static unsigned
+nv50_tgsi_scan_swizzle(const struct tgsi_full_instruction *insn,
+		       unsigned rdep[4])
+{
+	const struct tgsi_full_dst_register *fd = &insn->FullDstRegisters[0];
+	const struct tgsi_full_src_register *fs;
+	unsigned i, deqs = 0;
+
+	for (i = 0; i < 4; ++i)
+		rdep[i] = 0;
+
+	for (i = 0; i < insn->Instruction.NumSrcRegs; i++) {
+		unsigned chn, mask = nv50_tgsi_src_mask(insn, i);
+		boolean neg_supp = negate_supported(insn, i);
+
+		fs = &insn->FullSrcRegisters[i];
+		if (fs->SrcRegister.File != fd->DstRegister.File ||
+		    fs->SrcRegister.Index != fd->DstRegister.Index)
 			continue;
-		mask |= (1 << c);
 
-		pc->attr[n].acc = acc[n];
-		pc->attr[n].rhw = pc->attr[n].hw = -1;
-		alloc_reg(pc, &pc->attr[n]);
+		for (chn = 0; chn < 4; ++chn) {
+			unsigned s, c;
+
+			if (!(mask & (1 << chn))) /* src is not read */
+				continue;
+			c = tgsi_util_get_full_src_register_extswizzle(fs, chn);
+			s = tgsi_util_get_full_src_register_sign_mode(fs, chn);
 
-		pc->attr[n].rhw = (*aid)++;
-		emit_interp(pc, &pc->attr[n], iv, pc->interp_mode[i]);
+			if (c > TGSI_EXTSWIZZLE_W ||
+			    !(fd->DstRegister.WriteMask & (1 << c)))
+				continue;
 
-		pc->p->cfg.fp.map[(*mid) / 4] |= oid << (8 * ((*mid) % 4));
-		(*mid)++;
-		pc->p->cfg.fp.regs[1] += 0x00010001;
+			/* no danger if src is copied to TEMP first */
+			if ((s != TGSI_UTIL_SIGN_KEEP) &&
+			    (s != TGSI_UTIL_SIGN_TOGGLE || !neg_supp))
+				continue;
+
+			rdep[c] |= nv50_tgsi_dst_revdep(
+				insn->Instruction.Opcode, i, chn);
+			deqs |= (1 << c);
+		}
 	}
 
-	return mask;
+	return deqs;
 }
 
 static boolean
-nv50_program_tx_prep(struct nv50_pc *pc)
+nv50_tgsi_insn(struct nv50_pc *pc, const union tgsi_full_token *tok)
 {
-	struct tgsi_parse_context p;
-	boolean ret = FALSE;
-	unsigned i, c;
-	unsigned fcol, bcol, fcrd, depr;
+	struct tgsi_full_instruction insn = tok->FullInstruction;
+	const struct tgsi_full_dst_register *fd;
+	unsigned i, deqs, rdep[4], m[4];
+
+	fd = &tok->FullInstruction.FullDstRegisters[0];
+	deqs = nv50_tgsi_scan_swizzle(&insn, rdep);
+
+	if (is_scalar_op(insn.Instruction.Opcode)) {
+		pc->r_brdc = tgsi_broadcast_dst(pc, fd, deqs);
+		if (!pc->r_brdc)
+			pc->r_brdc = temp_temp(pc);
+		return nv50_program_tx_insn(pc, &insn);
+	}
+	pc->r_brdc = NULL;
+
+	if (!deqs)
+		return nv50_program_tx_insn(pc, &insn);
+
+	deqs = nv50_revdep_reorder(m, rdep);
 
-	/* count (centroid) perspective interpolations */
-	unsigned centroid_loads = 0;
-	unsigned perspect_loads = 0;
+	for (i = 0; i < 4; ++i) {
+		assert(pc->r_dst[m[i]] == NULL);
 
-	/* track register access for temps and attrs */
-	unsigned *r_usage[2];
-	r_usage[0] = NULL;
-	r_usage[1] = NULL;
+		insn.FullDstRegisters[0].DstRegister.WriteMask =
+			fd->DstRegister.WriteMask & (1 << m[i]);
 
-	depr = fcol = bcol = fcrd = 0xffff;
+		if (!insn.FullDstRegisters[0].DstRegister.WriteMask)
+			continue;
+
+		if (deqs & (1 << i))
+			pc->r_dst[m[i]] = alloc_temp(pc, NULL);
 
-	if (pc->p->type == PIPE_SHADER_FRAGMENT) {
-		pc->p->cfg.fp.regs[0] = 0x01000404;
-		pc->p->cfg.fp.regs[1] = 0x00000400;
+		if (!nv50_program_tx_insn(pc, &insn))
+			return FALSE;
 	}
 
-	tgsi_parse_init(&p, pc->p->pipe.tokens);
-	while (!tgsi_parse_end_of_tokens(&p)) {
-		const union tgsi_full_token *tok = &p.FullToken;
+	for (i = 0; i < 4; i++) {
+		struct nv50_reg *reg = pc->r_dst[i];
+		if (!reg)
+			continue;
+		pc->r_dst[i] = NULL;
+
+		if (insn.Instruction.Saturate == TGSI_SAT_ZERO_ONE)
+			emit_sat(pc, tgsi_dst(pc, i, fd), reg);
+		else
+			emit_mov(pc, tgsi_dst(pc, i, fd), reg);
+		free_temp(pc, reg);
+	}
 
-		tgsi_parse_token(&p);
+	return TRUE;
+}
+
+static void
+load_interpolant(struct nv50_pc *pc, struct nv50_reg *reg)
+{
+	struct nv50_reg *iv, **ppiv;
+	unsigned mode = pc->interp_mode[reg->index];
+
+	ppiv = (mode & INTERP_CENTROID) ? &pc->iv_c : &pc->iv_p;
+	iv = *ppiv;
+
+	if ((mode & INTERP_PERSPECTIVE) && !iv) {
+		iv = *ppiv = alloc_temp(pc, NULL);
+		iv->rhw = popcnt4(pc->p->cfg.regs[1] >> 24) - 1;
+
+		emit_interp(pc, iv, NULL, mode & INTERP_CENTROID);
+		emit_flop(pc, 0, iv, iv);
+
+		/* XXX: when loading interpolants dynamically, move these
+		 * to the program head, or make sure it can't be skipped.
+		 */
+	}
+
+	emit_interp(pc, reg, iv, mode);
+}
+
+static boolean
+nv50_program_tx_prep(struct nv50_pc *pc)
+{
+	struct tgsi_parse_context tp;
+	struct nv50_program *p = pc->p;
+	boolean ret = FALSE;
+	unsigned i, c, flat_nr = 0;
+
+	tgsi_parse_init(&tp, pc->p->pipe.tokens);
+	while (!tgsi_parse_end_of_tokens(&tp)) {
+		const union tgsi_full_token *tok = &tp.FullToken;
+
+		tgsi_parse_token(&tp);
 		switch (tok->Token.Type) {
 		case TGSI_TOKEN_TYPE_IMMEDIATE:
 		{
 			const struct tgsi_full_immediate *imm =
-				&p.FullToken.FullImmediate;
+				&tp.FullToken.FullImmediate;
 
 			ctor_immd(pc, imm->u[0].Float,
 				      imm->u[1].Float,
@@ -1820,78 +2037,61 @@ nv50_program_tx_prep(struct nv50_pc *pc)
 		case TGSI_TOKEN_TYPE_DECLARATION:
 		{
 			const struct tgsi_full_declaration *d;
-			unsigned last, first, mode;
+			unsigned si, last, first, mode;
 
-			d = &p.FullToken.FullDeclaration;
+			d = &tp.FullToken.FullDeclaration;
 			first = d->DeclarationRange.First;
 			last = d->DeclarationRange.Last;
 
 			switch (d->Declaration.File) {
 			case TGSI_FILE_TEMPORARY:
-				if (pc->temp_nr < (last + 1))
-					pc->temp_nr = last + 1;
 				break;
 			case TGSI_FILE_OUTPUT:
-				if (pc->result_nr < (last + 1))
-					pc->result_nr = last + 1;
-
-				if (!d->Declaration.Semantic)
+				if (!d->Declaration.Semantic ||
+				    p->type == PIPE_SHADER_FRAGMENT)
 					break;
 
+				si = d->Semantic.SemanticIndex;
 				switch (d->Semantic.SemanticName) {
-				case TGSI_SEMANTIC_POSITION:
-					depr = first;
-					pc->p->cfg.fp.regs[2] |= 0x00000100;
-					pc->p->cfg.fp.regs[3] |= 0x00000011;
+				case TGSI_SEMANTIC_BCOLOR:
+					p->cfg.two_side[si].hw = first;
+					if (p->cfg.io_nr > first)
+						p->cfg.io_nr = first;
+					break;
+				case TGSI_SEMANTIC_PSIZE:
+					p->cfg.psiz = first;
+					if (p->cfg.io_nr > first)
+						p->cfg.io_nr = first;
+					break;
+					/*
+				case TGSI_SEMANTIC_CLIP_DISTANCE:
+					p->cfg.clpd = MIN2(p->cfg.clpd, first);
 					break;
+					*/
 				default:
 					break;
 				}
-
 				break;
 			case TGSI_FILE_INPUT:
 			{
-				if (pc->attr_nr < (last + 1))
-					pc->attr_nr = last + 1;
-
-				if (pc->p->type != PIPE_SHADER_FRAGMENT)
+				if (p->type != PIPE_SHADER_FRAGMENT)
 					break;
 
 				switch (d->Declaration.Interpolate) {
 				case TGSI_INTERPOLATE_CONSTANT:
 					mode = INTERP_FLAT;
+					flat_nr++;
 					break;
 				case TGSI_INTERPOLATE_PERSPECTIVE:
 					mode = INTERP_PERSPECTIVE;
+					p->cfg.regs[1] |= 0x08 << 24;
 					break;
 				default:
 					mode = INTERP_LINEAR;
 					break;
 				}
-
-				if (d->Declaration.Semantic) {
-					switch (d->Semantic.SemanticName) {
-					case TGSI_SEMANTIC_POSITION:
-						fcrd = first;
-						break;
-					case TGSI_SEMANTIC_COLOR:
-						fcol = first;
-						mode = INTERP_PERSPECTIVE;
-						break;
-					case TGSI_SEMANTIC_BCOLOR:
-						bcol = first;
-						mode = INTERP_PERSPECTIVE;
-						break;
-					}
-				}
-
-				if (d->Declaration.Centroid) {
+				if (d->Declaration.Centroid)
 					mode |= INTERP_CENTROID;
-					if (mode & INTERP_PERSPECTIVE)
-						centroid_loads++;
-				} else
-				if (mode & INTERP_PERSPECTIVE)
-					perspect_loads++;
 
 				assert(last < 32);
 				for (i = first; i <= last; i++)
@@ -1899,8 +2099,6 @@ nv50_program_tx_prep(struct nv50_pc *pc)
 			}
 				break;
 			case TGSI_FILE_CONSTANT:
-				if (pc->param_nr < (last + 1))
-					pc->param_nr = last + 1;
 				break;
 			case TGSI_FILE_SAMPLER:
 				break;
@@ -1913,182 +2111,155 @@ nv50_program_tx_prep(struct nv50_pc *pc)
 			break;
 		case TGSI_TOKEN_TYPE_INSTRUCTION:
 			pc->insn_nr++;
-			prep_inspect_insn(pc, tok, r_usage);
+			prep_inspect_insn(pc, &tok->FullInstruction);
 			break;
 		default:
 			break;
 		}
 	}
 
-	if (pc->temp_nr) {
-		pc->temp = CALLOC(pc->temp_nr * 4, sizeof(struct nv50_reg));
-		if (!pc->temp)
-			goto out_err;
+	if (p->type == PIPE_SHADER_VERTEX) {
+		int rid = 0;
 
-		for (i = 0; i < pc->temp_nr; i++) {
-			for (c = 0; c < 4; c++) {
-				pc->temp[i*4+c].type = P_TEMP;
-				pc->temp[i*4+c].hw = -1;
-				pc->temp[i*4+c].rhw = -1;
-				pc->temp[i*4+c].index = i;
-				pc->temp[i*4+c].acc = r_usage[0][i*4+c];
+		for (i = 0; i < pc->attr_nr * 4; ++i) {
+			if (pc->attr[i].acc) {
+				pc->attr[i].hw = rid++;
+				p->cfg.attr[i / 32] |= 1 << (i % 32);
 			}
 		}
-	}
-
-	if (pc->attr_nr) {
-		int oid = 4, mid = 4, aid = 0;
-		/* oid = VP output id
-		 * aid = FP attribute/interpolant id
-		 * mid = VP output mapping field ID
-		 */
 
-		pc->attr = CALLOC(pc->attr_nr * 4, sizeof(struct nv50_reg));
-		if (!pc->attr)
-			goto out_err;
+		for (i = 0, rid = 0; i < pc->result_nr; ++i) {
+			p->cfg.io[i].hw = rid;
+			p->cfg.io[i].id_vp = i;
 
-		if (pc->p->type == PIPE_SHADER_FRAGMENT) {
-			/* position should be loaded first */
-			if (fcrd != 0xffff) {
-				unsigned mask;
-				mid = 0;
-				mask = load_fp_attrib(pc, fcrd, r_usage[1],
-						      &mid, &aid, &oid);
-				oid = 0;
-				pc->p->cfg.fp.regs[1] |= (mask << 24);
-				pc->p->cfg.fp.map[0] = 0x04040404 * fcrd;
-			}
-			pc->p->cfg.fp.map[0] += 0x03020100;
-
-			/* should do MAD fcrd.xy, fcrd, SOME_CONST, fcrd */
-
-			if (perspect_loads) {
-				pc->iv_p = alloc_temp(pc, NULL);
-
-				if (!(pc->p->cfg.fp.regs[1] & 0x08000000)) {
-					pc->p->cfg.fp.regs[1] |= 0x08000000;
-					pc->iv_p->rhw = aid++;
-					emit_interp(pc, pc->iv_p, NULL,
-						    INTERP_LINEAR);
-					emit_flop(pc, 0, pc->iv_p, pc->iv_p);
-				} else {
-					pc->iv_p->rhw = aid - 1;
-					emit_flop(pc, 0, pc->iv_p,
-						  &pc->attr[fcrd * 4 + 3]);
-				}
+			for (c = 0; c < 4; ++c) {
+				int n = i * 4 + c;
+				if (!pc->result[n].acc)
+					continue;
+				pc->result[n].hw = rid++;
+				p->cfg.io[i].mask |= 1 << c;
 			}
+		}
 
-			if (centroid_loads) {
-				pc->iv_c = alloc_temp(pc, NULL);
-				pc->iv_c->rhw = pc->iv_p ? aid - 1 : aid++;
-				emit_interp(pc, pc->iv_c, NULL,
-					    INTERP_CENTROID);
-				emit_flop(pc, 0, pc->iv_c, pc->iv_c);
-				pc->p->cfg.fp.regs[1] |= 0x08000000;
-			}
+		for (c = 0; c < 2; ++c)
+			if (p->cfg.two_side[c].hw < 0x40)
+				p->cfg.two_side[c] = p->cfg.io[
+					p->cfg.two_side[c].hw];
 
-			for (c = 0; c < 4; c++) {
-				/* I don't know what these values do, but
-				 * let's set them like the blob does:
-				 */
-				if (fcol != 0xffff && r_usage[1][fcol * 4 + c])
-					pc->p->cfg.fp.regs[0] += 0x00010000;
-				if (bcol != 0xffff && r_usage[1][bcol * 4 + c])
-					pc->p->cfg.fp.regs[0] += 0x00010000;
-			}
-
-			for (i = 0; i < pc->attr_nr; i++)
-				load_fp_attrib(pc, i, r_usage[1],
-					       &mid, &aid, &oid);
+		if (p->cfg.psiz < 0x40)
+			p->cfg.psiz = p->cfg.io[p->cfg.psiz].hw;
+	} else
+	if (p->type == PIPE_SHADER_FRAGMENT) {
+		int rid, aid;
+		unsigned n = 0, m = pc->attr_nr - flat_nr;
 
-			if (pc->iv_p)
-				free_temp(pc, pc->iv_p);
-			if (pc->iv_c)
-				free_temp(pc, pc->iv_c);
+		int base = (TGSI_SEMANTIC_POSITION ==
+			    p->info.input_semantic_name[0]) ? 0 : 1;
 
-			pc->p->cfg.fp.high_map = (mid / 4);
-			pc->p->cfg.fp.high_map += ((mid % 4) ? 1 : 0);
-		} else {
-			/* vertex program */
-			for (i = 0; i < pc->attr_nr * 4; i++) {
-				pc->p->cfg.vp.attr[aid / 32] |=
-					(1 << (aid % 32));
-				pc->attr[i].type = P_ATTR;
-				pc->attr[i].hw = aid++;
-				pc->attr[i].index = i / 4;
+		/* non-flat interpolants have to be mapped to
+		 * the lower hardware IDs, so sort them:
+		 */
+		for (i = 0; i < pc->attr_nr; i++) {
+			if (pc->interp_mode[i] == INTERP_FLAT) {
+				p->cfg.io[m].id_vp = i + base;
+				p->cfg.io[m++].id_fp = i;
+			} else {
+				if (!(pc->interp_mode[i] & INTERP_PERSPECTIVE))
+					p->cfg.io[n].linear = TRUE;
+				p->cfg.io[n].id_vp = i + base;
+				p->cfg.io[n++].id_fp = i;
 			}
 		}
-	}
 
-	if (pc->result_nr) {
-		int rid = 0;
+		if (!base) /* set w-coordinate mask from perspective interp */
+			p->cfg.io[0].mask |= p->cfg.regs[1] >> 24;
 
-		pc->result = CALLOC(pc->result_nr * 4, sizeof(struct nv50_reg));
-		if (!pc->result)
-			goto out_err;
+		aid = popcnt4( /* if fcrd isn't contained in cfg.io */
+			base ? (p->cfg.regs[1] >> 24) : p->cfg.io[0].mask);
 
-		for (i = 0; i < pc->result_nr; i++) {
-			for (c = 0; c < 4; c++) {
-				if (pc->p->type == PIPE_SHADER_FRAGMENT) {
-					pc->result[i*4+c].type = P_TEMP;
-					pc->result[i*4+c].hw = -1;
-					pc->result[i*4+c].rhw = (i == depr) ?
-						-1 : rid++;
-				} else {
-					pc->result[i*4+c].type = P_RESULT;
-					pc->result[i*4+c].hw = rid++;
-				}
-				pc->result[i*4+c].index = i;
-			}
+		for (n = 0; n < pc->attr_nr; ++n) {
+			p->cfg.io[n].hw = rid = aid;
+			i = p->cfg.io[n].id_fp;
+
+			for (c = 0; c < 4; ++c) {
+				if (!pc->attr[i * 4 + c].acc)
+					continue;
+				pc->attr[i * 4 + c].rhw = rid++;
+				p->cfg.io[n].mask |= 1 << c;
 
-			if (pc->p->type == PIPE_SHADER_FRAGMENT &&
-			    depr != 0xffff) {
-				pc->result[depr * 4 + 2].rhw =
-					(pc->result_nr - 1) * 4;
+				load_interpolant(pc, &pc->attr[i * 4 + c]);
 			}
+			aid += popcnt4(p->cfg.io[n].mask);
 		}
-	}
 
-	if (pc->param_nr) {
-		int rid = 0;
+		if (!base)
+			p->cfg.regs[1] |= p->cfg.io[0].mask << 24;
 
-		pc->param = CALLOC(pc->param_nr * 4, sizeof(struct nv50_reg));
-		if (!pc->param)
-			goto out_err;
+		m = popcnt4(p->cfg.regs[1] >> 24);
 
-		for (i = 0; i < pc->param_nr; i++) {
-			for (c = 0; c < 4; c++) {
-				pc->param[i*4+c].type = P_CONST;
-				pc->param[i*4+c].hw = rid++;
-				pc->param[i*4+c].index = i;
+		/* set count of non-position inputs and of non-flat
+		 * non-position inputs for FP_INTERPOLANT_CTRL
+		 */
+		p->cfg.regs[1] |= aid - m;
+
+		if (flat_nr) {
+			i = p->cfg.io[pc->attr_nr - flat_nr].hw;
+			p->cfg.regs[1] |= (i - m) << 16;
+		} else
+			p->cfg.regs[1] |= p->cfg.regs[1] << 16;
+
+		/* mark color semantic for light-twoside */
+		n = 0x40;
+		for (i = 0; i < pc->attr_nr; i++) {
+			ubyte si, sn;
+
+			sn = p->info.input_semantic_name[p->cfg.io[i].id_fp];
+			si = p->info.input_semantic_index[p->cfg.io[i].id_fp];
+
+			if (sn == TGSI_SEMANTIC_COLOR) {
+				p->cfg.two_side[si] = p->cfg.io[i];
+
+				/* increase colour count */
+				p->cfg.regs[0] += popcnt4(
+					p->cfg.two_side[si].mask) << 16;
+
+				n = MIN2(n, p->cfg.io[i].hw - m);
 			}
 		}
+		if (n < 0x40)
+			p->cfg.regs[0] += n;
+
+		/* Initialize FP results:
+		 * FragDepth is always first TGSI and last hw output
+		 */
+		i = p->info.writes_z ? 4 : 0;
+		for (rid = 0; i < pc->result_nr * 4; i++)
+			pc->result[i].rhw = rid++;
+		if (p->info.writes_z)
+			pc->result[2].rhw = rid;
 	}
 
 	if (pc->immd_nr) {
 		int rid = 0;
 
-		pc->immd = CALLOC(pc->immd_nr * 4, sizeof(struct nv50_reg));
+		pc->immd = MALLOC(pc->immd_nr * 4 * sizeof(struct nv50_reg));
 		if (!pc->immd)
 			goto out_err;
 
 		for (i = 0; i < pc->immd_nr; i++) {
-			for (c = 0; c < 4; c++) {
-				pc->immd[i*4+c].type = P_IMMD;
-				pc->immd[i*4+c].hw = rid++;
-				pc->immd[i*4+c].index = i;
-			}
+			for (c = 0; c < 4; c++, rid++)
+				ctor_reg(&pc->immd[rid], P_IMMD, i, rid);
 		}
 	}
 
 	ret = TRUE;
 out_err:
-	if (r_usage[0])
-		FREE(r_usage[0]);
-	if (r_usage[1])
-		FREE(r_usage[1]);
+	if (pc->iv_p)
+		free_temp(pc, pc->iv_p);
+	if (pc->iv_c)
+		free_temp(pc, pc->iv_c);
 
-	tgsi_parse_free(&p);
+	tgsi_parse_free(&tp);
 	return ret;
 }
 
@@ -2110,6 +2281,88 @@ free_nv50_pc(struct nv50_pc *pc)
 }
 
 static boolean
+ctor_nv50_pc(struct nv50_pc *pc, struct nv50_program *p)
+{
+	int i, c;
+	unsigned rtype[2] = { P_ATTR, P_RESULT };
+
+	pc->p = p;
+	pc->temp_nr = p->info.file_max[TGSI_FILE_TEMPORARY] + 1;
+	pc->attr_nr = p->info.file_max[TGSI_FILE_INPUT] + 1;
+	pc->result_nr = p->info.file_max[TGSI_FILE_OUTPUT] + 1;
+	pc->param_nr = p->info.file_max[TGSI_FILE_CONSTANT] + 1;
+
+	p->cfg.high_temp = 4;
+
+	p->cfg.two_side[0].hw = 0x40;
+	p->cfg.two_side[1].hw = 0x40;
+
+	switch (p->type) {
+	case PIPE_SHADER_VERTEX:
+		p->cfg.psiz = 0x40;
+		p->cfg.clpd = 0x40;
+		p->cfg.io_nr = pc->result_nr;
+		break;
+	case PIPE_SHADER_FRAGMENT:
+		rtype[0] = rtype[1] = P_TEMP;
+
+		p->cfg.regs[0] = 0x01000004;
+		p->cfg.io_nr = pc->attr_nr;
+
+		if (p->info.writes_z) {
+			p->cfg.regs[2] |= 0x00000100;
+			p->cfg.regs[3] |= 0x00000011;
+		}
+		if (p->info.uses_kill)
+			p->cfg.regs[2] |= 0x00100000;
+		break;
+	}
+
+	if (pc->temp_nr) {
+		pc->temp = MALLOC(pc->temp_nr * 4 * sizeof(struct nv50_reg));
+		if (!pc->temp)
+			return FALSE;
+
+		for (i = 0; i < pc->temp_nr * 4; ++i)
+			ctor_reg(&pc->temp[i], P_TEMP, i / 4, -1);
+	}
+
+	if (pc->attr_nr) {
+		pc->attr = MALLOC(pc->attr_nr * 4 * sizeof(struct nv50_reg));
+		if (!pc->attr)
+			return FALSE;
+
+		for (i = 0; i < pc->attr_nr * 4; ++i)
+			ctor_reg(&pc->attr[i], rtype[0], i / 4, -1);
+	}
+
+	if (pc->result_nr) {
+		unsigned nr = pc->result_nr * 4;
+
+		pc->result = MALLOC(nr * sizeof(struct nv50_reg));
+		if (!pc->result)
+			return FALSE;
+
+		for (i = 0; i < nr; ++i)
+			ctor_reg(&pc->result[i], rtype[1], i / 4, -1);
+	}
+
+	if (pc->param_nr) {
+		int rid = 0;
+
+		pc->param = MALLOC(pc->param_nr * 4 * sizeof(struct nv50_reg));
+		if (!pc->param)
+			return FALSE;
+
+		for (i = 0; i < pc->param_nr; ++i)
+			for (c = 0; c < 4; ++c, ++rid)
+				ctor_reg(&pc->param[rid], P_CONST, i, rid);
+	}
+
+	return TRUE;
+}
+
+static boolean
 nv50_program_tx(struct nv50_program *p)
 {
 	struct tgsi_parse_context parse;
@@ -2120,8 +2373,10 @@ nv50_program_tx(struct nv50_program *p)
 	pc = CALLOC_STRUCT(nv50_pc);
 	if (!pc)
 		return FALSE;
-	pc->p = p;
-	pc->p->cfg.high_temp = 4;
+
+	ret = ctor_nv50_pc(pc, p);
+	if (ret == FALSE)
+		goto out_cleanup;
 
 	ret = nv50_program_tx_prep(pc);
 	if (ret == FALSE)
@@ -2141,7 +2396,7 @@ nv50_program_tx(struct nv50_program *p)
 		switch (tok->Token.Type) {
 		case TGSI_TOKEN_TYPE_INSTRUCTION:
 			++pc->insn_cur;
-			ret = nv50_program_tx_insn(pc, tok);
+			ret = nv50_tgsi_insn(pc, tok);
 			if (ret == FALSE)
 				goto out_err;
 			break;
@@ -2152,8 +2407,8 @@ nv50_program_tx(struct nv50_program *p)
 
 	if (p->type == PIPE_SHADER_FRAGMENT) {
 		struct nv50_reg out;
+		ctor_reg(&out, P_TEMP, -1, -1);
 
-		out.type = P_TEMP;
 		for (k = 0; k < pc->result_nr * 4; k++) {
 			if (pc->result[k].rhw == -1)
 				continue;
@@ -2258,30 +2513,19 @@ nv50_program_validate_data(struct nv50_context *nv50, struct nv50_program *p)
 					 p->immd_nr, NV50_CB_PMISC);
 	}
 
-	if (!p->data[1] && p->param_nr) {
-		struct nouveau_resource *heap =
-			nv50->screen->parm_heap[p->type];
-
-		if (nouveau_resource_alloc(heap, p->param_nr, p, &p->data[1])) {
-			while (heap->next && heap->size < p->param_nr) {
-				struct nv50_program *evict = heap->next->priv;
-				nouveau_resource_free(&evict->data[1]);
-			}
-
-			if (nouveau_resource_alloc(heap, p->param_nr, p,
-						   &p->data[1]))
-				assert(0);
-		}
-	}
+	assert(p->param_nr <= 128);
 
 	if (p->param_nr) {
-		unsigned cbuf = NV50_CB_PVP;
+		unsigned cb;
 		float *map = pipe_buffer_map(pscreen, nv50->constbuf[p->type],
 					     PIPE_BUFFER_USAGE_CPU_READ);
-		if (p->type == PIPE_SHADER_FRAGMENT)
-			cbuf = NV50_CB_PFP;
-		nv50_program_upload_data(nv50, map, p->data[1]->start,
-					 p->param_nr, cbuf);
+
+		if (p->type == PIPE_SHADER_VERTEX)
+			cb = NV50_CB_PVP;
+		else
+			cb = NV50_CB_PFP;
+
+		nv50_program_upload_data(nv50, map, 0, p->param_nr, cb);
 		pipe_buffer_unmap(pscreen, nv50->constbuf[p->type]);
 	}
 }
@@ -2303,32 +2547,30 @@ nv50_program_validate_code(struct nv50_context *nv50, struct nv50_program *p)
 		upload = TRUE;
 	}
 
-	if ((p->data[0] && p->data[0]->start != p->data_start[0]) ||
-		(p->data[1] && p->data[1]->start != p->data_start[1])) {
-		for (e = p->exec_head; e; e = e->next) {
-			unsigned ei, ci, bs;
-
-			if (e->param.index < 0)
-				continue;
-			bs = (e->inst[1] >> 22) & 0x07;
-			assert(bs < 2);
-			ei = e->param.shift >> 5;
-			ci = e->param.index + p->data[bs]->start;
+	if (p->data[0] && p->data[0]->start != p->data_start[0])
+		upload = TRUE;
 
-			e->inst[ei] &= ~e->param.mask;
-			e->inst[ei] |= (ci << e->param.shift);
-		}
+	if (!upload)
+		return;
 
-		if (p->data[0])
-			p->data_start[0] = p->data[0]->start;
-		if (p->data[1])
-			p->data_start[1] = p->data[1]->start;
+	for (e = p->exec_head; e; e = e->next) {
+		unsigned ei, ci, bs;
 
-		upload = TRUE;
+		if (e->param.index < 0)
+			continue;
+		bs = (e->inst[1] >> 22) & 0x07;
+		assert(bs < 2);
+		ei = e->param.shift >> 5;
+		ci = e->param.index;
+		if (bs == 0)
+			ci += p->data[bs]->start;
+
+		e->inst[ei] &= ~e->param.mask;
+		e->inst[ei] |= (ci << e->param.shift);
 	}
 
-	if (!upload)
-		return;
+	if (p->data[0])
+		p->data_start[0] = p->data[0]->start;
 
 #ifdef NV50_PROGRAM_DUMP
 	NOUVEAU_ERR("-------\n");
@@ -2402,8 +2644,8 @@ nv50_vertprog_validate(struct nv50_context *nv50)
 	so_reloc (so, p->bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD |
 		      NOUVEAU_BO_LOW, 0, 0);
 	so_method(so, tesla, NV50TCL_VP_ATTR_EN_0, 2);
-	so_data  (so, p->cfg.vp.attr[0]);
-	so_data  (so, p->cfg.vp.attr[1]);
+	so_data  (so, p->cfg.attr[0]);
+	so_data  (so, p->cfg.attr[1]);
 	so_method(so, tesla, NV50TCL_VP_REG_ALLOC_RESULT, 1);
 	so_data  (so, p->cfg.high_result);
 	so_method(so, tesla, NV50TCL_VP_RESULT_MAP_SIZE, 2);
@@ -2421,7 +2663,6 @@ nv50_fragprog_validate(struct nv50_context *nv50)
 	struct nouveau_grobj *tesla = nv50->screen->tesla;
 	struct nv50_program *p = nv50->fragprog;
 	struct nouveau_stateobj *so;
-	unsigned i;
 
 	if (!p->translated) {
 		nv50_program_validate(nv50, p);
@@ -2438,29 +2679,186 @@ nv50_fragprog_validate(struct nv50_context *nv50)
 		      NOUVEAU_BO_HIGH, 0, 0);
 	so_reloc (so, p->bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD |
 		      NOUVEAU_BO_LOW, 0, 0);
-	so_method(so, tesla, NV50TCL_MAP_SEMANTIC_0, 4);
-	so_data  (so, p->cfg.fp.regs[0]); /* 0x01000404 / 0x00040404 */
-	so_data  (so, 0x00000004);
-	so_data  (so, 0x00000000);
-	so_data  (so, 0x00000000);
-	so_method(so, tesla, NV50TCL_VP_RESULT_MAP(0), p->cfg.fp.high_map);
-	for (i = 0; i < p->cfg.fp.high_map; i++)
-		so_data(so, p->cfg.fp.map[i]);
-	so_method(so, tesla, NV50TCL_FP_INTERPOLANT_CTRL, 2);
-	so_data  (so, p->cfg.fp.regs[1]); /* 0x08040404 / 0x0f000401 */
+	so_method(so, tesla, NV50TCL_FP_REG_ALLOC_TEMP, 1);
 	so_data  (so, p->cfg.high_temp);
 	so_method(so, tesla, NV50TCL_FP_RESULT_COUNT, 1);
 	so_data  (so, p->cfg.high_result);
 	so_method(so, tesla, NV50TCL_FP_CTRL_UNK19A8, 1);
-	so_data  (so, p->cfg.fp.regs[2]);
+	so_data  (so, p->cfg.regs[2]);
 	so_method(so, tesla, NV50TCL_FP_CTRL_UNK196C, 1);
-	so_data  (so, p->cfg.fp.regs[3]);
+	so_data  (so, p->cfg.regs[3]);
 	so_method(so, tesla, NV50TCL_FP_START_ID, 1);
 	so_data  (so, 0); /* program start offset */
 	so_ref(so, &nv50->state.fragprog);
 	so_ref(NULL, &so);
 }
 
+static void
+nv50_pntc_replace(struct nv50_context *nv50, uint32_t pntc[8], unsigned base)
+{
+	struct nv50_program *fp = nv50->fragprog;
+	struct nv50_program *vp = nv50->vertprog;
+	unsigned i, c, m = base;
+
+	/* XXX: This can't work correctly in all cases yet, we either
+	 * have to create TGSI_SEMANTIC_PNTC or sprite_coord_mode has
+	 * to be per FP input instead of per VP output
+	 */
+	memset(pntc, 0, 8 * sizeof(uint32_t));
+
+	for (i = 0; i < fp->cfg.io_nr; i++) {
+		uint8_t sn, si;
+		uint8_t j = fp->cfg.io[i].id_vp, k = fp->cfg.io[i].id_fp;
+		unsigned n = popcnt4(fp->cfg.io[i].mask);
+
+		if (fp->info.input_semantic_name[k] != TGSI_SEMANTIC_GENERIC) {
+			m += n;
+			continue;
+		}
+
+		sn = vp->info.input_semantic_name[j];
+		si = vp->info.input_semantic_index[j];
+
+		if (j < fp->cfg.io_nr && sn == TGSI_SEMANTIC_GENERIC) {
+			ubyte mode =
+				nv50->rasterizer->pipe.sprite_coord_mode[si];
+
+			if (mode == PIPE_SPRITE_COORD_NONE) {
+				m += n;
+				continue;
+			}
+		}
+
+		/* this is either PointCoord or replaced by sprite coords */
+		for (c = 0; c < 4; c++) {
+			if (!(fp->cfg.io[i].mask & (1 << c)))
+				continue;
+			pntc[m / 8] |= (c + 1) << ((m % 8) * 4);
+			++m;
+		}
+	}
+}
+
+static int
+nv50_sreg4_map(uint32_t *p_map, int mid, uint32_t lin[4],
+	       struct nv50_sreg4 *fpi, struct nv50_sreg4 *vpo)
+{
+	int c;
+	uint8_t mv = vpo->mask, mf = fpi->mask, oid = vpo->hw;
+	uint8_t *map = (uint8_t *)p_map;
+
+	for (c = 0; c < 4; ++c) {
+		if (mf & 1) {
+			if (fpi->linear == TRUE)
+				lin[mid / 32] |= 1 << (mid % 32);
+			map[mid++] = (mv & 1) ? oid : ((c == 3) ? 0x41 : 0x40);
+		}
+
+		oid += mv & 1;
+		mf >>= 1;
+		mv >>= 1;
+	}
+
+	return mid;
+}
+
+void
+nv50_linkage_validate(struct nv50_context *nv50)
+{
+	struct nouveau_grobj *tesla = nv50->screen->tesla;
+	struct nv50_program *vp = nv50->vertprog;
+	struct nv50_program *fp = nv50->fragprog;
+	struct nouveau_stateobj *so;
+	struct nv50_sreg4 dummy, *vpo;
+	int i, n, c, m = 0;
+	uint32_t map[16], lin[4], reg[5], pcrd[8];
+
+	memset(map, 0, sizeof(map));
+	memset(lin, 0, sizeof(lin));
+
+	reg[1] = 0x00000004; /* low and high clip distance map ids */
+	reg[2] = 0x00000000; /* layer index map id (disabled, GP only) */
+	reg[3] = 0x00000000; /* point size map id & enable */
+	reg[0] = fp->cfg.regs[0]; /* colour semantic reg */
+	reg[4] = fp->cfg.regs[1]; /* interpolant info */
+
+	dummy.linear = FALSE;
+	dummy.mask = 0xf; /* map all components of HPOS */
+	m = nv50_sreg4_map(map, m, lin, &dummy, &vp->cfg.io[0]);
+
+	dummy.mask = 0x0;
+
+	if (vp->cfg.clpd < 0x40) {
+		for (c = 0; c < vp->cfg.clpd_nr; ++c)
+			map[m++] = vp->cfg.clpd + c;
+		reg[1] = (m << 8);
+	}
+
+	reg[0] |= m << 8; /* adjust BFC0 id */
+
+	/* if light_twoside is active, it seems FFC0_ID == BFC0_ID is bad */
+	if (nv50->rasterizer->pipe.light_twoside) {
+		vpo = &vp->cfg.two_side[0];
+
+		m = nv50_sreg4_map(map, m, lin, &fp->cfg.two_side[0], &vpo[0]);
+		m = nv50_sreg4_map(map, m, lin, &fp->cfg.two_side[1], &vpo[1]);
+	}
+
+	reg[0] += m - 4; /* adjust FFC0 id */
+	reg[4] |= m << 8; /* set mid where 'normal' FP inputs start */
+
+	i = 0;
+	if (fp->info.input_semantic_name[0] == TGSI_SEMANTIC_POSITION)
+		i = 1;
+	for (; i < fp->cfg.io_nr; i++) {
+		ubyte sn = fp->info.input_semantic_name[fp->cfg.io[i].id_fp];
+		ubyte si = fp->info.input_semantic_index[fp->cfg.io[i].id_fp];
+
+		n = fp->cfg.io[i].id_vp;
+		if (n >= vp->cfg.io_nr ||
+		    vp->info.output_semantic_name[n] != sn ||
+		    vp->info.output_semantic_index[n] != si)
+			vpo = &dummy;
+		else
+			vpo = &vp->cfg.io[n];
+
+		m = nv50_sreg4_map(map, m, lin, &fp->cfg.io[i], vpo);
+	}
+
+	if (nv50->rasterizer->pipe.point_size_per_vertex) {
+		map[m / 4] |= vp->cfg.psiz << ((m % 4) * 8);
+		reg[3] = (m++ << 4) | 1;
+	}
+
+	/* now fill the stateobj */
+	so = so_new(64, 0);
+
+	n = (m + 3) / 4;
+	so_method(so, tesla, NV50TCL_VP_RESULT_MAP_SIZE, 1);
+	so_data  (so, m);
+	so_method(so, tesla, NV50TCL_VP_RESULT_MAP(0), n);
+	so_datap (so, map, n);
+
+	so_method(so, tesla, NV50TCL_MAP_SEMANTIC_0, 4);
+	so_datap (so, reg, 4);
+
+	so_method(so, tesla, NV50TCL_FP_INTERPOLANT_CTRL, 1);
+	so_data  (so, reg[4]);
+
+	so_method(so, tesla, 0x1540, 4);
+	so_datap (so, lin, 4);
+
+	if (nv50->rasterizer->pipe.point_sprite) {
+		nv50_pntc_replace(nv50, pcrd, (reg[4] >> 8) & 0xff);
+
+		so_method(so, tesla, NV50TCL_POINT_COORD_REPLACE_MAP(0), 8);
+		so_datap (so, pcrd, 8);
+	}
+
+        so_ref(so, &nv50->state.programs);
+        so_ref(NULL, &so);
+}
+
 void
 nv50_program_destroy(struct nv50_context *nv50, struct nv50_program *p)
 {
@@ -2476,7 +2874,6 @@ nv50_program_destroy(struct nv50_context *nv50, struct nv50_program *p)
 	nouveau_bo_ref(NULL, &p->bo);
 
 	nouveau_resource_free(&p->data[0]);
-	nouveau_resource_free(&p->data[1]);
 
 	p->translated = 0;
 }
diff --git a/src/gallium/drivers/nv50/nv50_program.h b/src/gallium/drivers/nv50/nv50_program.h
index 096e0476aa..d78dee083f 100644
--- a/src/gallium/drivers/nv50/nv50_program.h
+++ b/src/gallium/drivers/nv50/nv50_program.h
@@ -15,6 +15,15 @@ struct nv50_program_exec {
 	} param;
 };
 
+struct nv50_sreg4 {
+	uint8_t hw;
+	uint8_t id_vp;
+	uint8_t id_fp;
+
+	uint8_t mask;
+	boolean linear;
+};
+
 struct nv50_program {
 	struct pipe_shader_state pipe;
 	struct tgsi_shader_info info;
@@ -24,8 +33,8 @@ struct nv50_program {
 	struct nv50_program_exec *exec_head;
 	struct nv50_program_exec *exec_tail;
 	unsigned exec_size;
-	struct nouveau_resource *data[2];
-	unsigned data_start[2];
+	struct nouveau_resource *data[1];
+	unsigned data_start[1];
 
 	struct nouveau_bo *bo;
 
@@ -36,14 +45,20 @@ struct nv50_program {
 	struct {
 		unsigned high_temp;
 		unsigned high_result;
-		struct {
-			unsigned attr[2];
-		} vp;
-		struct {
-			unsigned regs[4];
-			unsigned map[5];
-			unsigned high_map;
-		} fp;
+
+		uint32_t attr[2];
+		uint32_t regs[4];
+
+		/* for VPs, io_nr doesn't count 'private' results (PSIZ etc.) */
+		unsigned io_nr;
+		struct nv50_sreg4 io[PIPE_MAX_SHADER_OUTPUTS];
+
+		/* FP colour inputs, VP/GP back colour outputs */
+		struct nv50_sreg4 two_side[2];
+
+		/* VP only */
+		uint8_t clpd, clpd_nr;
+		uint8_t psiz;
 	} cfg;
 };
 
diff --git a/src/gallium/drivers/nv50/nv50_screen.c b/src/gallium/drivers/nv50/nv50_screen.c
index c7f80a2203..3b08e1b89f 100644
--- a/src/gallium/drivers/nv50/nv50_screen.c
+++ b/src/gallium/drivers/nv50/nv50_screen.c
@@ -87,12 +87,10 @@ nv50_screen_get_param(struct pipe_screen *pscreen, int param)
 		return 1;
 	case PIPE_CAP_GLSL:
 		return 0;
-	case PIPE_CAP_S3TC:
-		return 1;
 	case PIPE_CAP_ANISOTROPIC_FILTER:
 		return 1;
 	case PIPE_CAP_POINT_SPRITE:
-		return 0;
+		return 1;
 	case PIPE_CAP_MAX_RENDER_TARGETS:
 		return 8;
 	case PIPE_CAP_OCCLUSION_QUERY:
diff --git a/src/gallium/drivers/nv50/nv50_state.c b/src/gallium/drivers/nv50/nv50_state.c
index 4283808ed9..81fa3e34c5 100644
--- a/src/gallium/drivers/nv50/nv50_state.c
+++ b/src/gallium/drivers/nv50/nv50_state.c
@@ -276,6 +276,9 @@ nv50_rasterizer_state_create(struct pipe_context *pipe,
 	so_method(so, tesla, 0x1684, 1);
 	so_data  (so, cso->flatshade_first ? 0 : 1);
 
+	so_method(so, tesla, NV50TCL_VERTEX_TWO_SIDE_ENABLE, 1);
+	so_data  (so, cso->light_twoside);
+
 	so_method(so, tesla, NV50TCL_LINE_WIDTH, 1);
 	so_data  (so, fui(cso->line_width));
 	so_method(so, tesla, NV50TCL_LINE_SMOOTH_ENABLE, 1);
@@ -294,6 +297,9 @@ nv50_rasterizer_state_create(struct pipe_context *pipe,
 	so_method(so, tesla, NV50TCL_POINT_SIZE, 1);
 	so_data  (so, fui(cso->point_size));
 
+	so_method(so, tesla, NV50TCL_POINT_SPRITE_ENABLE, 1);
+	so_data  (so, cso->point_sprite);
+
 	so_method(so, tesla, NV50TCL_POLYGON_MODE_FRONT, 3);
 	if (cso->front_winding == PIPE_WINDING_CCW) {
 		so_data(so, nvgl_polygon_mode(cso->fill_ccw));
diff --git a/src/gallium/drivers/nv50/nv50_state_validate.c b/src/gallium/drivers/nv50/nv50_state_validate.c
index 344c2cf6dd..5a3559ed18 100644
--- a/src/gallium/drivers/nv50/nv50_state_validate.c
+++ b/src/gallium/drivers/nv50/nv50_state_validate.c
@@ -66,7 +66,8 @@ nv50_state_validate_fb(struct nv50_context *nv50)
 			so_data(so, NV50TCL_RT_FORMAT_X8R8G8B8_UNORM);
 			break;
 		}
-		so_data(so, bo->tile_mode << 4);
+		so_data(so, nv50_miptree(pt)->
+				level[fb->cbufs[i]->level].tile_mode << 4);
 		so_data(so, 0x00000000);
 
 		so_method(so, tesla, 0x1224, 1);
@@ -110,7 +111,8 @@ nv50_state_validate_fb(struct nv50_context *nv50)
 			so_data(so, NV50TCL_ZETA_FORMAT_S8Z24_UNORM);
 			break;
 		}
-		so_data(so, bo->tile_mode << 4);
+		so_data(so, nv50_miptree(pt)->
+				level[fb->zsbuf->level].tile_mode << 4);
 		so_data(so, 0x00000000);
 
 		so_method(so, tesla, 0x1538, 1);
@@ -187,6 +189,8 @@ nv50_state_emit(struct nv50_context *nv50)
 		so_emit(chan, nv50->state.vertprog);
 	if (nv50->state.dirty & NV50_NEW_FRAGPROG)
 		so_emit(chan, nv50->state.fragprog);
+	if (nv50->state.dirty & (NV50_NEW_FRAGPROG | NV50_NEW_VERTPROG))
+		so_emit(chan, nv50->state.programs);
 	if (nv50->state.dirty & NV50_NEW_RASTERIZER)
 		so_emit(chan, nv50->state.rast);
 	if (nv50->state.dirty & NV50_NEW_BLEND_COLOUR)
@@ -208,6 +212,12 @@ nv50_state_emit(struct nv50_context *nv50)
 			so_emit(chan, nv50->state.vtxattr);
 	}
 	nv50->state.dirty = 0;
+}
+
+void
+nv50_state_flush_notify(struct nouveau_channel *chan)
+{
+	struct nv50_context *nv50 = chan->user_private;
 
 	so_emit_reloc_markers(chan, nv50->state.fb);
 	so_emit_reloc_markers(chan, nv50->state.vertprog);
@@ -238,6 +248,9 @@ nv50_state_validate(struct nv50_context *nv50)
 	if (nv50->dirty & (NV50_NEW_FRAGPROG | NV50_NEW_FRAGPROG_CB))
 		nv50_fragprog_validate(nv50);
 
+	if (nv50->dirty & (NV50_NEW_FRAGPROG | NV50_NEW_VERTPROG))
+		nv50_linkage_validate(nv50);
+
 	if (nv50->dirty & NV50_NEW_RASTERIZER)
 		so_ref(nv50->rasterizer->so, &nv50->state.rast);
 
diff --git a/src/gallium/drivers/nv50/nv50_surface.c b/src/gallium/drivers/nv50/nv50_surface.c
index b266324f58..6bf6f773b0 100644
--- a/src/gallium/drivers/nv50/nv50_surface.c
+++ b/src/gallium/drivers/nv50/nv50_surface.c
@@ -60,13 +60,13 @@ nv50_surface_set(struct nv50_screen *screen, struct pipe_surface *ps, int dst)
  	format = nv50_format(ps->format);
  	if (format < 0)
  		return 1;
-  
+
  	if (!bo->tile_flags) {
  		BEGIN_RING(chan, eng2d, mthd, 2);
  		OUT_RING  (chan, format);
  		OUT_RING  (chan, 1);
  		BEGIN_RING(chan, eng2d, mthd + 0x14, 5);
- 		OUT_RING  (chan, mt->level[0].pitch);
+		OUT_RING  (chan, mt->level[ps->level].pitch);
  		OUT_RING  (chan, ps->width);
  		OUT_RING  (chan, ps->height);
  		OUT_RELOCh(chan, bo, ps->offset, flags);
@@ -75,7 +75,7 @@ nv50_surface_set(struct nv50_screen *screen, struct pipe_surface *ps, int dst)
  		BEGIN_RING(chan, eng2d, mthd, 5);
  		OUT_RING  (chan, format);
  		OUT_RING  (chan, 0);
- 		OUT_RING  (chan, bo->tile_mode << 4);
+		OUT_RING  (chan, mt->level[ps->level].tile_mode << 4);
  		OUT_RING  (chan, 1);
  		OUT_RING  (chan, 0);
  		BEGIN_RING(chan, eng2d, mthd + 0x18, 4);
diff --git a/src/gallium/drivers/nv50/nv50_transfer.c b/src/gallium/drivers/nv50/nv50_transfer.c
index e9c3562194..bb7731855c 100644
--- a/src/gallium/drivers/nv50/nv50_transfer.c
+++ b/src/gallium/drivers/nv50/nv50_transfer.c
@@ -89,14 +89,14 @@ nv50_transfer_rect_m2mf(struct pipe_screen *pscreen,
 		if (src_bo->tile_flags) {
 			BEGIN_RING(chan, m2mf,
 				NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN, 1);
-			OUT_RING  (chan, (sy << 16) | sx);
+			OUT_RING  (chan, (sy << 16) | (sx * cpp));
 		} else {
 			src_offset += (line_count * src_pitch);
 		}
 		if (dst_bo->tile_flags) {
 			BEGIN_RING(chan, m2mf,
 				NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT, 1);
-			OUT_RING  (chan, (dy << 16) | dx);
+			OUT_RING  (chan, (dy << 16) | (dx * cpp));
 		} else {
 			dst_offset += (line_count * dst_pitch);
 		}
diff --git a/src/gallium/drivers/r300/Makefile b/src/gallium/drivers/r300/Makefile
index ec58eeacc2..69e4724790 100644
--- a/src/gallium/drivers/r300/Makefile
+++ b/src/gallium/drivers/r300/Makefile
@@ -9,6 +9,7 @@ C_SOURCES = \
 	r300_chipset.c \
 	r300_clear.c \
 	r300_context.c \
+	r300_debug.c \
 	r300_emit.c \
 	r300_flush.c \
 	r300_fs.c \
diff --git a/src/gallium/drivers/r300/r300_context.c b/src/gallium/drivers/r300/r300_context.c
index da67bc29b8..9cc455135d 100644
--- a/src/gallium/drivers/r300/r300_context.c
+++ b/src/gallium/drivers/r300/r300_context.c
@@ -22,6 +22,9 @@
 
 #include "r300_context.h"
 
+#include "r300_flush.h"
+#include "r300_state_invariant.h"
+
 static boolean r300_draw_range_elements(struct pipe_context* pipe,
                                         struct pipe_buffer* indexBuffer,
                                         unsigned indexSize,
@@ -146,6 +149,8 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
     r300->context.winsys = (struct pipe_winsys*)r300_winsys;
     r300->context.screen = r300_screen(screen);
 
+    r300_init_debug(r300);
+
     r300->context.destroy = r300_destroy_context;
 
     r300->context.clear = r300_clear;
diff --git a/src/gallium/drivers/r300/r300_context.h b/src/gallium/drivers/r300/r300_context.h
index f78492d4aa..52b1c9a6b2 100644
--- a/src/gallium/drivers/r300/r300_context.h
+++ b/src/gallium/drivers/r300/r300_context.h
@@ -184,8 +184,15 @@ struct r300_texture {
     /* Offsets into the buffer. */
     unsigned offset[PIPE_MAX_TEXTURE_LEVELS];
 
-    /* Stride (pitch?) of this texture in bytes */
-    unsigned stride;
+    /**
+     * If non-zero, override the natural texture layout with
+     * a custom stride (in bytes).
+     *
+     * \note Mipmapping fails for textures with a non-natural layout!
+     *
+     * \sa r300_texture_get_stride
+     */
+    unsigned stride_override;
 
     /* Total size of this texture, in bytes. */
     unsigned size;
@@ -211,10 +218,7 @@ struct r300_vertex_format {
     int fs_tab[16];
 };
 
-static struct pipe_viewport_state r300_viewport_identity = {
-    .scale = {1.0, 1.0, 1.0, 1.0},
-    .translate = {0.0, 0.0, 0.0, 0.0},
-};
+extern struct pipe_viewport_state r300_viewport_identity;
 
 struct r300_context {
     /* Parent class */
@@ -275,6 +279,9 @@ struct r300_context {
     uint32_t dirty_state;
     /* Flag indicating whether or not the HW is dirty. */
     uint32_t dirty_hw;
+
+    /** Combination of DBG_xxx flags */
+    unsigned debug;
 };
 
 /* Convenience cast wrapper. */
@@ -288,4 +295,40 @@ struct draw_stage* r300_draw_stage(struct r300_context* r300);
 void r300_init_state_functions(struct r300_context* r300);
 void r300_init_surface_functions(struct r300_context* r300);
 
+/* Debug functionality. */
+
+/**
+ * Debug flags to disable/enable certain groups of debugging outputs.
+ *
+ * \note These may be rather coarse, and the grouping may be impractical.
+ * If you find, while debugging the driver, that a different grouping
+ * of these flags would be beneficial, just feel free to change them
+ * but make sure to update the documentation in r300_debug.c to reflect
+ * those changes.
+ */
+/*@{*/
+#define DBG_HELP    0x0000001
+#define DBG_FP      0x0000002
+#define DBG_VP      0x0000004
+#define DBG_CS      0x0000008
+#define DBG_DRAW    0x0000010
+/*@}*/
+
+static INLINE boolean DBG_ON(struct r300_context * ctx, unsigned flags)
+{
+    return (ctx->debug & flags) ? true : false;
+}
+
+static INLINE void DBG(struct r300_context * ctx, unsigned flags, const char * fmt, ...)
+{
+    if (DBG_ON(ctx, flags)) {
+        va_list va;
+        va_start(va, fmt);
+        debug_vprintf(fmt, va);
+        va_end(va);
+    }
+}
+
+void r300_init_debug(struct r300_context * ctx);
+
 #endif /* R300_CONTEXT_H */
diff --git a/src/gallium/drivers/r300/r300_cs.h b/src/gallium/drivers/r300/r300_cs.h
index 71b142c0db..0a7e470363 100644
--- a/src/gallium/drivers/r300/r300_cs.h
+++ b/src/gallium/drivers/r300/r300_cs.h
@@ -49,7 +49,8 @@
     (RADEON_CP_PACKET0 | ((count) << 16) | ((register) >> 2))
 
 #define CS_LOCALS(context) \
-    struct r300_winsys* cs_winsys = context->winsys; \
+    struct r300_context* const cs_context_copy = (context); \
+    struct r300_winsys* cs_winsys = cs_context_copy->winsys; \
     int cs_count = 0;
 
 #define CHECK_CS(size) \
@@ -58,7 +59,7 @@
 #define BEGIN_CS(size) do { \
     CHECK_CS(size); \
     if (VERY_VERBOSE_CS) { \
-        debug_printf("r300: BEGIN_CS, count %d, in %s (%s:%d)\n", \
+        DBG(cs_context_copy, DBG_CS, "r300: BEGIN_CS, count %d, in %s (%s:%d)\n", \
                 size, __FUNCTION__, __FILE__, __LINE__); \
     } \
     cs_winsys->begin_cs(cs_winsys, (size), \
@@ -78,7 +79,7 @@
 
 #define OUT_CS_REG(register, value) do { \
     if (VERY_VERBOSE_REGISTERS) \
-        debug_printf("r300: writing 0x%08X to register 0x%04X\n", \
+        DBG(cs_context_copy, DBG_CS, "r300: writing 0x%08X to register 0x%04X\n", \
             value, register); \
     assert(register); \
     OUT_CS(CP_PACKET0(register, 0)); \
@@ -89,14 +90,14 @@
  * not the actual packet0 count! */
 #define OUT_CS_REG_SEQ(register, count) do { \
     if (VERY_VERBOSE_REGISTERS) \
-        debug_printf("r300: writing register sequence of %d to 0x%04X\n", \
+        DBG(cs_context_copy, DBG_CS, "r300: writing register sequence of %d to 0x%04X\n", \
             count, register); \
     assert(register); \
     OUT_CS(CP_PACKET0(register, ((count) - 1))); \
 } while (0)
 
 #define OUT_CS_RELOC(bo, offset, rd, wd, flags) do { \
-    debug_printf("r300: writing relocation for buffer %p, offset %d, " \
+    DBG(cs_context_copy, DBG_CS, "r300: writing relocation for buffer %p, offset %d, " \
             "domains (%d, %d, %d)\n", \
         bo, offset, rd, wd, flags); \
     assert(bo); \
@@ -107,7 +108,7 @@
 
 #define END_CS do { \
     if (VERY_VERBOSE_CS) { \
-        debug_printf("r300: END_CS in %s (%s:%d)\n", __FUNCTION__, \
+        DBG(cs_context_copy, DBG_CS, "r300: END_CS in %s (%s:%d)\n", __FUNCTION__, \
                 __FILE__, __LINE__); \
     } \
     if (cs_count != 0) \
@@ -117,7 +118,7 @@
 
 #define FLUSH_CS do { \
     if (VERY_VERBOSE_CS) { \
-        debug_printf("r300: FLUSH_CS in %s (%s:%d)\n\n", __FUNCTION__, \
+        DBG(cs_context_copy, DBG_CS, "r300: FLUSH_CS in %s (%s:%d)\n\n", __FUNCTION__, \
                 __FILE__, __LINE__); \
     } \
     cs_winsys->flush_cs(cs_winsys); \
@@ -127,7 +128,7 @@
 
 #define OUT_CS_ONE_REG(register, count) do { \
     if (VERY_VERBOSE_REGISTERS) \
-        debug_printf("r300: writing data sequence of %d to 0x%04X\n", \
+        DBG(cs_context_copy, DBG_CS, "r300: writing data sequence of %d to 0x%04X\n", \
             count, register); \
     assert(register); \
     OUT_CS(CP_PACKET0(register, ((count) - 1)) | RADEON_ONE_REG_WR); \
@@ -141,7 +142,7 @@
 } while (0)
 
 #define OUT_CS_INDEX_RELOC(bo, offset, count, rd, wd, flags) do { \
-    debug_printf("r300: writing relocation for index buffer %p," \
+    DBG(cs_context_copy, DBG_CS, "r300: writing relocation for index buffer %p," \
             "offset %d\n", bo, offset); \
     assert(bo); \
     OUT_CS(offset); \
diff --git a/src/gallium/drivers/r300/r300_debug.c b/src/gallium/drivers/r300/r300_debug.c
new file mode 100644
index 0000000000..15308dda1d
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_debug.c
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2009 Nicolai Haehnle <nhaehnle@gmail.com>
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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. */
+
+#include "r300_context.h"
+
+#include <ctype.h>
+
+
+struct debug_option {
+    const char * name;
+    unsigned flag;
+    const char * description;
+};
+
+static struct debug_option debug_options[] = {
+    { "help", DBG_HELP, "Helpful meta-information about the driver" },
+    { "fp", DBG_FP, "Fragment program handling" },
+    { "vp", DBG_VP, "Vertex program handling" },
+    { "cs", DBG_CS, "Command submissions" },
+    { "draw", DBG_DRAW, "Draw and emit" },
+
+    { "all", ~0, "Convenience option that enables all debug flags" },
+
+    /* must be last */
+    { 0, 0, 0 }
+};
+
+void r300_init_debug(struct r300_context * ctx)
+{
+    const char * options = debug_get_option("RADEON_DEBUG", 0);
+    boolean printhint = false;
+
+    if (options) {
+        while(*options) {
+            if (*options == ' ' || *options == ',') {
+                options++;
+                continue;
+            }
+
+            size_t length = strcspn(options, " ,");
+            struct debug_option * opt;
+
+            for(opt = debug_options; opt->name; ++opt) {
+                if (!strncmp(options, opt->name, length)) {
+                    ctx->debug |= opt->flag;
+                    break;
+                }
+            }
+
+            if (!opt->name) {
+                debug_printf("Unknown debug option: %s\n", options);
+                printhint = true;
+            }
+
+            options += length;
+        }
+
+        if (!ctx->debug)
+            printhint = true;
+    }
+
+    if (printhint || ctx->debug & DBG_HELP) {
+        debug_printf("You can enable debug output by setting the RADEON_DEBUG environment variable\n"
+                     "to a comma-separated list of debug options. Available options are:\n");
+        for(struct debug_option * opt = debug_options; opt->name; ++opt) {
+            debug_printf("    %s: %s\n", opt->name, opt->description);
+        }
+    }
+}
diff --git a/src/gallium/drivers/r300/r300_emit.c b/src/gallium/drivers/r300/r300_emit.c
index bd4d59e6f1..a1b36ba2ed 100644
--- a/src/gallium/drivers/r300/r300_emit.c
+++ b/src/gallium/drivers/r300/r300_emit.c
@@ -25,6 +25,7 @@
 #include "r300_emit.h"
 
 #include "r300_fs.h"
+#include "r300_state_derived.h"
 #include "r300_vs.h"
 
 void r300_emit_blend_state(struct r300_context* r300,
@@ -282,7 +283,7 @@ void r300_emit_fb_state(struct r300_context* r300,
     for (i = 0; i < fb->nr_cbufs; i++) {
         tex = (struct r300_texture*)fb->cbufs[i]->texture;
         assert(tex && tex->buffer && "cbuf is marked, but NULL!");
-        pixpitch = tex->stride / tex->tex.block.size;
+        pixpitch = r300_texture_get_stride(tex, 0) / tex->tex.block.size;
 
         OUT_CS_REG_SEQ(R300_RB3D_COLOROFFSET0 + (4 * i), 1);
         OUT_CS_RELOC(tex->buffer, 0, 0, RADEON_GEM_DOMAIN_VRAM, 0);
@@ -299,7 +300,7 @@ void r300_emit_fb_state(struct r300_context* r300,
     if (fb->zsbuf) {
         tex = (struct r300_texture*)fb->zsbuf->texture;
         assert(tex && tex->buffer && "zsbuf is marked, but NULL!");
-        pixpitch = tex->stride / tex->tex.block.size;
+        pixpitch = r300_texture_get_stride(tex, 0) / tex->tex.block.size;
 
         OUT_CS_REG_SEQ(R300_ZB_DEPTHOFFSET, 1);
         OUT_CS_RELOC(tex->buffer, 0, 0, RADEON_GEM_DOMAIN_VRAM, 0);
@@ -490,7 +491,7 @@ void r300_emit_vertex_buffer(struct r300_context* r300)
 {
     CS_LOCALS(r300);
 
-    debug_printf("r300: Preparing vertex buffer %p for render, "
+    DBG(r300, DBG_DRAW, "r300: Preparing vertex buffer %p for render, "
             "vertex size %d\n", r300->vbo,
             r300->vertex_info.vinfo.size);
     /* Set the pointer to our vertex buffer. The emitted values are this:
diff --git a/src/gallium/drivers/r300/r300_emit.h b/src/gallium/drivers/r300/r300_emit.h
index 350691d592..c4002b8e5d 100644
--- a/src/gallium/drivers/r300/r300_emit.h
+++ b/src/gallium/drivers/r300/r300_emit.h
@@ -56,6 +56,11 @@ void r500_emit_fragment_program_code(struct r300_context* r300,
 void r300_emit_fb_state(struct r300_context* r300,
                         struct pipe_framebuffer_state* fb);
 
+void r300_emit_query_begin(struct r300_context* r300,
+                           struct r300_query* query);
+void r300_emit_query_end(struct r300_context* r300,
+                         struct r300_query* query);
+
 void r300_emit_rs_state(struct r300_context* r300, struct r300_rs_state* rs);
 
 void r300_emit_rs_block_state(struct r300_context* r300,
diff --git a/src/gallium/drivers/r300/r300_fs.c b/src/gallium/drivers/r300/r300_fs.c
index 36463b9a2e..a0e848a59a 100644
--- a/src/gallium/drivers/r300/r300_fs.c
+++ b/src/gallium/drivers/r300/r300_fs.c
@@ -96,7 +96,7 @@ void r300_translate_fragment_shader(struct r300_context* r300,
 
     memset(&compiler, 0, sizeof(compiler));
     rc_init(&compiler.Base);
-    compiler.Base.Debug = 1;
+    compiler.Base.Debug = DBG_ON(r300, DBG_FP);
 
     compiler.code = &fs->code;
     compiler.is_r500 = r300_screen(r300->context.screen)->caps->is_r500;
diff --git a/src/gallium/drivers/r300/r300_query.c b/src/gallium/drivers/r300/r300_query.c
index 1d5185b417..2880d34877 100644
--- a/src/gallium/drivers/r300/r300_query.c
+++ b/src/gallium/drivers/r300/r300_query.c
@@ -22,6 +22,8 @@
 
 #include "r300_query.h"
 
+#include "r300_emit.h"
+
 static struct pipe_query* r300_create_query(struct pipe_context* pipe,
                                             unsigned query_type)
 {
diff --git a/src/gallium/drivers/r300/r300_render.c b/src/gallium/drivers/r300/r300_render.c
index aced4ab887..737396d8d9 100644
--- a/src/gallium/drivers/r300/r300_render.c
+++ b/src/gallium/drivers/r300/r300_render.c
@@ -26,15 +26,17 @@
 
 #include "r300_cs.h"
 #include "r300_context.h"
+#include "r300_emit.h"
 #include "r300_reg.h"
 #include "r300_state_derived.h"
 
 /* r300_render: Vertex and index buffer primitive emission. */
+#define R300_MAX_VBO_SIZE  (1024 * 1024)
 
 struct r300_render {
     /* Parent class */
     struct vbuf_render base;
-    
+
     /* Pipe context */
     struct r300_context* r300;
 
@@ -45,7 +47,10 @@ struct r300_render {
 
     /* VBO */
     struct pipe_buffer* vbo;
-    size_t vbo_alloc_size;
+    size_t vbo_size;
+    size_t vbo_offset;
+    size_t vbo_max_used;
+    void * vbo_ptr;
 };
 
 static INLINE struct r300_render*
@@ -74,19 +79,18 @@ static boolean r300_render_allocate_vertices(struct vbuf_render* render,
     struct pipe_screen* screen = r300->context.screen;
     size_t size = (size_t)vertex_size * (size_t)count;
 
-    if (r300render->vbo && (size > r300render->vbo_alloc_size)) {
-        pipe_buffer_reference(&r300render->vbo, NULL);
-    }
-    
-    if (!r300render->vbo) {
+    if (size + r300render->vbo_offset > r300render->vbo_size) 
+    {
         r300render->vbo = pipe_buffer_create(screen,
                                              64,
                                              PIPE_BUFFER_USAGE_VERTEX,
-                                             size);
+                                             R300_MAX_VBO_SIZE);
+        r300render->vbo_size = R300_MAX_VBO_SIZE;
     }
 
-    r300render->vbo_alloc_size = MAX2(size, r300render->vbo_alloc_size);
     r300render->vertex_size = vertex_size;
+    r300->vbo = r300render->vbo;
+    r300->vbo_offset = r300render->vbo_offset;
 
     return (r300render->vbo) ? TRUE : FALSE;
 }
@@ -96,8 +100,10 @@ static void* r300_render_map_vertices(struct vbuf_render* render)
     struct r300_render* r300render = r300_render(render);
     struct pipe_screen* screen = r300render->r300->context.screen;
 
-    return (unsigned char*)pipe_buffer_map(screen, r300render->vbo,
-                                           PIPE_BUFFER_USAGE_CPU_WRITE);
+    r300render->vbo_ptr = pipe_buffer_map(screen, r300render->vbo,
+                                          PIPE_BUFFER_USAGE_CPU_WRITE);
+
+    return (r300render->vbo_ptr + r300render->vbo_offset);
 }
 
 static void r300_render_unmap_vertices(struct vbuf_render* render,
@@ -106,15 +112,24 @@ static void r300_render_unmap_vertices(struct vbuf_render* render,
 {
     struct r300_render* r300render = r300_render(render);
     struct pipe_screen* screen = r300render->r300->context.screen;
+    CS_LOCALS(r300render->r300);
+    BEGIN_CS(2);
+    OUT_CS_REG(R300_VAP_VF_MAX_VTX_INDX, max);
+    END_CS;
 
+    r300render->vbo_max_used = MAX2(r300render->vbo_max_used, 
+                                    r300render->vertex_size * (max + 1));
     pipe_buffer_unmap(screen, r300render->vbo);
 }
 
 static void r300_render_release_vertices(struct vbuf_render* render)
 {
     struct r300_render* r300render = r300_render(render);
+    struct r300_context* r300 = r300render->r300;
 
-    pipe_buffer_reference(&r300render->vbo, NULL);
+    r300render->vbo_offset += r300render->vbo_max_used;
+    r300render->vbo_max_used = 0;
+    r300->vbo = NULL;
 }
 
 static boolean r300_render_set_primitive(struct vbuf_render* render,
@@ -162,14 +177,12 @@ static boolean r300_render_set_primitive(struct vbuf_render* render,
     return TRUE;
 }
 
-static void prepare_render(struct r300_render* render, unsigned count)
+static void r300_prepare_render(struct r300_render* render, unsigned count)
 {
     struct r300_context* r300 = render->r300;
 
     CS_LOCALS(r300);
 
-    r300->vbo = render->vbo;
-
     r300_emit_dirty_state(r300);
 }
 
@@ -182,9 +195,9 @@ static void r300_render_draw_arrays(struct vbuf_render* render,
 
     CS_LOCALS(r300);
 
-    prepare_render(r300render, count);
+    r300_prepare_render(r300render, count);
 
-    debug_printf("r300: Doing vbuf render, count %d\n", count);
+    DBG(r300, DBG_DRAW, "r300: Doing vbuf render, count %d\n", count);
 
     BEGIN_CS(2);
     OUT_CS_PKT3(R300_PACKET3_3D_DRAW_VBUF_2, 0);
@@ -207,7 +220,7 @@ static void r300_render_draw(struct vbuf_render* render,
 
     CS_LOCALS(r300);
 
-    prepare_render(r300render, count);
+    r300_prepare_render(r300render, count);
 
     /* Send our indices into an index buffer. */
     index_buffer = pipe_buffer_create(screen, 64, PIPE_BUFFER_USAGE_VERTEX,
@@ -216,25 +229,7 @@ static void r300_render_draw(struct vbuf_render* render,
         return;
     }
 
-/*
-    index_map = pipe_buffer_map(screen, index_buffer,
-                                PIPE_BUFFER_USAGE_CPU_WRITE);
-    memcpy(index_map, indices, count);
-    pipe_buffer_unmap(screen, index_buffer);
-
-    debug_printf("r300: Doing indexbuf render, count %d\n", count);
-
-    BEGIN_CS(8);
-    OUT_CS_PKT3(R300_PACKET3_3D_DRAW_INDX_2, 0);
-    OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (count << 16) |
-           r300render->hwprim);
-    OUT_CS_PKT3(R300_PACKET3_INDX_BUFFER, 2);
-    OUT_CS(R300_INDX_BUFFER_ONE_REG_WR | (R300_VAP_PORT_IDX0 >> 2));
-    OUT_CS_INDEX_RELOC(index_buffer, 0, count, RADEON_GEM_DOMAIN_GTT, 0, 0);
-    END_CS; */
-
-    BEGIN_CS(4 + (count+1)/2);
-    OUT_CS_REG(R300_VAP_VF_MAX_VTX_INDX, count);
+    BEGIN_CS(2 + (count+1)/2);
     OUT_CS_PKT3(R300_PACKET3_3D_DRAW_INDX_2, (count+1)/2);
     OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (count << 16) |
            r300render->hwprim);
@@ -272,6 +267,10 @@ static struct vbuf_render* r300_render_create(struct r300_context* r300)
     r300render->base.release_vertices = r300_render_release_vertices;
     r300render->base.destroy = r300_render_destroy;
 
+    r300render->vbo = NULL;
+    r300render->vbo_size = 0;
+    r300render->vbo_offset = 0;
+
     return &r300render->base;
 }
 
diff --git a/src/gallium/drivers/r300/r300_screen.c b/src/gallium/drivers/r300/r300_screen.c
index 15740f6125..3b5b1bbd37 100644
--- a/src/gallium/drivers/r300/r300_screen.c
+++ b/src/gallium/drivers/r300/r300_screen.c
@@ -93,8 +93,6 @@ static int r300_get_param(struct pipe_screen* pscreen, int param)
             } else {
                 return 0;
             }
-        case PIPE_CAP_S3TC:
-            return 1;
         case PIPE_CAP_ANISOTROPIC_FILTER:
             return 1;
         case PIPE_CAP_POINT_SPRITE:
@@ -323,13 +321,14 @@ r300_get_tex_transfer(struct pipe_screen *screen,
     if (trans) {
         pipe_texture_reference(&trans->transfer.texture, texture);
         trans->transfer.format = texture->format;
+        trans->transfer.x = x;
+        trans->transfer.y = y;
         trans->transfer.width = w;
         trans->transfer.height = h;
         trans->transfer.block = texture->block;
         trans->transfer.nblocksx = texture->nblocksx[level];
         trans->transfer.nblocksy = texture->nblocksy[level];
-        trans->transfer.stride = align(pf_get_stride(&trans->transfer.block,
-                                                     texture->width[level]), 32);
+        trans->transfer.stride = r300_texture_get_stride(tex, level);
         trans->transfer.usage = usage;
         trans->offset = offset;
     }
@@ -356,7 +355,7 @@ static void* r300_transfer_map(struct pipe_screen* screen,
     if (transfer->usage != PIPE_TRANSFER_READ) {
         flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
     }
-    
+
     map = pipe_buffer_map(screen, tex->buffer, flags);
 
     if (!map) {
diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c
index 81808017f8..88cb9af6fb 100644
--- a/src/gallium/drivers/r300/r300_state.c
+++ b/src/gallium/drivers/r300/r300_state.c
@@ -20,10 +20,11 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
 
+#include "util/u_debug.h"
 #include "util/u_math.h"
 #include "util/u_pack_color.h"
 
-#include "util/u_debug.h"
+#include "tgsi/tgsi_parse.h"
 
 #include "pipe/p_config.h"
 #include "pipe/internal/p_winsys_screen.h"
diff --git a/src/gallium/drivers/r300/r300_state_derived.c b/src/gallium/drivers/r300/r300_state_derived.c
index c01e61a9b1..5f6b225d34 100644
--- a/src/gallium/drivers/r300/r300_state_derived.c
+++ b/src/gallium/drivers/r300/r300_state_derived.c
@@ -23,6 +23,7 @@
 #include "r300_state_derived.h"
 
 #include "r300_fs.h"
+#include "r300_state_inlines.h"
 #include "r300_vs.h"
 
 /* r300_state_derived: Various bits of state which are dependent upon
@@ -195,13 +196,13 @@ static void r300_vertex_psc(struct r300_context* r300,
      * and not on attrib information. */
     if (r300screen->caps->has_tcl) {
         attrib_count = r300->vs->info.num_inputs;
-        debug_printf("r300: routing %d attribs in psc for vs\n",
+        DBG(r300, DBG_DRAW, "r300: routing %d attribs in psc for vs\n",
                 attrib_count);
     } else {
         attrib_count = vinfo->num_attribs;
-        debug_printf("r300: attrib count: %d\n", attrib_count);
+        DBG(r300, DBG_DRAW, "r300: attrib count: %d\n", attrib_count);
         for (i = 0; i < attrib_count; i++) {
-            debug_printf("r300: attrib: offset %d, interp %d, size %d,"
+            DBG(r300, DBG_DRAW, "r300: attrib: offset %d, interp %d, size %d,"
                    " tab %d\n", vinfo->attrib[i].src_index,
                    vinfo->attrib[i].interp_mode, vinfo->attrib[i].emit,
                    tab[i]);
@@ -299,18 +300,18 @@ static void r300_update_fs_tab(struct r300_context* r300)
     }
 
     /* Now that we know where everything is... */
-    debug_printf("r300: fp input count: %d\n", info->num_inputs);
+    DBG(r300, DBG_DRAW, "r300: fp input count: %d\n", info->num_inputs);
     for (i = 0; i < info->num_inputs; i++) {
         switch (tab[i]) {
             case INTERP_LINEAR:
-                debug_printf("r300: attrib: "
+                DBG(r300, DBG_DRAW, "r300: attrib: "
                         "stack offset %d, color,    tab %d\n",
                         i, cols_emitted);
                 tab[i] = cols_emitted;
                 cols_emitted++;
                 break;
             case INTERP_PERSPECTIVE:
-                debug_printf("r300: attrib: "
+                DBG(r300, DBG_DRAW, "r300: attrib: "
                         "stack offset %d, texcoord, tab %d\n",
                         i, cols + texs);
                 tab[i] = cols + texs;
diff --git a/src/gallium/drivers/r300/r300_state_derived.h b/src/gallium/drivers/r300/r300_state_derived.h
index 63ae8eb8d0..71a4a47b00 100644
--- a/src/gallium/drivers/r300/r300_state_derived.h
+++ b/src/gallium/drivers/r300/r300_state_derived.h
@@ -23,11 +23,7 @@
 #ifndef R300_STATE_DERIVED_H
 #define R300_STATE_DERIVED_H
 
-#include "draw/draw_vertex.h"
-
-#include "r300_context.h"
-#include "r300_reg.h"
-#include "r300_state_inlines.h"
+struct r300_context;
 
 void r300_update_derived_state(struct r300_context* r300);
 
diff --git a/src/gallium/drivers/r300/r300_state_invariant.c b/src/gallium/drivers/r300/r300_state_invariant.c
index 7d822fec48..3865730d63 100644
--- a/src/gallium/drivers/r300/r300_state_invariant.c
+++ b/src/gallium/drivers/r300/r300_state_invariant.c
@@ -23,6 +23,12 @@
 
 #include "r300_state_invariant.h"
 
+
+struct pipe_viewport_state r300_viewport_identity = {
+    .scale = {1.0, 1.0, 1.0, 1.0},
+    .translate = {0.0, 0.0, 0.0, 0.0},
+};
+
 /* Calculate and emit invariant state. This is data that the 3D engine
  * will probably want at the beginning of every CS, but it's not currently
  * handled by any CSO setup, and in addition it doesn't really change much.
diff --git a/src/gallium/drivers/r300/r300_surface.c b/src/gallium/drivers/r300/r300_surface.c
index 96e6e4a77d..cc6288cb51 100644
--- a/src/gallium/drivers/r300/r300_surface.c
+++ b/src/gallium/drivers/r300/r300_surface.c
@@ -29,7 +29,7 @@ static void r300_surface_setup(struct r300_context* r300,
                                unsigned w, unsigned h)
 {
     struct r300_capabilities* caps = r300_screen(r300->context.screen)->caps;
-    unsigned pixpitch = dest->stride / dest->tex.block.size;
+    unsigned pixpitch = r300_texture_get_stride(dest, 0) / dest->tex.block.size;
     CS_LOCALS(r300);
 
     r300_emit_blend_state(r300, &blend_clear_state);
@@ -100,7 +100,7 @@ static void r300_surface_fill(struct pipe_context* pipe,
     struct r300_context* r300 = r300_context(pipe);
     struct r300_capabilities* caps = r300_screen(pipe->screen)->caps;
     struct r300_texture* tex = (struct r300_texture*)dest->texture;
-    unsigned pixpitch = tex->stride / tex->tex.block.size;
+    unsigned pixpitch = r300_texture_get_stride(tex, 0) / tex->tex.block.size;
     boolean invalid = FALSE;
     CS_LOCALS(r300);
 
@@ -233,7 +233,7 @@ static void r300_surface_copy(struct pipe_context* pipe,
     struct r300_capabilities* caps = r300_screen(pipe->screen)->caps;
     struct r300_texture* srctex = (struct r300_texture*)src->texture;
     struct r300_texture* desttex = (struct r300_texture*)dest->texture;
-    unsigned pixpitch = srctex->stride / srctex->tex.block.size;
+    unsigned pixpitch = r300_texture_get_stride(srctex, 0) / srctex->tex.block.size;
     boolean invalid = FALSE;
     float fsrcx = srcx, fsrcy = srcy, fdestx = destx, fdesty = desty;
     CS_LOCALS(r300);
diff --git a/src/gallium/drivers/r300/r300_texture.c b/src/gallium/drivers/r300/r300_texture.c
index 590052509c..6e8c368320 100644
--- a/src/gallium/drivers/r300/r300_texture.c
+++ b/src/gallium/drivers/r300/r300_texture.c
@@ -25,7 +25,6 @@
 static void r300_setup_texture_state(struct r300_texture* tex,
                                      unsigned width,
                                      unsigned height,
-                                     unsigned pitch,
                                      unsigned levels)
 {
     struct r300_texture_state* state = &tex->state;
@@ -38,7 +37,7 @@ static void r300_setup_texture_state(struct r300_texture* tex,
     /* XXX */
     state->format1 = r300_translate_texformat(tex->tex.format);
 
-    state->format2 = pitch - 1;
+    state->format2 = r300_texture_get_stride(tex, 0);
 
     /* Assume (somewhat foolishly) that oversized textures will
      * not be permitted by the state tracker. */
@@ -50,13 +49,30 @@ static void r300_setup_texture_state(struct r300_texture* tex,
     }
 
     debug_printf("r300: Set texture state (%dx%d, pitch %d, %d levels)\n",
-            width, height, pitch, levels);
+            width, height, levels);
+}
+
+/**
+ * Return the stride, in bytes, of the texture images of the given texture
+ * at the given level.
+ */
+unsigned r300_texture_get_stride(struct r300_texture* tex, unsigned level)
+{
+    if (tex->stride_override)
+        return tex->stride_override;
+
+    if (level > tex->tex.last_level) {
+        debug_printf("%s: level (%u) > last_level (%u)\n", level, tex->tex.last_level);
+        return 0;
+    }
+
+    return align(pf_get_stride(&tex->tex.block, tex->tex.width[level]), 32);
 }
 
 static void r300_setup_miptree(struct r300_texture* tex)
 {
     struct pipe_texture* base = &tex->tex;
-    int stride, size, offset;
+    int stride, size;
     int i;
 
     for (i = 0; i <= base->last_level; i++) {
@@ -74,7 +90,7 @@ static void r300_setup_miptree(struct r300_texture* tex)
          * XXX
          * POT, uncompressed, unmippmapped textures can be aligned to 32,
          * instead of 64. */
-        stride = align(pf_get_stride(&base->block, base->width[i]), 32);
+        stride = r300_texture_get_stride(tex, i);
         size = stride * base->nblocksy[i] * base->depth[i];
 
         tex->offset[i] = align(tex->size, 32);
@@ -84,10 +100,6 @@ static void r300_setup_miptree(struct r300_texture* tex)
                 "(%dx%dx%d px, pitch %d bytes)\n",
                 i, base->width[i], base->height[i], base->depth[i],
                 stride);
-        /* Save stride of first level to the texture. */
-        if (i == 0) {
-            tex->stride = stride;
-        }
     }
 }
 
@@ -109,7 +121,7 @@ static struct pipe_texture*
     r300_setup_miptree(tex);
 
     r300_setup_texture_state(tex, template->width[0], template->height[0],
-            template->width[0], template->last_level);
+                             template->last_level);
 
     tex->buffer = screen->buffer_create(screen, 1024,
                                         PIPE_BUFFER_USAGE_PIXEL,
@@ -189,11 +201,10 @@ static struct pipe_texture*
     pipe_reference_init(&tex->tex.reference, 1);
     tex->tex.screen = screen;
 
-    tex->stride = *stride;
+    tex->stride_override = *stride;
 
     /* XXX */
-    r300_setup_texture_state(tex, tex->tex.width[0], tex->tex.height[0],
-            tex->stride, 0);
+    r300_setup_texture_state(tex, tex->tex.width[0], tex->tex.height[0], 0);
 
     pipe_buffer_reference(&tex->buffer, buffer);
 
@@ -221,7 +232,7 @@ boolean r300_get_texture_buffer(struct pipe_texture* texture,
     pipe_buffer_reference(buffer, tex->buffer);
 
     if (stride) {
-        *stride = tex->stride;
+        *stride = r300_texture_get_stride(tex, 0);
     }
 
     return TRUE;
diff --git a/src/gallium/drivers/r300/r300_texture.h b/src/gallium/drivers/r300/r300_texture.h
index 3b56f0307c..3109af5bac 100644
--- a/src/gallium/drivers/r300/r300_texture.h
+++ b/src/gallium/drivers/r300/r300_texture.h
@@ -30,8 +30,12 @@
 #include "r300_context.h"
 #include "r300_reg.h"
 
+struct r300_texture;
+
 void r300_init_screen_texture_functions(struct pipe_screen* screen);
 
+unsigned r300_texture_get_stride(struct r300_texture* tex, unsigned level);
+
 /* Note the signature of R300_EASY_TX_FORMAT(A, R, G, B, FORMAT)... */
 static INLINE uint32_t r300_translate_texformat(enum pipe_format format)
 {
diff --git a/src/gallium/drivers/r300/r300_tgsi_to_rc.c b/src/gallium/drivers/r300/r300_tgsi_to_rc.c
index 2c63a46c27..7f12008830 100644
--- a/src/gallium/drivers/r300/r300_tgsi_to_rc.c
+++ b/src/gallium/drivers/r300/r300_tgsi_to_rc.c
@@ -161,7 +161,6 @@ static unsigned translate_saturate(unsigned saturate)
             /* fall-through */
         case TGSI_SAT_NONE: return RC_SATURATE_NONE;
         case TGSI_SAT_ZERO_ONE: return RC_SATURATE_ZERO_ONE;
-        case TGSI_SAT_MINUS_PLUS_ONE: return RC_SATURATE_MINUS_PLUS_ONE;
     }
 }
 
diff --git a/src/gallium/drivers/r300/r300_vs.c b/src/gallium/drivers/r300/r300_vs.c
index 2cb903bba2..12a6e37be6 100644
--- a/src/gallium/drivers/r300/r300_vs.c
+++ b/src/gallium/drivers/r300/r300_vs.c
@@ -116,7 +116,7 @@ void r300_translate_vertex_shader(struct r300_context* r300,
     /* Setup the compiler */
     rc_init(&compiler.Base);
 
-    compiler.Base.Debug = 1;
+    compiler.Base.Debug = DBG_ON(r300, DBG_VP);
     compiler.code = &vs->code;
     compiler.UserData = vs;
 
diff --git a/src/gallium/drivers/softpipe/sp_clear.c b/src/gallium/drivers/softpipe/sp_clear.c
index fa59277438..8fac8e6e05 100644
--- a/src/gallium/drivers/softpipe/sp_clear.c
+++ b/src/gallium/drivers/softpipe/sp_clear.c
@@ -36,8 +36,6 @@
 #include "util/u_pack_color.h"
 #include "sp_clear.h"
 #include "sp_context.h"
-#include "sp_surface.h"
-#include "sp_state.h"
 #include "sp_tile_cache.h"
 
 
@@ -85,5 +83,7 @@ softpipe_clear(struct pipe_context *pipe, unsigned buffers, const float *rgba,
       /* non-cached surface */
       pipe->surface_fill(pipe, ps, 0, 0, ps->width, ps->height, cv);
 #endif
-      }
+   }
+
+   softpipe->dirty_render_cache = TRUE;
 }
diff --git a/src/gallium/drivers/softpipe/sp_clear.h b/src/gallium/drivers/softpipe/sp_clear.h
index 2e450672f5..9be3b86fe9 100644
--- a/src/gallium/drivers/softpipe/sp_clear.h
+++ b/src/gallium/drivers/softpipe/sp_clear.h
@@ -32,7 +32,6 @@
 #ifndef SP_CLEAR_H
 #define SP_CLEAR_H
 
-#include "pipe/p_state.h"
 struct pipe_context;
 
 extern void
diff --git a/src/gallium/drivers/softpipe/sp_context.c b/src/gallium/drivers/softpipe/sp_context.c
index 86df320ea8..c699c433e9 100644
--- a/src/gallium/drivers/softpipe/sp_context.c
+++ b/src/gallium/drivers/softpipe/sp_context.c
@@ -83,7 +83,8 @@ softpipe_unmap_transfers(struct softpipe_context *sp)
 }
 
 
-static void softpipe_destroy( struct pipe_context *pipe )
+static void
+softpipe_destroy( struct pipe_context *pipe )
 {
    struct softpipe_context *softpipe = softpipe_context( pipe );
    uint i;
@@ -121,6 +122,15 @@ static void softpipe_destroy( struct pipe_context *pipe )
    FREE( softpipe );
 }
 
+
+/**
+ * if (the texture is being used as a framebuffer surface)
+ *    return PIPE_REFERENCED_FOR_WRITE
+ * else if (the texture is a bound texture source)
+ *    return PIPE_REFERENCED_FOR_READ  XXX not done yet
+ * else
+ *    return PIPE_UNREFERENCED
+ */
 static unsigned int
 softpipe_is_texture_referenced( struct pipe_context *pipe,
 				struct pipe_texture *texture,
@@ -129,15 +139,17 @@ softpipe_is_texture_referenced( struct pipe_context *pipe,
    struct softpipe_context *softpipe = softpipe_context( pipe );
    unsigned i;
 
-   if(softpipe->dirty_render_cache) {
+   if (softpipe->dirty_render_cache) {
       for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++) {
-         if(softpipe->framebuffer.cbufs[i] && 
-            softpipe->framebuffer.cbufs[i]->texture == texture)
+         if (softpipe->framebuffer.cbufs[i] && 
+             softpipe->framebuffer.cbufs[i]->texture == texture) {
             return PIPE_REFERENCED_FOR_WRITE;
+         }
       }
-      if(softpipe->framebuffer.zsbuf && 
-         softpipe->framebuffer.zsbuf->texture == texture)
+      if (softpipe->framebuffer.zsbuf && 
+          softpipe->framebuffer.zsbuf->texture == texture) {
          return PIPE_REFERENCED_FOR_WRITE;
+      }
    }
    
    /* FIXME: we also need to do the same for the texture cache */
@@ -145,6 +157,7 @@ softpipe_is_texture_referenced( struct pipe_context *pipe,
    return PIPE_UNREFERENCED;
 }
 
+
 static unsigned int
 softpipe_is_buffer_referenced( struct pipe_context *pipe,
 			       struct pipe_buffer *buf)
@@ -152,6 +165,7 @@ softpipe_is_buffer_referenced( struct pipe_context *pipe,
    return PIPE_UNREFERENCED;
 }
 
+
 struct pipe_context *
 softpipe_create( struct pipe_screen *screen )
 {
@@ -222,7 +236,6 @@ softpipe_create( struct pipe_screen *screen )
    softpipe->pipe.is_buffer_referenced = softpipe_is_buffer_referenced;
 
    softpipe_init_query_funcs( softpipe );
-   softpipe_init_texture_funcs( softpipe );
 
    /*
     * Alloc caches for accessing drawing surfaces and textures.
diff --git a/src/gallium/drivers/softpipe/sp_screen.c b/src/gallium/drivers/softpipe/sp_screen.c
index 6178c4ac7e..ce77018415 100644
--- a/src/gallium/drivers/softpipe/sp_screen.c
+++ b/src/gallium/drivers/softpipe/sp_screen.c
@@ -65,8 +65,6 @@ softpipe_get_param(struct pipe_screen *screen, int param)
       return 1;
    case PIPE_CAP_GLSL:
       return 1;
-   case PIPE_CAP_S3TC:
-      return 0;
    case PIPE_CAP_ANISOTROPIC_FILTER:
       return 0;
    case PIPE_CAP_POINT_SPRITE:
@@ -141,6 +139,7 @@ softpipe_is_format_supported( struct pipe_screen *screen,
    case PIPE_FORMAT_DXT1_RGBA:
    case PIPE_FORMAT_DXT3_RGBA:
    case PIPE_FORMAT_DXT5_RGBA:
+   case PIPE_FORMAT_Z32_FLOAT:
       return FALSE;
    default:
       return TRUE;
diff --git a/src/gallium/drivers/softpipe/sp_state_derived.c b/src/gallium/drivers/softpipe/sp_state_derived.c
index 75551000c9..9258f64109 100644
--- a/src/gallium/drivers/softpipe/sp_state_derived.c
+++ b/src/gallium/drivers/softpipe/sp_state_derived.c
@@ -91,6 +91,23 @@ softpipe_get_vertex_info(struct softpipe_context *softpipe)
       vinfo->num_attribs = 0;
       for (i = 0; i < spfs->info.num_inputs; i++) {
          int src;
+         enum interp_mode interp;
+
+         switch (spfs->info.input_interpolate[i]) {
+         case TGSI_INTERPOLATE_CONSTANT:
+            interp = INTERP_CONSTANT;
+            break;
+         case TGSI_INTERPOLATE_LINEAR:
+            interp = INTERP_LINEAR;
+            break;
+         case TGSI_INTERPOLATE_PERSPECTIVE:
+            interp = INTERP_PERSPECTIVE;
+            break;
+         default:
+            assert(0);
+            interp = INTERP_LINEAR;
+         }
+
          switch (spfs->info.input_semantic_name[i]) {
          case TGSI_SEMANTIC_POSITION:
             src = draw_find_vs_output(softpipe->draw,
@@ -106,7 +123,7 @@ softpipe_get_vertex_info(struct softpipe_context *softpipe)
 
          case TGSI_SEMANTIC_FOG:
             src = draw_find_vs_output(softpipe->draw, TGSI_SEMANTIC_FOG, 0);
-            draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_PERSPECTIVE, src);
+            draw_emit_vertex_attr(vinfo, EMIT_4F, interp, src);
             break;
 
          case TGSI_SEMANTIC_GENERIC:
@@ -114,7 +131,7 @@ softpipe_get_vertex_info(struct softpipe_context *softpipe)
             /* this includes texcoords and varying vars */
             src = draw_find_vs_output(softpipe->draw, TGSI_SEMANTIC_GENERIC,
                                       spfs->info.input_semantic_index[i]);
-            draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_PERSPECTIVE, src);
+            draw_emit_vertex_attr(vinfo, EMIT_4F, interp, src);
             break;
 
          default:
diff --git a/src/gallium/drivers/softpipe/sp_tex_sample.c b/src/gallium/drivers/softpipe/sp_tex_sample.c
index a1d3bade27..f99a30277d 100644
--- a/src/gallium/drivers/softpipe/sp_tex_sample.c
+++ b/src/gallium/drivers/softpipe/sp_tex_sample.c
@@ -464,7 +464,7 @@ choose_cube_face(float rx, float ry, float rz, float *newS, float *newT)
    unsigned face;
    float sc, tc, ma;
 
-   if (arx > ary && arx > arz) {
+   if (arx >= ary && arx >= arz) {
       if (rx >= 0.0F) {
          face = PIPE_TEX_FACE_POS_X;
          sc = -rz;
@@ -478,7 +478,7 @@ choose_cube_face(float rx, float ry, float rz, float *newS, float *newT)
          ma = arx;
       }
    }
-   else if (ary > arx && ary > arz) {
+   else if (ary >= arx && ary >= arz) {
       if (ry >= 0.0F) {
          face = PIPE_TEX_FACE_POS_Y;
          sc = rx;
diff --git a/src/gallium/drivers/softpipe/sp_texture.c b/src/gallium/drivers/softpipe/sp_texture.c
index 70f0932431..548e40c4a8 100644
--- a/src/gallium/drivers/softpipe/sp_texture.c
+++ b/src/gallium/drivers/softpipe/sp_texture.c
@@ -30,26 +30,21 @@
   *   Michel Dänzer <michel@tungstengraphics.com>
   */
 
-#include "pipe/p_context.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 
 #include "sp_context.h"
 #include "sp_state.h"
 #include "sp_texture.h"
-#include "sp_tile_cache.h"
 #include "sp_screen.h"
 #include "sp_winsys.h"
 
 
-/* Simple, maximally packed layout.
- */
-
-
-/* Conventional allocation path for non-display textures:
+/**
+ * Conventional allocation path for non-display textures:
+ * Use a simple, maximally packed layout.
  */
 static boolean
 softpipe_texture_layout(struct pipe_screen *screen,
@@ -89,6 +84,10 @@ softpipe_texture_layout(struct pipe_screen *screen,
    return spt->buffer != NULL;
 }
 
+
+/**
+ * Texture layout for simple color buffers.
+ */
 static boolean
 softpipe_displaytarget_layout(struct pipe_screen *screen,
                               struct softpipe_texture * spt)
@@ -112,9 +111,6 @@ softpipe_displaytarget_layout(struct pipe_screen *screen,
 }
 
 
-
-
-
 static struct pipe_texture *
 softpipe_texture_create(struct pipe_screen *screen,
                         const struct pipe_texture *templat)
@@ -342,14 +338,13 @@ softpipe_transfer_map( struct pipe_screen *screen,
    /* May want to different things here depending on read/write nature
     * of the map:
     */
-   if (transfer->texture && transfer->usage != PIPE_TRANSFER_READ) 
-   {
+   if (transfer->texture && transfer->usage != PIPE_TRANSFER_READ) {
       /* Do something to notify sharing contexts of a texture change.
        * In softpipe, that would mean flushing the texture cache.
        */
       softpipe_screen(screen)->timestamp++;
    }
-   
+
    xfer_map = map + softpipe_transfer(transfer)->offset +
       transfer->y / transfer->block.height * transfer->stride +
       transfer->x / transfer->block.width * transfer->block.size;
@@ -360,7 +355,7 @@ softpipe_transfer_map( struct pipe_screen *screen,
 
 static void
 softpipe_transfer_unmap(struct pipe_screen *screen,
-                       struct pipe_transfer *transfer)
+                        struct pipe_transfer *transfer)
 {
    struct softpipe_texture *spt;
 
@@ -377,12 +372,6 @@ softpipe_transfer_unmap(struct pipe_screen *screen,
 
 
 void
-softpipe_init_texture_funcs(struct softpipe_context *sp)
-{
-}
-
-
-void
 softpipe_init_screen_texture_funcs(struct pipe_screen *screen)
 {
    screen->texture_create = softpipe_texture_create;
@@ -404,7 +393,7 @@ softpipe_get_texture_buffer( struct pipe_texture *texture,
                              struct pipe_buffer **buf,
                              unsigned *stride )
 {
-   struct softpipe_texture *tex = (struct softpipe_texture *)texture;
+   struct softpipe_texture *tex = (struct softpipe_texture *) texture;
 
    if (!tex)
       return FALSE;
diff --git a/src/gallium/drivers/softpipe/sp_texture.h b/src/gallium/drivers/softpipe/sp_texture.h
index 893aa7d11d..b1b6130b22 100644
--- a/src/gallium/drivers/softpipe/sp_texture.h
+++ b/src/gallium/drivers/softpipe/sp_texture.h
@@ -74,9 +74,6 @@ softpipe_transfer(struct pipe_transfer *pt)
 
 
 extern void
-softpipe_init_texture_funcs( struct softpipe_context *softpipe );
-
-extern void
 softpipe_init_screen_texture_funcs(struct pipe_screen *screen);
 
 
diff --git a/src/gallium/include/pipe/p_compiler.h b/src/gallium/include/pipe/p_compiler.h
index e6a67f8c2f..c13cffceb0 100644
--- a/src/gallium/include/pipe/p_compiler.h
+++ b/src/gallium/include/pipe/p_compiler.h
@@ -93,9 +93,11 @@ typedef int     _Bool;
 #endif
 
 
+#ifndef __HAIKU__
 typedef unsigned int       uint;
-typedef unsigned char      ubyte;
 typedef unsigned short     ushort;
+#endif
+typedef unsigned char      ubyte;
 
 #if 0
 #define boolean bool
diff --git a/src/gallium/include/pipe/p_config.h b/src/gallium/include/pipe/p_config.h
index 4152d6ac36..de99957d9d 100644
--- a/src/gallium/include/pipe/p_config.h
+++ b/src/gallium/include/pipe/p_config.h
@@ -140,6 +140,9 @@
 #define PIPE_OS_WINDOWS
 #endif
 
+#if defined(__HAIKU__)
+#define PIPE_OS_HAIKU
+#endif
 
 /*
  * Subsystem.
diff --git a/src/gallium/include/pipe/p_defines.h b/src/gallium/include/pipe/p_defines.h
index b01ab6d137..f252d6df00 100644
--- a/src/gallium/include/pipe/p_defines.h
+++ b/src/gallium/include/pipe/p_defines.h
@@ -281,7 +281,7 @@ enum pipe_transfer_usage {
 #define PIPE_CAP_NPOT_TEXTURES           2
 #define PIPE_CAP_TWO_SIDED_STENCIL       3
 #define PIPE_CAP_GLSL                    4  /* XXX need something better */
-#define PIPE_CAP_S3TC                    5
+#define PIPE_CAP_S3TC                    5  /* XXX: deprecated; cap determined via supported sampler formats */
 #define PIPE_CAP_ANISOTROPIC_FILTER      6
 #define PIPE_CAP_POINT_SPRITE            7
 #define PIPE_CAP_MAX_RENDER_TARGETS      8
diff --git a/src/gallium/include/pipe/p_inlines.h b/src/gallium/include/pipe/p_inlines.h
index a5c1e8270a..30a4aaf409 100644
--- a/src/gallium/include/pipe/p_inlines.h
+++ b/src/gallium/include/pipe/p_inlines.h
@@ -118,7 +118,7 @@ pipe_buffer_write(struct pipe_screen *screen,
                   unsigned offset, unsigned size,
                   const void *data)
 {
-   uint8_t *map;
+   void *map;
    
    assert(offset < buf->size);
    assert(offset + size <= buf->size);
@@ -129,7 +129,7 @@ pipe_buffer_write(struct pipe_screen *screen,
                                PIPE_BUFFER_USAGE_FLUSH_EXPLICIT);
    assert(map);
    if(map) {
-      memcpy(map + offset, data, size);
+      memcpy((uint8_t *)map + offset, data, size);
       pipe_buffer_flush_mapped_range(screen, buf, offset, size);
       pipe_buffer_unmap(screen, buf);
    }
@@ -141,7 +141,7 @@ pipe_buffer_read(struct pipe_screen *screen,
                  unsigned offset, unsigned size,
                  void *data)
 {
-   uint8_t *map;
+   void *map;
    
    assert(offset < buf->size);
    assert(offset + size <= buf->size);
@@ -150,11 +150,31 @@ pipe_buffer_read(struct pipe_screen *screen,
    map = pipe_buffer_map_range(screen, buf, offset, size, PIPE_BUFFER_USAGE_CPU_READ);
    assert(map);
    if(map) {
-      memcpy(data, map + offset, size);
+      memcpy(data, (const uint8_t *)map + offset, size);
       pipe_buffer_unmap(screen, buf);
    }
 }
 
+static INLINE void *
+pipe_transfer_map( struct pipe_transfer *transf )
+{
+   struct pipe_screen *screen = transf->texture->screen;
+   return screen->transfer_map(screen, transf);
+}
+
+static INLINE void
+pipe_transfer_unmap( struct pipe_transfer *transf )
+{
+   struct pipe_screen *screen = transf->texture->screen;
+   screen->transfer_unmap(screen, transf);
+}
+
+static INLINE void
+pipe_transfer_destroy( struct pipe_transfer *transf )
+{
+   struct pipe_screen *screen = transf->texture->screen;
+   screen->tex_transfer_destroy(transf);
+}
 
 #ifdef __cplusplus
 }
diff --git a/src/gallium/include/pipe/p_state.h b/src/gallium/include/pipe/p_state.h
index 626bedb35a..2187f5b367 100644
--- a/src/gallium/include/pipe/p_state.h
+++ b/src/gallium/include/pipe/p_state.h
@@ -307,7 +307,7 @@ struct pipe_transfer
    unsigned nblocksx;            /**< allocated width in blocks */
    unsigned nblocksy;            /**< allocated height in blocks */
    unsigned stride;              /**< stride in bytes between rows of blocks */
-   unsigned usage;               /**< PIPE_TRANSFER_*  */
+   enum pipe_transfer_usage usage; /**< PIPE_TRANSFER_*  */
 
    struct pipe_texture *texture; /**< texture to transfer to/from  */
    unsigned face;
diff --git a/src/gallium/include/pipe/p_thread.h b/src/gallium/include/pipe/p_thread.h
index 96e8e08744..25e4148232 100644
--- a/src/gallium/include/pipe/p_thread.h
+++ b/src/gallium/include/pipe/p_thread.h
@@ -39,7 +39,7 @@
 #include "util/u_debug.h" /* for assert */
 
 
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
 
 #include <pthread.h> /* POSIX threads headers */
 #include <stdio.h> /* for perror() */
@@ -213,7 +213,7 @@ typedef unsigned pipe_condvar;
  */
 
 typedef struct {
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    pthread_key_t key;
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
    DWORD key;
@@ -228,7 +228,7 @@ typedef struct {
 static INLINE void
 pipe_tsd_init(pipe_tsd *tsd)
 {
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    if (pthread_key_create(&tsd->key, NULL/*free*/) != 0) {
       perror("pthread_key_create(): failed to allocate key for thread specific data");
       exit(-1);
@@ -245,7 +245,7 @@ pipe_tsd_get(pipe_tsd *tsd)
    if (tsd->initMagic != (int) PIPE_TSD_INIT_MAGIC) {
       pipe_tsd_init(tsd);
    }
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    return pthread_getspecific(tsd->key);
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
    assert(0);
@@ -262,7 +262,7 @@ pipe_tsd_set(pipe_tsd *tsd, void *value)
    if (tsd->initMagic != (int) PIPE_TSD_INIT_MAGIC) {
       pipe_tsd_init(tsd);
    }
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
    if (pthread_setspecific(tsd->key, value) != 0) {
       perror("pthread_set_specific() failed");
       exit(-1);
diff --git a/src/gallium/state_trackers/g3dvl/vl_basic_csc.c b/src/gallium/state_trackers/g3dvl/vl_basic_csc.c
index 20d682de3f..b1683b891b 100644
--- a/src/gallium/state_trackers/g3dvl/vl_basic_csc.c
+++ b/src/gallium/state_trackers/g3dvl/vl_basic_csc.c
@@ -51,6 +51,7 @@ static int vlResizeFrameBuffer
 	struct vlBasicCSC	*basic_csc;
 	struct pipe_context	*pipe;
 	struct pipe_texture	template;
+	float			clear_color[4];
 
 	assert(csc);
 
@@ -68,7 +69,12 @@ static int vlResizeFrameBuffer
 	basic_csc->viewport.translate[1] = 0;
 	basic_csc->viewport.translate[2] = 0;
 	basic_csc->viewport.translate[3] = 0;
-	
+
+	clear_color[0]	= 0.0f;
+	clear_color[1]  = 0.0f;
+	clear_color[2]  = 0.0f;
+	clear_color[3]  = 0.0f;
+
 	if (basic_csc->framebuffer_tex)
 	{
 		pipe_surface_reference(&basic_csc->framebuffer.cbufs[0], NULL);
@@ -98,7 +104,7 @@ static int vlResizeFrameBuffer
 
 	/* Clear to black, in case video doesn't fill the entire window */
 	pipe->set_framebuffer_state(pipe, &basic_csc->framebuffer);
-	pipe->clear(pipe, PIPE_CLEAR_COLOR, 0, 0.0f, 0);
+	pipe->clear(pipe, PIPE_CLEAR_COLOR, clear_color, 0.0f, 0);
 
 	return 0;
 }
@@ -425,7 +431,7 @@ static int vlCreateVertexShader
 	 */
 	for (i = 0; i < 2; ++i)
 	{
-		inst = vl_inst4(TGSI_OPCODE_MADD, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i, TGSI_FILE_CONSTANT, i * 2, TGSI_FILE_CONSTANT, i * 2 + 1);
+		inst = vl_inst4(TGSI_OPCODE_MAD, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i, TGSI_FILE_CONSTANT, i * 2, TGSI_FILE_CONSTANT, i * 2 + 1);
 		ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 	}
 
diff --git a/src/gallium/state_trackers/g3dvl/vl_r16snorm_mc_buf_shaders.inc b/src/gallium/state_trackers/g3dvl/vl_r16snorm_mc_buf_shaders.inc
index ef4a4b2add..34d93e1df0 100644
--- a/src/gallium/state_trackers/g3dvl/vl_r16snorm_mc_buf_shaders.inc
+++ b/src/gallium/state_trackers/g3dvl/vl_r16snorm_mc_buf_shaders.inc
@@ -615,7 +615,7 @@ static int vlCreateFragmentShaderFieldPMB
 	ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 
 	/* floor t3, t3			; Get rid of fractional part */
-	inst = vl_inst2(TGSI_OPCODE_FLOOR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
+	inst = vl_inst2(TGSI_OPCODE_FLR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
 	ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 
 	/* mul t3, t3, c1.y		; Multiply by 2 */
@@ -632,7 +632,7 @@ static int vlCreateFragmentShaderFieldPMB
 
 	/* TODO: Move to conditional tex fetch on t3 instead of lerp */
 	/* lerp t1, t3, t1, t2		; Choose between top and bottom fields based on Y % 2 */
-	inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
+	inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
 	ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 
 	/* add o0, t0, t1		; Add ref and differential to form final output */
@@ -969,7 +969,7 @@ static int vlCreateFragmentShaderFrameBMB
 	}
 
 	/* lerp t1, c1.x, t1, t2	; Blend past and future texels */
-	inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
+	inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
 	inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
 	inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
 	inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
@@ -1116,7 +1116,7 @@ static int vlCreateFragmentShaderFieldBMB
 	ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 
 	/* floor t3, t3			; Get rid of fractional part */
-	inst = vl_inst2(TGSI_OPCODE_FLOOR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
+	inst = vl_inst2(TGSI_OPCODE_FLR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
 	ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 
 	/* mul t3, t3, c1.y		; Multiply by 2 */
@@ -1143,7 +1143,7 @@ static int vlCreateFragmentShaderFieldBMB
 
 	/* TODO: Move to conditional tex fetch on t3 instead of lerp */
 	/* lerp t1, t3, t1, t2		; Choose between top and bottom fields based on Y % 2 */
-	inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
+	inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
 	ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 
 	/*
@@ -1158,11 +1158,11 @@ static int vlCreateFragmentShaderFieldBMB
 
 	/* TODO: Move to conditional tex fetch on t3 instead of lerp */
 	/* lerp t2, t3, t4, t5		; Choose between top and bottom fields based on Y % 2 */
-	inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 2, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_TEMPORARY, 5);
+	inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 2, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_TEMPORARY, 5);
 	ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
 
 	/* lerp t1, c1.x, t1, t2	; Blend past and future texels */
-	inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
+	inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
 	inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
 	inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
 	inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
diff --git a/src/gallium/state_trackers/xorg/xorg_composite.c b/src/gallium/state_trackers/xorg/xorg_composite.c
index c708ac3170..66ca4cb590 100644
--- a/src/gallium/state_trackers/xorg/xorg_composite.c
+++ b/src/gallium/state_trackers/xorg/xorg_composite.c
@@ -4,6 +4,7 @@
 
 #include "cso_cache/cso_context.h"
 #include "util/u_draw_quad.h"
+#include "util/u_math.h"
 
 #include "pipe/p_inlines.h"
 
@@ -11,9 +12,9 @@ struct xorg_composite_blend {
    int op:8;
 
    unsigned rgb_src_factor:5;    /**< PIPE_BLENDFACTOR_x */
-   unsigned rgb_dst_factor:5;    /**< PIPE_BLENDFACTOR_x */
-
    unsigned alpha_src_factor:5;  /**< PIPE_BLENDFACTOR_x */
+
+   unsigned rgb_dst_factor:5;    /**< PIPE_BLENDFACTOR_x */
    unsigned alpha_dst_factor:5;  /**< PIPE_BLENDFACTOR_x */
 };
 
@@ -40,9 +41,25 @@ static const struct xorg_composite_blend xorg_blends[] = {
      PIPE_BLENDFACTOR_INV_SRC_ALPHA, PIPE_BLENDFACTOR_INV_SRC_ALPHA },
 };
 
+
+static INLINE void
+pixel_to_float4(Pixel pixel, float *color)
+{
+   CARD32	    r, g, b, a;
+
+   a = (pixel >> 24) & 0xff;
+   r = (pixel >> 16) & 0xff;
+   g = (pixel >>  8) & 0xff;
+   b = (pixel >>  0) & 0xff;
+   color[0] = ((float)r) / 255.;
+   color[1] = ((float)g) / 255.;
+   color[2] = ((float)b) / 255.;
+   color[3] = ((float)a) / 255.;
+}
+
 static INLINE void
-pixel_to_float4(PictFormatPtr format,
-                CARD32 pixel, float *color)
+render_pixel_to_float4(PictFormatPtr format,
+                       CARD32 pixel, float *color)
 {
    CARD32	    r, g, b, a;
 
@@ -148,7 +165,7 @@ setup_vertex_data0(struct exa_context *ctx,
    setup_vertex0(vertices[3], dstX, dstY + height,
                  ctx->solid_color);
 
-   return pipe_user_buffer_create(ctx->ctx->screen,
+   return pipe_user_buffer_create(ctx->pipe->screen,
                                   vertices,
                                   sizeof(vertices));
 }
@@ -194,11 +211,38 @@ setup_vertex_data1(struct exa_context *ctx,
    setup_vertex1(vertices[3], dstX, dstY + height,
                  s0, t1);
 
-   return pipe_user_buffer_create(ctx->ctx->screen,
+   return pipe_user_buffer_create(ctx->pipe->screen,
                                   vertices,
                                   sizeof(vertices));
 }
 
+static struct pipe_buffer *
+setup_vertex_data_tex(struct exa_context *ctx,
+                      float x0, float y0, float x1, float y1,
+                      float s0, float t0, float s1, float t1,
+                      float z)
+{
+   float vertices[4][2][4];
+
+   /* 1st vertex */
+   setup_vertex1(vertices[0], x0, y0,
+                 s0, t0);
+   /* 2nd vertex */
+   setup_vertex1(vertices[1], x1, y0,
+                 s1, t0);
+   /* 3rd vertex */
+   setup_vertex1(vertices[2], x1, y1,
+                 s1, t1);
+   /* 4th vertex */
+   setup_vertex1(vertices[3], x0, y1,
+                 s0, t1);
+
+   return pipe_user_buffer_create(ctx->pipe->screen,
+                                  vertices,
+                                  sizeof(vertices));
+}
+
+
 
 static INLINE void
 setup_vertex2(float vertex[3][4], float x, float y,
@@ -253,7 +297,7 @@ setup_vertex_data2(struct exa_context *ctx,
    setup_vertex2(vertices[3], dstX, dstY + height,
                  st0[0], st0[3], st1[0], st1[3]);
 
-   return pipe_user_buffer_create(ctx->ctx->screen,
+   return pipe_user_buffer_create(ctx->pipe->screen,
                                   vertices,
                                   sizeof(vertices));
 }
@@ -291,16 +335,20 @@ boolean xorg_composite_accelerated(int op,
 }
 
 static void
-bind_framebuffer_state(struct exa_context *exa, PicturePtr pDstPicture,
-                       struct exa_pixmap_priv *pDst)
+bind_clip_state(struct exa_context *exa)
+{
+}
+
+static void
+bind_framebuffer_state(struct exa_context *exa, struct exa_pixmap_priv *pDst)
 {
    unsigned i;
    struct pipe_framebuffer_state state;
    struct pipe_surface *surface = exa_gpu_surface(exa, pDst);
    memset(&state, 0, sizeof(struct pipe_framebuffer_state));
 
-   state.width  = pDstPicture->pDrawable->width;
-   state.height = pDstPicture->pDrawable->height;
+   state.width  = pDst->tex->width[0];
+   state.height = pDst->tex->height[0];
 
    state.nr_cbufs = 1;
    state.cbufs[0] = surface;
@@ -338,10 +386,12 @@ set_viewport(struct exa_context *exa, int width, int height,
 }
 
 static void
-bind_viewport_state(struct exa_context *exa, PicturePtr pDstPicture)
+bind_viewport_state(struct exa_context *exa, struct exa_pixmap_priv *pDst)
 {
-   int width = pDstPicture->pDrawable->width;
-   int height = pDstPicture->pDrawable->height;
+   int width = pDst->tex->width[0];
+   int height = pDst->tex->height[0];
+
+   debug_printf("Bind viewport (%d, %d)\n", width, height);
 
    set_viewport(exa, width, height, Y0_TOP);
 }
@@ -350,7 +400,8 @@ static void
 bind_blend_state(struct exa_context *exa, int op,
                  PicturePtr pSrcPicture, PicturePtr pMaskPicture)
 {
-   boolean component_alpha = pSrcPicture->componentAlpha;
+   boolean component_alpha = (pSrcPicture) ?
+                             pSrcPicture->componentAlpha : FALSE;
    struct xorg_composite_blend blend_opt;
    struct pipe_blend_state blend;
 
@@ -390,14 +441,17 @@ bind_shaders(struct exa_context *exa, int op,
    unsigned vs_traits = 0, fs_traits = 0;
    struct xorg_shader shader;
 
+   exa->has_solid_color = FALSE;
+
    if (pSrcPicture) {
       if (pSrcPicture->pSourcePict) {
          if (pSrcPicture->pSourcePict->type == SourcePictTypeSolidFill) {
             fs_traits |= FS_SOLID_FILL;
             vs_traits |= VS_SOLID_FILL;
-            pixel_to_float4(pSrcPicture->pFormat,
-                            pSrcPicture->pSourcePict->solidFill.color,
-                            exa->solid_color);
+            render_pixel_to_float4(pSrcPicture->pFormat,
+                                   pSrcPicture->pSourcePict->solidFill.color,
+                                   exa->solid_color);
+            exa->has_solid_color = TRUE;
          } else {
             debug_assert("!gradients not supported");
          }
@@ -478,15 +532,15 @@ setup_vs_constant_buffer(struct exa_context *exa,
    struct pipe_constant_buffer *cbuf = &exa->vs_const_buffer;
 
    pipe_buffer_reference(&cbuf->buffer, NULL);
-   cbuf->buffer = pipe_buffer_create(exa->ctx->screen, 16,
+   cbuf->buffer = pipe_buffer_create(exa->pipe->screen, 16,
                                      PIPE_BUFFER_USAGE_CONSTANT,
                                      param_bytes);
 
    if (cbuf->buffer) {
-      pipe_buffer_write(exa->ctx->screen, cbuf->buffer,
+      pipe_buffer_write(exa->pipe->screen, cbuf->buffer,
                         0, param_bytes, vs_consts);
    }
-   exa->ctx->set_constant_buffer(exa->ctx, PIPE_SHADER_VERTEX, 0, cbuf);
+   exa->pipe->set_constant_buffer(exa->pipe, PIPE_SHADER_VERTEX, 0, cbuf);
 }
 
 
@@ -500,22 +554,22 @@ setup_fs_constant_buffer(struct exa_context *exa)
    struct pipe_constant_buffer *cbuf = &exa->fs_const_buffer;
 
    pipe_buffer_reference(&cbuf->buffer, NULL);
-   cbuf->buffer = pipe_buffer_create(exa->ctx->screen, 16,
+   cbuf->buffer = pipe_buffer_create(exa->pipe->screen, 16,
                                      PIPE_BUFFER_USAGE_CONSTANT,
                                      param_bytes);
 
    if (cbuf->buffer) {
-      pipe_buffer_write(exa->ctx->screen, cbuf->buffer,
+      pipe_buffer_write(exa->pipe->screen, cbuf->buffer,
                         0, param_bytes, fs_consts);
    }
-   exa->ctx->set_constant_buffer(exa->ctx, PIPE_SHADER_FRAGMENT, 0, cbuf);
+   exa->pipe->set_constant_buffer(exa->pipe, PIPE_SHADER_FRAGMENT, 0, cbuf);
 }
 
 static void
-setup_constant_buffers(struct exa_context *exa, PicturePtr pDstPicture)
+setup_constant_buffers(struct exa_context *exa, struct exa_pixmap_priv *pDst)
 {
-   int width = pDstPicture->pDrawable->width;
-   int height = pDstPicture->pDrawable->height;
+   int width = pDst->tex->width[0];
+   int height = pDst->tex->height[0];
 
    setup_vs_constant_buffer(exa, width, height);
    setup_fs_constant_buffer(exa);
@@ -530,15 +584,15 @@ boolean xorg_composite_bind_state(struct exa_context *exa,
                                   struct exa_pixmap_priv *pMask,
                                   struct exa_pixmap_priv *pDst)
 {
-   bind_framebuffer_state(exa, pDstPicture, pDst);
-   bind_viewport_state(exa, pDstPicture);
+   bind_framebuffer_state(exa, pDst);
+   bind_viewport_state(exa, pDst);
    bind_blend_state(exa, op, pSrcPicture, pMaskPicture);
    bind_rasterizer_state(exa);
    bind_shaders(exa, op, pSrcPicture, pMaskPicture);
    bind_samplers(exa, op, pSrcPicture, pMaskPicture,
                  pDstPicture, pSrc, pMask, pDst);
-
-   setup_constant_buffers(exa, pDstPicture);
+   bind_clip_state(exa);
+   setup_constant_buffers(exa, pDst);
 
    return FALSE;
 }
@@ -548,7 +602,7 @@ void xorg_composite(struct exa_context *exa,
                     int srcX, int srcY, int maskX, int maskY,
                     int dstX, int dstY, int width, int height)
 {
-   struct pipe_context *pipe = exa->ctx;
+   struct pipe_context *pipe = exa->pipe;
    struct pipe_buffer *buf = 0;
 
    if (exa->num_bound_samplers == 0 ) { /* solid fill */
@@ -573,12 +627,455 @@ void xorg_composite(struct exa_context *exa,
    }
 
    if (buf) {
+      int num_attribs = 1; /*pos*/
+      num_attribs += exa->num_bound_samplers;
+      if (exa->has_solid_color)
+         ++num_attribs;
+
+      util_draw_vertex_buffer(pipe, buf, 0,
+                              PIPE_PRIM_TRIANGLE_FAN,
+                              4,  /* verts */
+                              num_attribs); /* attribs/vert */
+
+      pipe_buffer_reference(&buf, NULL);
+   }
+}
+
+boolean xorg_solid_bind_state(struct exa_context *exa,
+                              struct exa_pixmap_priv *pixmap,
+                              Pixel fg)
+{
+   unsigned vs_traits, fs_traits;
+   struct xorg_shader shader;
+
+   pixel_to_float4(fg, exa->solid_color);
+   exa->has_solid_color = TRUE;
+
+   exa->solid_color[3] = 1.f;
+
+#if 0
+   debug_printf("Color Pixel=(%d, %d, %d, %d), RGBA=(%f, %f, %f, %f)\n",
+                (fg >> 24) & 0xff, (fg >> 16) & 0xff,
+                (fg >> 8) & 0xff,  (fg >> 0) & 0xff,
+                exa->solid_color[0], exa->solid_color[1],
+                exa->solid_color[2], exa->solid_color[3]);
+#endif
+
+   vs_traits = VS_SOLID_FILL;
+   fs_traits = FS_SOLID_FILL;
+
+   bind_framebuffer_state(exa, pixmap);
+   bind_viewport_state(exa, pixmap);
+   bind_rasterizer_state(exa);
+   bind_blend_state(exa, PictOpSrc, NULL, NULL);
+   setup_constant_buffers(exa, pixmap);
+   bind_clip_state(exa);
+
+   shader = xorg_shaders_get(exa->shaders, vs_traits, fs_traits);
+   cso_set_vertex_shader_handle(exa->cso, shader.vs);
+   cso_set_fragment_shader_handle(exa->cso, shader.fs);
+
+   return FALSE;
+}
+
+void xorg_solid(struct exa_context *exa,
+                struct exa_pixmap_priv *pixmap,
+                int x0, int y0, int x1, int y1)
+{
+   struct pipe_context *pipe = exa->pipe;
+   struct pipe_buffer *buf = 0;
+   float vertices[4][2][4];
+
+   /* 1st vertex */
+   setup_vertex0(vertices[0], x0, y0,
+                 exa->solid_color);
+   /* 2nd vertex */
+   setup_vertex0(vertices[1], x1, y0,
+                 exa->solid_color);
+   /* 3rd vertex */
+   setup_vertex0(vertices[2], x1, y1,
+                 exa->solid_color);
+   /* 4th vertex */
+   setup_vertex0(vertices[3], x0, y1,
+                 exa->solid_color);
+
+   buf = pipe_user_buffer_create(exa->pipe->screen,
+                                 vertices,
+                                 sizeof(vertices));
+
+
+   if (buf) {
+      debug_printf("Drawing buf is %p\n", buf);
       util_draw_vertex_buffer(pipe, buf, 0,
                               PIPE_PRIM_TRIANGLE_FAN,
                               4,  /* verts */
-                              1 + exa->num_bound_samplers); /* attribs/vert */
+                              2); /* attribs/vert */
+
+      pipe_buffer_reference(&buf, NULL);
+   }
+}
+
+
+static INLINE void shift_rectx(float coords[4],
+                               const float *bounds,
+                               const float shift)
+{
+   coords[0] += shift;
+   coords[2] -= shift;
+   if (bounds) {
+      coords[2] = MIN2(coords[2], bounds[2]);
+      /* bound x/y + width/height */
+      if ((coords[0] + coords[2]) > (bounds[0] + bounds[2])) {
+         coords[2] = (bounds[0] + bounds[2]) - coords[0];
+      }
+   }
+}
+
+static INLINE void shift_recty(float coords[4],
+                               const float *bounds,
+                               const float shift)
+{
+   coords[1] += shift;
+   coords[3] -= shift;
+   if (bounds) {
+      coords[3] = MIN2(coords[3], bounds[3]);
+      if ((coords[1] + coords[3]) > (bounds[1] + bounds[3])) {
+         coords[3] = (bounds[1] + bounds[3]) - coords[1];
+      }
+   }
+}
+
+static INLINE void bound_rect(float coords[4],
+                              const float bounds[4],
+                              float shift[4])
+{
+   /* if outside the bounds */
+   if (coords[0] > (bounds[0] + bounds[2]) ||
+       coords[1] > (bounds[1] + bounds[3]) ||
+       (coords[0] + coords[2]) < bounds[0] ||
+       (coords[1] + coords[3]) < bounds[1]) {
+      coords[0] = 0.f;
+      coords[1] = 0.f;
+      coords[2] = 0.f;
+      coords[3] = 0.f;
+      shift[0] = 0.f;
+      shift[1] = 0.f;
+      return;
+   }
+
+   /* bound x */
+   if (coords[0] < bounds[0]) {
+      shift[0] = bounds[0] - coords[0];
+      coords[2] -= shift[0];
+      coords[0] = bounds[0];
+   } else
+      shift[0] = 0.f;
+
+   /* bound y */
+   if (coords[1] < bounds[1]) {
+      shift[1] = bounds[1] - coords[1];
+      coords[3] -= shift[1];
+      coords[1] = bounds[1];
+   } else
+      shift[1] = 0.f;
+
+   shift[2] = bounds[2] - coords[2];
+   shift[3] = bounds[3] - coords[3];
+   /* bound width/height */
+   coords[2] = MIN2(coords[2], bounds[2]);
+   coords[3] = MIN2(coords[3], bounds[3]);
+
+   /* bound x/y + width/height */
+   if ((coords[0] + coords[2]) > (bounds[0] + bounds[2])) {
+      coords[2] = (bounds[0] + bounds[2]) - coords[0];
+   }
+   if ((coords[1] + coords[3]) > (bounds[1] + bounds[3])) {
+      coords[3] = (bounds[1] + bounds[3]) - coords[1];
+   }
+
+   /* if outside the bounds */
+   if ((coords[0] + coords[2]) < bounds[0] ||
+       (coords[1] + coords[3]) < bounds[1]) {
+      coords[0] = 0.f;
+      coords[1] = 0.f;
+      coords[2] = 0.f;
+      coords[3] = 0.f;
+      return;
+   }
+}
+
+static INLINE void sync_size(float *src_loc, float *dst_loc)
+{
+   src_loc[2] = MIN2(src_loc[2], dst_loc[2]);
+   src_loc[3] = MIN2(src_loc[3], dst_loc[3]);
+   dst_loc[2] = src_loc[2];
+   dst_loc[3] = src_loc[3];
+}
+
+
+static void renderer_copy_texture(struct exa_context *exa,
+                                  struct pipe_texture *src,
+                                  float sx1, float sy1,
+                                  float sx2, float sy2,
+                                  struct pipe_texture *dst,
+                                  float dx1, float dy1,
+                                  float dx2, float dy2)
+{
+   struct pipe_context *pipe = exa->pipe;
+   struct pipe_screen *screen = pipe->screen;
+   struct pipe_buffer *buf;
+   struct pipe_surface *dst_surf = screen->get_tex_surface(
+      screen, dst, 0, 0, 0,
+      PIPE_BUFFER_USAGE_GPU_WRITE);
+   struct pipe_framebuffer_state fb;
+   float s0, t0, s1, t1;
+   struct xorg_shader shader;
+
+   assert(src->width[0] != 0);
+   assert(src->height[0] != 0);
+   assert(dst->width[0] != 0);
+   assert(dst->height[0] != 0);
+
+#if 1
+   s0 = sx1 / src->width[0];
+   s1 = sx2 / src->width[0];
+   t0 = sy1 / src->height[0];
+   t1 = sy2 / src->height[0];
+#else
+   s0 = 0;
+   s1 = 1;
+   t0 = 0;
+   t1 = 1;
+#endif
+
+#if 1
+   debug_printf("copy texture src=[%f, %f, %f, %f], dst=[%f, %f, %f, %f], tex=[%f, %f, %f, %f]\n",
+                sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2,
+                s0, t0, s1, t1);
+#endif
+
+   assert(screen->is_format_supported(screen, dst_surf->format,
+                                      PIPE_TEXTURE_2D,
+                                      PIPE_TEXTURE_USAGE_RENDER_TARGET,
+                                      0));
+
+   /* save state (restored below) */
+   cso_save_blend(exa->cso);
+   cso_save_samplers(exa->cso);
+   cso_save_sampler_textures(exa->cso);
+   cso_save_framebuffer(exa->cso);
+   cso_save_fragment_shader(exa->cso);
+   cso_save_vertex_shader(exa->cso);
+
+   cso_save_viewport(exa->cso);
+
+
+   /* set misc state we care about */
+   {
+      struct pipe_blend_state blend;
+      memset(&blend, 0, sizeof(blend));
+      blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE;
+      blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE;
+      blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
+      blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
+      blend.colormask = PIPE_MASK_RGBA;
+      cso_set_blend(exa->cso, &blend);
+   }
+
+   /* sampler */
+   {
+      struct pipe_sampler_state sampler;
+      memset(&sampler, 0, sizeof(sampler));
+      sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+      sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+      sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+      sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
+      sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
+      sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
+      sampler.normalized_coords = 1;
+      cso_single_sampler(exa->cso, 0, &sampler);
+      cso_single_sampler_done(exa->cso);
+   }
+
+   set_viewport(exa, dst_surf->width, dst_surf->height, Y0_TOP);
+
+   /* texture */
+   cso_set_sampler_textures(exa->cso, 1, &src);
+
+   /* shaders */
+   shader = xorg_shaders_get(exa->shaders,
+                             VS_COMPOSITE,
+                             FS_COMPOSITE);
+   cso_set_vertex_shader_handle(exa->cso, shader.vs);
+   cso_set_fragment_shader_handle(exa->cso, shader.fs);
+
+   /* drawing dest */
+   memset(&fb, 0, sizeof(fb));
+   fb.width = dst_surf->width;
+   fb.height = dst_surf->height;
+   fb.nr_cbufs = 1;
+   fb.cbufs[0] = dst_surf;
+   {
+      int i;
+      for (i = 1; i < PIPE_MAX_COLOR_BUFS; ++i)
+         fb.cbufs[i] = 0;
+   }
+   cso_set_framebuffer(exa->cso, &fb);
+   setup_vs_constant_buffer(exa, fb.width, fb.height);
+   setup_fs_constant_buffer(exa);
+
+   /* draw quad */
+   buf = setup_vertex_data_tex(exa,
+                               dx1, dy1,
+                               dx2, dy2,
+                               s0, t0, s1, t1,
+                               0.0f);
+
+   if (buf) {
+      util_draw_vertex_buffer(exa->pipe, buf, 0,
+                              PIPE_PRIM_TRIANGLE_FAN,
+                              4,  /* verts */
+                              2); /* attribs/vert */
 
       pipe_buffer_reference(&buf, NULL);
    }
+
+   /* restore state we changed */
+   cso_restore_blend(exa->cso);
+   cso_restore_samplers(exa->cso);
+   cso_restore_sampler_textures(exa->cso);
+   cso_restore_framebuffer(exa->cso);
+   cso_restore_vertex_shader(exa->cso);
+   cso_restore_fragment_shader(exa->cso);
+   cso_restore_viewport(exa->cso);
+
+   pipe_surface_reference(&dst_surf, NULL);
+}
+
+
+static struct pipe_texture *
+create_sampler_texture(struct exa_context *ctx,
+                       struct pipe_texture *src)
+{
+   enum pipe_format format;
+   struct pipe_context *pipe = ctx->pipe;
+   struct pipe_screen *screen = pipe->screen;
+   struct pipe_texture *pt;
+   struct pipe_texture templ;
+
+   pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
+
+   /* the coming in texture should already have that invariance */
+   debug_assert(screen->is_format_supported(screen, src->format,
+                                            PIPE_TEXTURE_2D,
+                                            PIPE_TEXTURE_USAGE_SAMPLER, 0));
+
+   format = src->format;
+
+   memset(&templ, 0, sizeof(templ));
+   templ.target = PIPE_TEXTURE_2D;
+   templ.format = format;
+   templ.last_level = 0;
+   templ.width[0] = src->width[0];
+   templ.height[0] = src->height[0];
+   templ.depth[0] = 1;
+   pf_get_block(format, &templ.block);
+   templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
+
+   pt = screen->texture_create(screen, &templ);
+
+   debug_assert(!pt || pipe_is_referenced(&pt->reference));
+
+   if (!pt)
+      return NULL;
+
+   {
+      /* copy source framebuffer surface into texture */
+      struct pipe_surface *ps_read = screen->get_tex_surface(
+         screen, src, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ);
+      struct pipe_surface *ps_tex = screen->get_tex_surface(
+         screen, pt, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE );
+      pipe->surface_copy(pipe,
+			 ps_tex, /* dest */
+			 0, 0, /* destx/y */
+			 ps_read,
+			 0, 0, src->width[0], src->height[0]);
+      pipe_surface_reference(&ps_read, NULL);
+      pipe_surface_reference(&ps_tex, NULL);
+   }
+
+   return pt;
+}
+
+void xorg_copy_pixmap(struct exa_context *ctx,
+                      struct exa_pixmap_priv *dst_priv, int dx, int dy,
+                      struct exa_pixmap_priv *src_priv, int sx, int sy,
+                      int width, int height)
+{
+   float dst_loc[4], src_loc[4];
+   float dst_bounds[4], src_bounds[4];
+   float src_shift[4], dst_shift[4], shift[4];
+   struct pipe_texture *dst = dst_priv->tex;
+   struct pipe_texture *src = src_priv->tex;
+
+   xorg_exa_finish(ctx);
+
+   dst_loc[0] = dx;
+   dst_loc[1] = dy;
+   dst_loc[2] = width;
+   dst_loc[3] = height;
+   dst_bounds[0] = 0.f;
+   dst_bounds[1] = 0.f;
+   dst_bounds[2] = dst->width[0];
+   dst_bounds[3] = dst->height[0];
+
+   src_loc[0] = sx;
+   src_loc[1] = sy;
+   src_loc[2] = width;
+   src_loc[3] = height;
+   src_bounds[0] = 0.f;
+   src_bounds[1] = 0.f;
+   src_bounds[2] = src->width[0];
+   src_bounds[3] = src->height[0];
+
+   bound_rect(src_loc, src_bounds, src_shift);
+   bound_rect(dst_loc, dst_bounds, dst_shift);
+   shift[0] = src_shift[0] - dst_shift[0];
+   shift[1] = src_shift[1] - dst_shift[1];
+
+   if (shift[0] < 0)
+      shift_rectx(src_loc, src_bounds, -shift[0]);
+   else
+      shift_rectx(dst_loc, dst_bounds, shift[0]);
+
+   if (shift[1] < 0)
+      shift_recty(src_loc, src_bounds, -shift[1]);
+   else
+      shift_recty(dst_loc, dst_bounds, shift[1]);
+
+   sync_size(src_loc, dst_loc);
+
+   if (src_loc[2] >= 0 && src_loc[3] >= 0 &&
+       dst_loc[2] >= 0 && dst_loc[3] >= 0) {
+      struct pipe_texture *temp_src = src;
+
+      if (src == dst)
+         temp_src = create_sampler_texture(ctx, src);
+
+      renderer_copy_texture(ctx,
+                            temp_src,
+                            src_loc[0],
+                            src_loc[1],
+                            src_loc[0] + src_loc[2],
+                            src_loc[1] + src_loc[3],
+                            dst,
+                            dst_loc[0],
+                            dst_loc[1],
+                            dst_loc[0] + dst_loc[2],
+                            dst_loc[1] + dst_loc[3]);
+
+      if (src == dst)
+         pipe_texture_reference(&temp_src, NULL);
+   }
 }
 
diff --git a/src/gallium/state_trackers/xorg/xorg_composite.h b/src/gallium/state_trackers/xorg/xorg_composite.h
index 17dfcb199e..e73f1c704a 100644
--- a/src/gallium/state_trackers/xorg/xorg_composite.h
+++ b/src/gallium/state_trackers/xorg/xorg_composite.h
@@ -22,4 +22,16 @@ void xorg_composite(struct exa_context *exa,
                     int srcX, int srcY, int maskX, int maskY,
                     int dstX, int dstY, int width, int height);
 
+boolean xorg_solid_bind_state(struct exa_context *exa,
+                              struct exa_pixmap_priv *pixmap,
+                              Pixel fg);
+void xorg_solid(struct exa_context *exa,
+                struct exa_pixmap_priv *pixmap,
+                int x0, int y0, int x1, int y1);
+
+void xorg_copy_pixmap(struct exa_context *ctx,
+                      struct exa_pixmap_priv *dst, int dx, int dy,
+                      struct exa_pixmap_priv *src, int sx, int sy,
+                      int width, int height);
+
 #endif
diff --git a/src/gallium/state_trackers/xorg/xorg_crtc.c b/src/gallium/state_trackers/xorg/xorg_crtc.c
index fe08bde9ef..67fe29a69d 100644
--- a/src/gallium/state_trackers/xorg/xorg_crtc.c
+++ b/src/gallium/state_trackers/xorg/xorg_crtc.c
@@ -42,8 +42,12 @@
 #include "xorg_tracker.h"
 #include "xf86Modes.h"
 
+#ifdef HAVE_XEXTPROTO_71
+#include <X11/extensions/dpmsconst.h>
+#else
 #define DPMS_SERVER
 #include <X11/extensions/dpms.h>
+#endif
 
 #include "pipe/p_inlines.h"
 #include "util/u_rect.h"
diff --git a/src/gallium/state_trackers/xorg/xorg_dri2.c b/src/gallium/state_trackers/xorg/xorg_dri2.c
index 6431a0fe25..8a362596c7 100644
--- a/src/gallium/state_trackers/xorg/xorg_dri2.c
+++ b/src/gallium/state_trackers/xorg/xorg_dri2.c
@@ -118,6 +118,7 @@ driDoCreateBuffer(DrawablePtr pDraw, DRI2BufferPtr buffer, unsigned int format)
     }
 
     if (!tex) {
+	exaMoveInPixmap(private->pPixmap);
 	xorg_exa_set_shared_usage(private->pPixmap);
 	pScreen->ModifyPixmapHeader(private->pPixmap, 0, 0, 0, 0, 0, NULL);
 	tex = xorg_exa_get_texture(private->pPixmap);
diff --git a/src/gallium/state_trackers/xorg/xorg_exa.c b/src/gallium/state_trackers/xorg/xorg_exa.c
index a17a71f23a..dea9f4c2bc 100644
--- a/src/gallium/state_trackers/xorg/xorg_exa.c
+++ b/src/gallium/state_trackers/xorg/xorg_exa.c
@@ -47,6 +47,8 @@
 
 #include "util/u_rect.h"
 
+#define DEBUG_SOLID 0
+
 /*
  * Helper functions
  */
@@ -72,6 +74,9 @@ exa_get_pipe_format(int depth, enum pipe_format *format, int *bbp)
 	assert(*bbp == 16);
 	break;
     case 8:
+	*format = PIPE_FORMAT_A8_UNORM;
+	assert(*bbp == 8);
+	break;
     case 4:
     case 1:
 	*format = PIPE_FORMAT_A8R8G8B8_UNORM; /* bad bad bad */
@@ -82,6 +87,25 @@ exa_get_pipe_format(int depth, enum pipe_format *format, int *bbp)
     }
 }
 
+static void
+xorg_exa_init_state(struct exa_context *exa)
+{
+   struct pipe_depth_stencil_alpha_state dsa;
+
+   /* set common initial clip state */
+   memset(&dsa, 0, sizeof(struct pipe_depth_stencil_alpha_state));
+   cso_set_depth_stencil_alpha(exa->cso, &dsa);
+}
+
+static void
+xorg_exa_common_done(struct exa_context *exa)
+{
+   exa->copy.src = NULL;
+   exa->copy.dst = NULL;
+   exa->has_solid_color = FALSE;
+   exa->num_bound_samplers = 0;
+}
+
 /*
  * Static exported EXA functions
  */
@@ -111,9 +135,9 @@ ExaDownloadFromScreen(PixmapPtr pPix, int x,  int y, int w,  int h, char *dst,
     if (!priv || !priv->tex)
 	return FALSE;
 
-    if (exa->ctx->is_texture_referenced(exa->ctx, priv->tex, 0, 0) &
+    if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
 	PIPE_REFERENCED_FOR_WRITE)
-	exa->ctx->flush(exa->ctx, 0, NULL);
+	exa->pipe->flush(exa->pipe, 0, NULL);
 
     transfer = exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
 					   PIPE_TRANSFER_READ, x, y, w, h);
@@ -178,9 +202,9 @@ ExaPrepareAccess(PixmapPtr pPix, int index)
 
     if (priv->map_count++ == 0)
     {
-	if (exa->ctx->is_texture_referenced(exa->ctx, priv->tex, 0, 0) &
+	if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
 	    PIPE_REFERENCED_FOR_WRITE)
-	    exa->ctx->flush(exa->ctx, 0, NULL);
+	    exa->pipe->flush(exa->pipe, 0, NULL);
 
 	priv->map_transfer =
 	    exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
@@ -231,15 +255,22 @@ ExaDone(PixmapPtr pPixmap)
     if (!priv)
 	return;
 
-    if (priv->src_surf)
-	exa->scrn->tex_surface_destroy(priv->src_surf);
-    priv->src_surf = NULL;
+#if 1
+    xorg_exa_flush(exa, PIPE_FLUSH_RENDER_CACHE, NULL);
+#else
+    xorg_exa_finish(exa);
+#endif
+    xorg_exa_common_done(exa);
 }
 
 static void
 ExaDoneComposite(PixmapPtr pPixmap)
 {
+   ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
+   modesettingPtr ms = modesettingPTR(pScrn);
+   struct exa_context *exa = ms->exa;
 
+   xorg_exa_common_done(exa);
 }
 
 static Bool
@@ -250,24 +281,36 @@ ExaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg)
     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
     struct exa_context *exa = ms->exa;
 
-    if (pPixmap->drawable.depth < 15)
-	return FALSE;
-
+#if 0
+    debug_printf("ExaPrepareSolid - test\n");
+#endif
     if (!EXA_PM_IS_SOLID(&pPixmap->drawable, planeMask))
 	return FALSE;
 
     if (!priv || !priv->tex)
 	return FALSE;
 
+    if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
+                                        priv->tex->target,
+                                        PIPE_TEXTURE_USAGE_RENDER_TARGET, 0))
+	return FALSE;
+
     if (alu != GXcopy)
 	return FALSE;
 
-    if (!exa->ctx || !exa->ctx->surface_fill)
+    if (!exa->pipe)
 	return FALSE;
 
-    priv->color = fg;
 
-    return TRUE;
+#if DEBUG_SOLID
+    fg = 0xffff0000;
+#endif
+
+#if 1
+    debug_printf("  ExaPrepareSolid(0x%x)\n", fg);
+#endif
+
+    return xorg_solid_bind_state(exa, priv, fg);
 }
 
 static void
@@ -277,12 +320,49 @@ ExaSolid(PixmapPtr pPixmap, int x0, int y0, int x1, int y1)
     modesettingPtr ms = modesettingPTR(pScrn);
     struct exa_context *exa = ms->exa;
     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
-    struct pipe_surface *surf = exa_gpu_surface(exa, priv);
 
-    exa->ctx->surface_fill(exa->ctx, surf, x0, y0, x1 - x0, y1 - y0,
-			   priv->color);
+    debug_printf("\tExaSolid(%d, %d, %d, %d)\n", x0, y0, x1, y1);
+
+#if 0
+    if (x0 == 0 && y0 == 0 &&
+        x1 == priv->tex->width[0] &&
+        y1 == priv->tex->height[0]) {
+       exa->ctx->clear(exa->pipe, PIPE_CLEAR_COLOR,
+                       exa->solid_color, 1., 0);
+    } else
+#endif
 
-    exa->scrn->tex_surface_destroy(surf);
+#if DEBUG_SOLID
+       exa->solid_color[0] = 0.f;
+       exa->solid_color[1] = 1.f;
+       exa->solid_color[2] = 0.f;
+       exa->solid_color[3] = 1.f;
+    xorg_solid(exa, priv, 0, 0, 1024, 768);
+       exa->solid_color[0] = 1.f;
+       exa->solid_color[1] = 0.f;
+       exa->solid_color[2] = 0.f;
+       exa->solid_color[3] = 1.f;
+       xorg_solid(exa, priv, 0, 0, 300, 300);
+       xorg_solid(exa, priv, 300, 300, 350, 350);
+       xorg_solid(exa, priv, 350, 350, 500, 500);
+
+       xorg_solid(exa, priv,
+               priv->tex->width[0] - 10,
+               priv->tex->height[0] - 10,
+               priv->tex->width[0],
+               priv->tex->height[0]);
+
+    exa->solid_color[0] = 0.f;
+    exa->solid_color[1] = 0.f;
+    exa->solid_color[2] = 1.f;
+    exa->solid_color[3] = 1.f;
+
+    exa->has_solid_color = FALSE;
+    ExaPrepareCopy(pPixmap, pPixmap, 0, 0, GXcopy, 0xffffffff);
+    ExaCopy(pPixmap, 0, 0, 50, 50, 500, 500);
+#else
+    xorg_solid(exa, priv, x0, y0, x1, y1) ;
+#endif
 }
 
 static Bool
@@ -295,10 +375,9 @@ ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir,
     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
     struct exa_pixmap_priv *src_priv = exaGetPixmapDriverPrivate(pSrcPixmap);
 
-    if (alu != GXcopy)
-	return FALSE;
+    debug_printf("ExaPrepareCopy\n");
 
-    if (pSrcPixmap->drawable.depth < 15 || pDstPixmap->drawable.depth < 15)
+    if (alu != GXcopy)
 	return FALSE;
 
     if (!EXA_PM_IS_SOLID(&pSrcPixmap->drawable, planeMask))
@@ -307,30 +386,44 @@ ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir,
     if (!priv || !src_priv)
 	return FALSE;
 
+    if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
+                                        priv->tex->target,
+                                        PIPE_TEXTURE_USAGE_RENDER_TARGET, 0) ||
+        !exa->scrn->is_format_supported(exa->scrn, src_priv->tex->format,
+                                        src_priv->tex->target,
+                                        PIPE_TEXTURE_USAGE_SAMPLER, 0))
+	return FALSE;
+
     if (!priv->tex || !src_priv->tex)
 	return FALSE;
 
-    if (!exa->ctx || !exa->ctx->surface_copy)
+    if (!exa->pipe)
 	return FALSE;
 
-    priv->src_surf = exa_gpu_surface(exa, src_priv);
+    exa->copy.src = src_priv;
+    exa->copy.dst = priv;
 
-    return TRUE;
+    /*XXX disabled until some issues with syncing are fixed */
+    return FALSE;
 }
 
 static void
 ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY,
 	int width, int height)
 {
-    ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
-    modesettingPtr ms = modesettingPTR(pScrn);
-    struct exa_context *exa = ms->exa;
-    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
-    struct pipe_surface *surf = exa_gpu_surface(exa, priv);
+   ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
+   modesettingPtr ms = modesettingPTR(pScrn);
+   struct exa_context *exa = ms->exa;
+   struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
+
+   debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n",
+                srcX, srcY, dstX, dstY, width, height);
+
+   debug_assert(priv == exa->copy.dst);
 
-    exa->ctx->surface_copy(exa->ctx, surf, dstX, dstY, priv->src_surf,
-			   srcX, srcY, width, height);
-    exa->scrn->tex_surface_destroy(surf);
+   xorg_copy_pixmap(exa, exa->copy.dst, dstX, dstY,
+                    exa->copy.src, srcX, srcY,
+                    width, height);
 }
 
 static Bool
@@ -342,6 +435,8 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture,
    modesettingPtr ms = modesettingPTR(pScrn);
    struct exa_context *exa = ms->exa;
 
+   debug_printf("ExaPrepareComposite\n");
+
    return xorg_composite_bind_state(exa, op, pSrcPicture, pMaskPicture,
                                     pDstPicture,
                                     exaGetPixmapDriverPrivate(pSrc),
@@ -358,6 +453,8 @@ ExaComposite(PixmapPtr pDst, int srcX, int srcY, int maskX, int maskY,
    struct exa_context *exa = ms->exa;
    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDst);
 
+   debug_printf("\tExaComposite\n");
+
    xorg_composite(exa, priv, srcX, srcY, maskX, maskY,
                   dstX, dstY, width, height);
 }
@@ -389,14 +486,11 @@ static void
 ExaDestroyPixmap(ScreenPtr pScreen, void *dPriv)
 {
     struct exa_pixmap_priv *priv = (struct exa_pixmap_priv *)dPriv;
-    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-    modesettingPtr ms = modesettingPTR(pScrn);
 
     if (!priv)
 	return;
 
-    if (priv->tex)
-	ms->screen->texture_destroy(priv->tex);
+    pipe_texture_reference(&priv->tex, NULL);
 
     xfree(priv);
 }
@@ -537,16 +631,16 @@ ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
 
 	    if (priv->tex) {
 		struct pipe_surface *dst_surf;
-
-		dst_surf = exa->scrn->get_tex_surface(exa->scrn, texture, 0, 0, 0,
-						      PIPE_BUFFER_USAGE_GPU_WRITE);
-		priv->src_surf = exa_gpu_surface(exa, priv);
-		exa->ctx->surface_copy(exa->ctx, dst_surf, 0, 0, priv->src_surf,
-				       0, 0, min(width, texture->width[0]),
-				       min(height, texture->height[0]));
+                struct pipe_surface *src_surf;
+
+		dst_surf = exa->scrn->get_tex_surface(
+                   exa->scrn, texture, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
+		src_surf = exa_gpu_surface(exa, priv);
+		exa->pipe->surface_copy(exa->pipe, dst_surf, 0, 0, src_surf,
+                                        0, 0, min(width, texture->width[0]),
+                                        min(height, texture->height[0]));
 		exa->scrn->tex_surface_destroy(dst_surf);
-		exa->scrn->tex_surface_destroy(priv->src_surf);
-		priv->src_surf = NULL;
+		exa->scrn->tex_surface_destroy(src_surf);
 	    } else if (pPixmap->devPrivate.ptr) {
 		struct pipe_transfer *transfer;
 
@@ -563,6 +657,9 @@ ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
 			       pPixmap->devKind, 0, 0);
 		exa->scrn->transfer_unmap(exa->scrn, transfer);
 		exa->scrn->tex_transfer_destroy(transfer);
+
+		xfree(pPixmap->devPrivate.ptr);
+		pPixmap->devPrivate.ptr = NULL;
 	    }
 	}
 #ifdef DRM_MODE_FEATURE_DIRTYFB
@@ -611,8 +708,8 @@ xorg_exa_close(ScrnInfoPtr pScrn)
       cso_destroy_context(exa->cso);
    }
 
-   if (exa->ctx)
-      exa->ctx->destroy(exa->ctx);
+   if (exa->pipe)
+      exa->pipe->destroy(exa->pipe);
 
    exaDriverFini(pScrn->pScreen);
    xfree(exa);
@@ -645,6 +742,12 @@ xorg_exa_init(ScrnInfoPtr pScrn)
    pExa->pixmapOffsetAlign = 0;
    pExa->pixmapPitchAlign  = 1;
    pExa->flags             = EXA_OFFSCREEN_PIXMAPS | EXA_HANDLES_PIXMAPS;
+#ifdef EXA_SUPPORTS_PREPARE_AUX
+   pExa->flags            |= EXA_SUPPORTS_PREPARE_AUX;
+#endif
+#ifdef EXA_MIXED_PIXMAPS
+   pExa->flags            |= EXA_MIXED_PIXMAPS;
+#endif
    pExa->maxX              = 8191; /* FIXME */
    pExa->maxY              = 8191; /* FIXME */
 
@@ -674,13 +777,15 @@ xorg_exa_init(ScrnInfoPtr pScrn)
    }
 
    exa->scrn = ms->screen;
-   exa->ctx = ms->api->create_context(ms->api, exa->scrn);
+   exa->pipe = ms->api->create_context(ms->api, exa->scrn);
    /* Share context with DRI */
-   ms->ctx = exa->ctx;
+   ms->ctx = exa->pipe;
 
-   exa->cso = cso_create_context(exa->ctx);
+   exa->cso = cso_create_context(exa->pipe);
    exa->shaders = xorg_shaders_create(exa);
 
+   xorg_exa_init_state(exa);
+
    return (void *)exa;
 
 out_err:
@@ -698,3 +803,19 @@ exa_gpu_surface(struct exa_context *exa, struct exa_pixmap_priv *priv)
 
 }
 
+void xorg_exa_flush(struct exa_context *exa, uint pipeFlushFlags,
+                    struct pipe_fence_handle **fence)
+{
+   exa->pipe->flush(exa->pipe, pipeFlushFlags, fence);
+}
+
+void xorg_exa_finish(struct exa_context *exa)
+{
+   struct pipe_fence_handle *fence = NULL;
+
+   xorg_exa_flush(exa, PIPE_FLUSH_RENDER_CACHE, &fence);
+
+   exa->pipe->screen->fence_finish(exa->pipe->screen, fence, 0);
+   exa->pipe->screen->fence_reference(exa->pipe->screen, &fence, NULL);
+}
+
diff --git a/src/gallium/state_trackers/xorg/xorg_exa.h b/src/gallium/state_trackers/xorg/xorg_exa.h
index 5b515be139..43949b04a4 100644
--- a/src/gallium/state_trackers/xorg/xorg_exa.h
+++ b/src/gallium/state_trackers/xorg/xorg_exa.h
@@ -14,7 +14,7 @@ struct xorg_shaders;
 struct exa_context
 {
    ExaDriverPtr pExa;
-   struct pipe_context *ctx;
+   struct pipe_context *pipe;
    struct pipe_screen *scrn;
    struct cso_context *cso;
    struct xorg_shaders *shaders;
@@ -26,6 +26,12 @@ struct exa_context
    int num_bound_samplers;
 
    float solid_color[4];
+   boolean has_solid_color;
+
+   struct {
+      struct exa_pixmap_priv *src;
+      struct exa_pixmap_priv *dst;
+   } copy;
 };
 
 
@@ -36,8 +42,6 @@ struct exa_pixmap_priv
 
    struct pipe_texture *tex;
    struct pipe_texture *depth_stencil_tex;
-   unsigned int color;
-   struct pipe_surface *src_surf; /* for copies */
 
    struct pipe_transfer *map_transfer;
    unsigned map_count;
@@ -46,5 +50,8 @@ struct exa_pixmap_priv
 struct pipe_surface *
 exa_gpu_surface(struct exa_context *exa, struct exa_pixmap_priv *priv);
 
+void xorg_exa_flush(struct exa_context *exa, uint pipeFlushFlags,
+                    struct pipe_fence_handle **fence);
+void xorg_exa_finish(struct exa_context *exa);
 
 #endif
diff --git a/src/gallium/state_trackers/xorg/xorg_exa_tgsi.c b/src/gallium/state_trackers/xorg/xorg_exa_tgsi.c
index cfee10c3b3..2daa5b5628 100644
--- a/src/gallium/state_trackers/xorg/xorg_exa_tgsi.c
+++ b/src/gallium/state_trackers/xorg/xorg_exa_tgsi.c
@@ -52,8 +52,7 @@ struct xorg_shaders {
 
 static const char over_op[] =
    "SUB TEMP[3], CONST[0].wwww, TEMP[1].wwww\n"
-   "MUL TEMP[3], TEMP[0], TEMP[3]\n"
-   "ADD TEMP[0], TEMP[3], TEMP[0]\n";
+   "MAD TEMP[3], TEMP[0], TEMP[3], TEMP[0]\n";
 
 
 static INLINE void
@@ -79,8 +78,7 @@ vs_normalize_coords(struct ureg_program *ureg, struct ureg_src coords,
 {
    struct ureg_dst tmp = ureg_DECL_temporary(ureg);
    struct ureg_src ret;
-   ureg_MUL(ureg, tmp, coords, const0);
-   ureg_ADD(ureg, tmp, ureg_src(tmp), const1);
+   ureg_MAD(ureg, tmp, coords, const0, const1);
    ret = ureg_src(tmp);
    ureg_release_temporary(ureg, tmp);
    return ret;
@@ -241,41 +239,38 @@ create_vs(struct pipe_context *pipe,
    boolean is_fill = vs_traits & VS_FILL;
    boolean is_composite = vs_traits & VS_COMPOSITE;
    boolean has_mask = vs_traits & VS_MASK;
+   unsigned input_slot = 0;
 
    ureg = ureg_create(TGSI_PROCESSOR_VERTEX);
    if (ureg == NULL)
       return 0;
 
-   const0 = ureg_DECL_constant(ureg);
-   const1 = ureg_DECL_constant(ureg);
+   const0 = ureg_DECL_constant(ureg, 0);
+   const1 = ureg_DECL_constant(ureg, 1);
 
    /* it has to be either a fill or a composite op */
    debug_assert(is_fill ^ is_composite);
 
-   src = ureg_DECL_vs_input(ureg,
-                            TGSI_SEMANTIC_POSITION, 0);
+   src = ureg_DECL_vs_input(ureg, input_slot++);
    dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
    src = vs_normalize_coords(ureg, src,
                              const0, const1);
    ureg_MOV(ureg, dst, src);
 
-
    if (is_composite) {
-      src = ureg_DECL_vs_input(ureg,
-                               TGSI_SEMANTIC_GENERIC, 1);
-      dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 1);
+      src = ureg_DECL_vs_input(ureg, input_slot++);
+      dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 0);
       ureg_MOV(ureg, dst, src);
    }
+
    if (is_fill) {
-      src = ureg_DECL_vs_input(ureg,
-                               TGSI_SEMANTIC_COLOR, 1);
-      dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 1);
+      src = ureg_DECL_vs_input(ureg, input_slot++);
+      dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
       ureg_MOV(ureg, dst, src);
    }
 
    if (has_mask) {
-      src = ureg_DECL_vs_input(ureg,
-                               TGSI_SEMANTIC_GENERIC, 2);
+      src = ureg_DECL_vs_input(ureg, input_slot++);
       dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 2);
       ureg_MOV(ureg, dst, src);
    }
@@ -315,11 +310,11 @@ create_fs(struct pipe_context *pipe,
    if (is_composite) {
       src_sampler = ureg_DECL_sampler(ureg, 0);
       src_input = ureg_DECL_fs_input(ureg,
-                                     TGSI_SEMANTIC_POSITION,
+                                     TGSI_SEMANTIC_GENERIC,
                                      0,
                                      TGSI_INTERPOLATE_PERSPECTIVE);
-   }
-   if (is_fill) {
+   } else {
+      debug_assert(is_fill);
       if (is_solid)
          src_input = ureg_DECL_fs_input(ureg,
                                         TGSI_SEMANTIC_COLOR,
@@ -370,11 +365,11 @@ create_fs(struct pipe_context *pipe,
          else
             src = out;
 
-         coords = ureg_DECL_constant(ureg);
-         const0124 = ureg_DECL_constant(ureg);
-         matrow0 = ureg_DECL_constant(ureg);
-         matrow1 = ureg_DECL_constant(ureg);
-         matrow2 = ureg_DECL_constant(ureg);
+         coords = ureg_DECL_constant(ureg, 0);
+         const0124 = ureg_DECL_constant(ureg, 1);
+         matrow0 = ureg_DECL_constant(ureg, 2);
+         matrow1 = ureg_DECL_constant(ureg, 3);
+         matrow2 = ureg_DECL_constant(ureg, 4);
 
          if (is_lingrad) {
             linear_gradient(ureg, src,
@@ -473,9 +468,9 @@ struct xorg_shader xorg_shaders_get(struct xorg_shaders *sc,
    struct xorg_shader shader = {0};
    void *vs, *fs;
 
-   vs = shader_from_cache(sc->exa->ctx, PIPE_SHADER_VERTEX,
+   vs = shader_from_cache(sc->exa->pipe, PIPE_SHADER_VERTEX,
                           sc->vs_hash, vs_traits);
-   fs = shader_from_cache(sc->exa->ctx, PIPE_SHADER_FRAGMENT,
+   fs = shader_from_cache(sc->exa->pipe, PIPE_SHADER_FRAGMENT,
                           sc->fs_hash, fs_traits);
 
    debug_assert(vs && fs);
diff --git a/src/gallium/state_trackers/xorg/xorg_output.c b/src/gallium/state_trackers/xorg/xorg_output.c
index 950af942f5..26f45f8d64 100644
--- a/src/gallium/state_trackers/xorg/xorg_output.c
+++ b/src/gallium/state_trackers/xorg/xorg_output.c
@@ -42,8 +42,12 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#ifdef HAVE_XEXTPROTO_71
+#include <X11/extensions/dpmsconst.h>
+#else
 #define DPMS_SERVER
 #include <X11/extensions/dpms.h>
+#endif
 
 #include "X11/Xatom.h"
 
diff --git a/src/gallium/winsys/drm/intel/dri/SConscript b/src/gallium/winsys/drm/intel/dri/SConscript
index 6c00861f51..f973811072 100644
--- a/src/gallium/winsys/drm/intel/dri/SConscript
+++ b/src/gallium/winsys/drm/intel/dri/SConscript
@@ -12,8 +12,9 @@ drivers = [
     trace,
 ]
 
-env.SharedLibrary(
+env.LoadableModule(
     target ='i915_dri.so',
     source = COMMON_GALLIUM_SOURCES,
     LIBS = drivers + mesa + auxiliaries + env['LIBS'],
+    SHLIBPREFIX = '',
 )
diff --git a/src/gallium/winsys/drm/intel/gem/intel_drm_batchbuffer.c b/src/gallium/winsys/drm/intel/gem/intel_drm_batchbuffer.c
index 5ca3ad9762..ebd1b607b7 100644
--- a/src/gallium/winsys/drm/intel/gem/intel_drm_batchbuffer.c
+++ b/src/gallium/winsys/drm/intel/gem/intel_drm_batchbuffer.c
@@ -13,6 +13,7 @@
 #define INTEL_BATCH_CLIPRECTS    0x2
 
 #undef INTEL_RUN_SYNC
+#undef INTEL_MAP_BATCHBUFFER
 
 struct intel_drm_batchbuffer
 {
@@ -40,8 +41,11 @@ intel_drm_batchbuffer_reset(struct intel_drm_batchbuffer *batch)
                                   "gallium3d_batchbuffer",
                                   batch->actual_size,
                                   4096);
+
+#ifdef INTEL_MAP_BATCHBUFFER
    drm_intel_bo_map(batch->bo, TRUE);
    batch->base.map = batch->bo->virtual;
+#endif
 
    memset(batch->base.map, 0, batch->actual_size);
    batch->base.ptr = batch->base.map;
@@ -55,7 +59,13 @@ intel_drm_batchbuffer_create(struct intel_winsys *iws)
    struct intel_drm_winsys *idws = intel_drm_winsys(iws);
    struct intel_drm_batchbuffer *batch = CALLOC_STRUCT(intel_drm_batchbuffer);
 
+   batch->actual_size = idws->max_batch_size;
+
+#ifdef INTEL_MAP_BATCHBUFFER
    batch->base.map = NULL;
+#else
+   batch->base.map = MALLOC(batch->actual_size);
+#endif
    batch->base.ptr = NULL;
    batch->base.size = 0;
 
@@ -64,8 +74,6 @@ intel_drm_batchbuffer_create(struct intel_winsys *iws)
 
    batch->base.iws = iws;
 
-   batch->actual_size = idws->max_batch_size;
-
    intel_drm_batchbuffer_reset(batch);
 
    return &batch->base;
@@ -156,7 +164,11 @@ intel_drm_batchbuffer_flush(struct intel_batchbuffer *ibatch,
 
    used = batch->base.ptr - batch->base.map;
 
+#ifdef INTEL_MAP_BATCHBUFFER
    drm_intel_bo_unmap(batch->bo);
+#else
+   drm_intel_bo_subdata(batch->bo, 0, used, batch->base.map);
+#endif
 
    /* Do the sending to HW */
    ret = drm_intel_bo_exec(batch->bo, used, NULL, 0, 0);
@@ -202,7 +214,10 @@ intel_drm_batchbuffer_destroy(struct intel_batchbuffer *ibatch)
    if (batch->bo)
       drm_intel_bo_unreference(batch->bo);
 
-   free(batch);
+#ifndef INTEL_MAP_BATCHBUFFER
+   FREE(batch->base.map);
+#endif
+   FREE(batch);
 }
 
 void intel_drm_winsys_init_batchbuffer_functions(struct intel_drm_winsys *idws)
diff --git a/src/gallium/winsys/drm/intel/gem/intel_drm_buffer.c b/src/gallium/winsys/drm/intel/gem/intel_drm_buffer.c
index e017cd2e98..0030f915a3 100644
--- a/src/gallium/winsys/drm/intel/gem/intel_drm_buffer.c
+++ b/src/gallium/winsys/drm/intel/gem/intel_drm_buffer.c
@@ -28,6 +28,7 @@ intel_drm_buffer_create(struct intel_winsys *iws,
    } else if (type == INTEL_NEW_VERTEX) {
       name = "gallium3d_vertex";
       pool = idws->pools.gem;
+      buf->map_gtt = TRUE;
    } else if (type == INTEL_NEW_SCANOUT) {
       name = "gallium3d_scanout";
       pool = idws->pools.gem;
@@ -109,6 +110,18 @@ intel_drm_buffer_unmap(struct intel_winsys *iws,
       drm_intel_bo_unmap(intel_bo(buffer));
 }
 
+static int
+intel_drm_buffer_write(struct intel_winsys *iws,
+                       struct intel_buffer *buffer,
+                       const void *data,
+                       size_t size,
+                       size_t offset)
+{
+   struct intel_drm_buffer *buf = intel_drm_buffer(buffer);
+
+   return drm_intel_bo_subdata(buf->bo, offset, size, (void*)data);
+}
+
 static void
 intel_drm_buffer_destroy(struct intel_winsys *iws,
                          struct intel_buffer *buffer)
@@ -130,5 +143,6 @@ intel_drm_winsys_init_buffer_functions(struct intel_drm_winsys *idws)
    idws->base.buffer_set_fence_reg = intel_drm_buffer_set_fence_reg;
    idws->base.buffer_map = intel_drm_buffer_map;
    idws->base.buffer_unmap = intel_drm_buffer_unmap;
+   idws->base.buffer_write = intel_drm_buffer_write;
    idws->base.buffer_destroy = intel_drm_buffer_destroy;
 }
diff --git a/src/gallium/winsys/drm/nouveau/drm/nouveau_drm_api.c b/src/gallium/winsys/drm/nouveau/drm/nouveau_drm_api.c
index 091cbbcfed..117ca6059b 100644
--- a/src/gallium/winsys/drm/nouveau/drm/nouveau_drm_api.c
+++ b/src/gallium/winsys/drm/nouveau/drm/nouveau_drm_api.c
@@ -112,7 +112,7 @@ nouveau_drm_create_screen(struct drm_api *api, int fd,
 		return NULL;
 	}
 
-	if (arg->mode == DRM_CREATE_DRI1) {
+	if (arg && arg->mode == DRM_CREATE_DRI1) {
 		struct nouveau_dri *nvdri = dri1->ddx_info;
 		enum pipe_format format;
 
diff --git a/src/gallium/winsys/drm/nouveau/xorg/Makefile b/src/gallium/winsys/drm/nouveau/xorg/Makefile
new file mode 100644
index 0000000000..f0d3b337e8
--- /dev/null
+++ b/src/gallium/winsys/drm/nouveau/xorg/Makefile
@@ -0,0 +1,61 @@
+TARGET     = modesetting_drv.so
+CFILES     = $(wildcard ./*.c)
+OBJECTS    = $(patsubst ./%.c,./%.o,$(CFILES))
+TOP        = ../../../../../..
+
+include $(TOP)/configs/current
+
+INCLUDES = \
+	$(shell pkg-config --cflags-only-I pixman-1 xorg-server libdrm xproto) \
+	-I../gem \
+	-I$(TOP)/src/gallium/include \
+	-I$(TOP)/src/gallium/drivers \
+	-I$(TOP)/src/gallium/auxiliary \
+	-I$(TOP)/src/mesa \
+	-I$(TOP)/include \
+	-I$(TOP)/src/egl/main
+
+LIBS = \
+	$(TOP)/src/gallium/state_trackers/xorg/libxorgtracker.a \
+	$(TOP)/src/gallium/winsys/drm/nouveau/drm/libnouveaudrm.a \
+	$(TOP)/src/gallium/drivers/nv04/libnv04.a \
+	$(TOP)/src/gallium/drivers/nv10/libnv10.a \
+	$(TOP)/src/gallium/drivers/nv20/libnv20.a \
+	$(TOP)/src/gallium/drivers/nv30/libnv30.a \
+	$(TOP)/src/gallium/drivers/nv40/libnv40.a \
+	$(TOP)/src/gallium/drivers/nv50/libnv50.a \
+	$(TOP)/src/gallium/drivers/nouveau/libnouveau.a \
+	$(GALLIUM_AUXILIARIES)
+
+DRIVER_DEFINES = \
+	-DHAVE_CONFIG_H
+
+
+#############################################
+
+
+
+all default: $(TARGET)
+
+$(TARGET): $(OBJECTS) Makefile $(TOP)/src/gallium/state_trackers/xorg/libxorgtracker.a $(LIBS)
+	$(TOP)/bin/mklib -noprefix -o $@ \
+	$(OBJECTS) $(LIBS) $(shell pkg-config --libs libdrm) -ldrm_nouveau
+
+clean:
+	rm -rf $(OBJECTS) $(TARGET)
+
+install:
+	$(INSTALL) -d $(DESTDIR)/$(XORG_DRIVER_INSTALL_DIR)
+	$(MINSTALL) -m 755 $(TARGET) $(DESTDIR)/$(XORG_DRIVER_INSTALL_DIR)
+
+
+##############################################
+
+
+.c.o:
+	$(CC) -c $(CFLAGS) $(INCLUDES) $(DRIVER_DEFINES) $< -o $@
+
+
+##############################################
+
+.PHONY	= all clean install
diff --git a/src/gallium/winsys/drm/nouveau/xorg/nouveau_xorg.c b/src/gallium/winsys/drm/nouveau/xorg/nouveau_xorg.c
new file mode 100644
index 0000000000..a669b3080a
--- /dev/null
+++ b/src/gallium/winsys/drm/nouveau/xorg/nouveau_xorg.c
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
+ *
+ *
+ * Author: Alan Hourihane <alanh@tungstengraphics.com>
+ * Author: Jakob Bornecrantz <wallbraker@gmail.com>
+ *
+ */
+
+#include "../../../../state_trackers/xorg/xorg_winsys.h"
+
+static void nouveau_xorg_identify(int flags);
+static Bool nouveau_xorg_pci_probe(DriverPtr driver, int entity_num,
+				   struct pci_device *device,
+				   intptr_t match_data);
+
+static const struct pci_id_match nouveau_xorg_device_match[] = {
+    { 0x10de, PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY,
+      0x00030000, 0x00ffffff, 0 },
+    { 0x12d2, PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY,
+      0x00030000, 0x00ffffff, 0 },
+    {0, 0, 0},
+};
+
+static SymTabRec nouveau_xorg_chipsets[] = {
+    {PCI_MATCH_ANY, "NVIDIA Graphics Device"},
+    {-1, NULL}
+};
+
+static PciChipsets nouveau_xorg_pci_devices[] = {
+    {PCI_MATCH_ANY, PCI_MATCH_ANY, NULL},
+    {-1, -1, NULL}
+};
+
+static XF86ModuleVersionInfo nouveau_xorg_version = {
+    "modesetting",
+    MODULEVENDORSTRING,
+    MODINFOSTRING1,
+    MODINFOSTRING2,
+    XORG_VERSION_CURRENT,
+    0, 1, 0, /* major, minor, patch */
+    ABI_CLASS_VIDEODRV,
+    ABI_VIDEODRV_VERSION,
+    MOD_CLASS_VIDEODRV,
+    {0, 0, 0, 0}
+};
+
+/*
+ * Xorg driver exported structures
+ */
+
+_X_EXPORT DriverRec modesetting = {
+    1,
+    "modesetting",
+    nouveau_xorg_identify,
+    NULL,
+    xorg_tracker_available_options,
+    NULL,
+    0,
+    NULL,
+    nouveau_xorg_device_match,
+    nouveau_xorg_pci_probe
+};
+
+static MODULESETUPPROTO(nouveau_xorg_setup);
+
+_X_EXPORT XF86ModuleData modesettingModuleData = {
+    &nouveau_xorg_version,
+    nouveau_xorg_setup,
+    NULL
+};
+
+/*
+ * Xorg driver functions
+ */
+
+static pointer
+nouveau_xorg_setup(pointer module, pointer opts, int *errmaj, int *errmin)
+{
+    static Bool setupDone = 0;
+
+    /* This module should be loaded only once, but check to be sure.
+     */
+    if (!setupDone) {
+	setupDone = 1;
+	xf86AddDriver(&modesetting, module, HaveDriverFuncs);
+
+	/*
+	 * The return value must be non-NULL on success even though there
+	 * is no TearDownProc.
+	 */
+	return (pointer) 1;
+    } else {
+	if (errmaj)
+	    *errmaj = LDR_ONCEONLY;
+	return NULL;
+    }
+}
+
+static void
+nouveau_xorg_identify(int flags)
+{
+    xf86PrintChipsets("modesetting", "Driver for Modesetting Kernel Drivers",
+		      nouveau_xorg_chipsets);
+}
+
+static Bool
+nouveau_xorg_pci_probe(DriverPtr driver,
+	  int entity_num, struct pci_device *device, intptr_t match_data)
+{
+    ScrnInfoPtr scrn = NULL;
+    EntityInfoPtr entity;
+
+    scrn = xf86ConfigPciEntity(scrn, 0, entity_num, nouveau_xorg_pci_devices,
+			       NULL, NULL, NULL, NULL, NULL);
+    if (scrn != NULL) {
+	scrn->driverVersion = 1;
+	scrn->driverName = "i915";
+	scrn->name = "modesetting";
+	scrn->Probe = NULL;
+
+	entity = xf86GetEntityInfo(entity_num);
+
+	/* Use all the functions from the xorg tracker */
+	xorg_tracker_set_functions(scrn);
+    }
+    return scrn != NULL;
+}
diff --git a/src/gallium/winsys/drm/radeon/core/radeon_buffer.c b/src/gallium/winsys/drm/radeon/core/radeon_buffer.c
index 07551e7cd1..7bf23cba23 100644
--- a/src/gallium/winsys/drm/radeon/core/radeon_buffer.c
+++ b/src/gallium/winsys/drm/radeon/core/radeon_buffer.c
@@ -32,6 +32,8 @@
 
 #include "radeon_buffer.h"
 
+#include "radeon_bo_gem.h"
+
 static const char *radeon_get_name(struct pipe_winsys *ws)
 {
     return "Radeon/GEM+KMS";
@@ -99,6 +101,7 @@ static struct pipe_buffer *radeon_surface_buffer_create(struct pipe_winsys *ws,
                                                         unsigned height,
                                                         enum pipe_format format,
                                                         unsigned usage,
+                                                        unsigned tex_usage,
                                                         unsigned *stride)
 {
     struct pipe_format_block block;
@@ -134,8 +137,11 @@ static void *radeon_buffer_map(struct pipe_winsys *ws,
         (struct radeon_pipe_buffer*)buffer;
     int write = 0;
 
-    if (!(flags & PIPE_BUFFER_USAGE_DONTBLOCK)) {
-        radeon_bo_wait(radeon_buffer->bo);
+    if (flags & PIPE_BUFFER_USAGE_DONTBLOCK) {
+        uint32_t domain;
+
+        if (radeon_bo_is_busy(radeon_buffer->bo, &domain))
+            return NULL;
     }
     if (flags & PIPE_BUFFER_USAGE_CPU_WRITE) {
         write = 1;
@@ -187,7 +193,6 @@ static void radeon_flush_frontbuffer(struct pipe_winsys *pipe_winsys,
 struct radeon_winsys* radeon_pipe_winsys(int fd)
 {
     struct radeon_winsys* radeon_ws;
-    struct radeon_bo_manager* bom;
 
     radeon_ws = CALLOC_STRUCT(radeon_winsys);
     if (radeon_ws == NULL) {
diff --git a/src/gallium/winsys/drm/radeon/core/radeon_drm.c b/src/gallium/winsys/drm/radeon/core/radeon_drm.c
index 47376a0f07..a4011db0b8 100644
--- a/src/gallium/winsys/drm/radeon/core/radeon_drm.c
+++ b/src/gallium/winsys/drm/radeon/core/radeon_drm.c
@@ -98,7 +98,7 @@ struct pipe_buffer* radeon_buffer_from_handle(struct drm_api* api,
     return &radeon_buffer->base;
 }
 
-struct pipe_texture*
+static struct pipe_texture*
 radeon_texture_from_shared_handle(struct drm_api *api,
                                   struct pipe_screen *screen,
                                   struct pipe_texture *templ,
@@ -116,20 +116,22 @@ radeon_texture_from_shared_handle(struct drm_api *api,
     return screen->texture_blanket(screen, templ, &stride, buffer);
 }
 
-boolean radeon_shared_handle_from_texture(struct drm_api *api,
-                                          struct pipe_screen *screen,
-                                          struct pipe_texture *texture,
-                                          unsigned *stride,
-                                          unsigned *handle)
+static boolean radeon_shared_handle_from_texture(struct drm_api *api,
+                                                 struct pipe_screen *screen,
+                                                 struct pipe_texture *texture,
+                                                 unsigned *stride,
+                                                 unsigned *handle)
 {
     int retval, fd;
     struct drm_gem_flink flink;
     struct radeon_pipe_buffer* radeon_buffer;
-    struct pipe_buffer* buffer = &radeon_buffer->base;
-    if (!radeon_buffer_from_texture(api, texture, buffer, stride)) {
+    struct pipe_buffer *buffer;
+
+    if (!radeon_buffer_from_texture(api, texture, &buffer, stride)) {
         return FALSE;
     }
 
+    radeon_buffer = (struct radeon_pipe_buffer*)buffer;
     if (!radeon_buffer->flinked) {
         fd = ((struct radeon_winsys*)screen->winsys)->priv->fd;
 
@@ -150,11 +152,11 @@ boolean radeon_shared_handle_from_texture(struct drm_api *api,
     return TRUE;
 }
 
-boolean radeon_local_handle_from_texture(struct drm_api *api,
-                                         struct pipe_screen *screen,
-                                         struct pipe_texture *texture,
-                                         unsigned *stride,
-                                         unsigned *handle)
+static boolean radeon_local_handle_from_texture(struct drm_api *api,
+                                                struct pipe_screen *screen,
+                                                struct pipe_texture *texture,
+                                                unsigned *stride,
+                                                unsigned *handle)
 {
     struct pipe_buffer *buffer;
     if (!radeon_buffer_from_texture(api, texture, &buffer, stride)) {
diff --git a/src/gallium/winsys/drm/radeon/core/radeon_r300.c b/src/gallium/winsys/drm/radeon/core/radeon_r300.c
index d723876221..d2d84f1a8f 100644
--- a/src/gallium/winsys/drm/radeon/core/radeon_r300.c
+++ b/src/gallium/winsys/drm/radeon/core/radeon_r300.c
@@ -137,7 +137,7 @@ static void do_ioctls(struct r300_winsys* winsys, int fd)
     int target = 0;
     int retval;
 
-    info.value = &target;
+    info.value = (unsigned long)&target;
 
     /* First, get the number of pixel pipes */
     info.request = RADEON_INFO_NUM_GB_PIPES;
diff --git a/src/gallium/winsys/g3dvl/xsp_winsys.c b/src/gallium/winsys/g3dvl/xsp_winsys.c
index 698c2856a4..37d60ce540 100644
--- a/src/gallium/winsys/g3dvl/xsp_winsys.c
+++ b/src/gallium/winsys/g3dvl/xsp_winsys.c
@@ -105,6 +105,7 @@ static struct pipe_buffer* xsp_surface_buffer_create
 	unsigned height,
 	enum pipe_format format,
 	unsigned usage,
+	unsigned tex_usage,
 	unsigned *stride
 )
 {
diff --git a/src/gallium/winsys/gdi/SConscript b/src/gallium/winsys/gdi/SConscript
index 86eb9ef55e..f5e6d36d89 100644
--- a/src/gallium/winsys/gdi/SConscript
+++ b/src/gallium/winsys/gdi/SConscript
@@ -5,35 +5,39 @@ Import('*')
 
 if env['platform'] == 'windows':
 
-	env = env.Clone()
+    env = env.Clone()
 
-	env.Append(CPPPATH = [
-		'#src/gallium/state_trackers/wgl',
-	])
+    env.Append(CPPPATH = [
+        '#src/gallium/state_trackers/wgl',
+    ])
 
-	env.Append(LIBS = [
-		'gdi32',
-		'user32',
-		'kernel32',
-		'ws2_32',
-	])
+    env.Append(LIBS = [
+        'gdi32',
+        'user32',
+        'kernel32',
+        'ws2_32',
+    ])
 
-	sources = [
-		'gdi_softpipe_winsys.c',
-	]
-	
-	if env['gcc']:
-		sources += ['#src/gallium/state_trackers/wgl/opengl32.mingw.def']
-	else:
-		sources += ['#src/gallium/state_trackers/wgl/opengl32.def']
-		
-	drivers = [
-		trace,
-		softpipe,
-	]
+    if 'llvmpipe' in env['drivers']:
+        sources = ['gdi_llvmpipe_winsys.c']
+        drivers = [llvmpipe]
+        env.Tool('llvm')
+    elif 'softpipe' in env['drivers']:
+        sources = ['gdi_softpipe_winsys.c']
+        drivers = [softpipe]
+    else:
+        print 'warning: softpipe or llvmpipe not selected, gdi winsys disabled'
+        Return()
+    
+    if env['gcc']:
+        sources += ['#src/gallium/state_trackers/wgl/opengl32.mingw.def']
+    else:
+        sources += ['#src/gallium/state_trackers/wgl/opengl32.def']
+        
+    drivers += [trace]
 
-	env.SharedLibrary(
-		target ='opengl32',
-		source = sources,
-		LIBS = wgl + glapi + mesa + drivers + auxiliaries + env['LIBS'],
-	)
+    env.SharedLibrary(
+        target ='opengl32',
+        source = sources,
+        LIBS = wgl + glapi + mesa + drivers + auxiliaries + env['LIBS'],
+    )
diff --git a/src/gallium/winsys/gdi/gdi_llvmpipe_winsys.c b/src/gallium/winsys/gdi/gdi_llvmpipe_winsys.c
new file mode 100644
index 0000000000..c0c33b45d5
--- /dev/null
+++ b/src/gallium/winsys/gdi/gdi_llvmpipe_winsys.c
@@ -0,0 +1,284 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS 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.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * LLVMpipe support.
+ *
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+
+
+#include <windows.h>
+
+#include "pipe/p_format.h"
+#include "pipe/p_context.h"
+#include "pipe/p_inlines.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+#include "llvmpipe/lp_winsys.h"
+#include "llvmpipe/lp_texture.h"
+#include "shared/stw_winsys.h"
+
+
+struct gdi_llvmpipe_displaytarget
+{
+   enum pipe_format format;
+   struct pipe_format_block block;
+   unsigned width;
+   unsigned height;
+   unsigned stride;
+
+   unsigned size;
+
+   void *data;
+
+   BITMAPINFO bmi;
+};
+
+
+/** Cast wrapper */
+static INLINE struct gdi_llvmpipe_displaytarget *
+gdi_llvmpipe_displaytarget( struct llvmpipe_displaytarget *buf )
+{
+   return (struct gdi_llvmpipe_displaytarget *)buf;
+}
+
+
+static boolean
+gdi_llvmpipe_is_displaytarget_format_supported( struct llvmpipe_winsys *ws,
+                                                enum pipe_format format )
+{
+   switch(format) {
+   case PIPE_FORMAT_X8R8G8B8_UNORM:
+   case PIPE_FORMAT_A8R8G8B8_UNORM:
+      return TRUE;
+
+   /* TODO: Support other formats possible with BMPs, as described in 
+    * http://msdn.microsoft.com/en-us/library/dd183376(VS.85).aspx */
+      
+   default:
+      return FALSE;
+   }
+}
+
+
+static void *
+gdi_llvmpipe_displaytarget_map(struct llvmpipe_winsys *ws,
+                               struct llvmpipe_displaytarget *dt,
+                               unsigned flags )
+{
+   struct gdi_llvmpipe_displaytarget *gdt = gdi_llvmpipe_displaytarget(dt);
+
+   return gdt->data;
+}
+
+
+static void
+gdi_llvmpipe_displaytarget_unmap(struct llvmpipe_winsys *ws,
+                                 struct llvmpipe_displaytarget *dt )
+{
+
+}
+
+
+static void
+gdi_llvmpipe_displaytarget_destroy(struct llvmpipe_winsys *winsys,
+                                   struct llvmpipe_displaytarget *dt)
+{
+   struct gdi_llvmpipe_displaytarget *gdt = gdi_llvmpipe_displaytarget(dt);
+
+   align_free(gdt->data);
+   FREE(gdt);
+}
+
+
+/**
+ * Round n up to next multiple.
+ */
+static INLINE unsigned
+round_up(unsigned n, unsigned multiple)
+{
+   return (n + multiple - 1) & ~(multiple - 1);
+}
+
+
+static struct llvmpipe_displaytarget *
+gdi_llvmpipe_displaytarget_create(struct llvmpipe_winsys *winsys,
+                                  enum pipe_format format,
+                                  unsigned width, unsigned height,
+                                  unsigned alignment,
+                                  unsigned *stride)
+{
+   struct gdi_llvmpipe_displaytarget *gdt;
+   unsigned cpp;
+   unsigned bpp;
+   
+   gdt = CALLOC_STRUCT(gdi_llvmpipe_displaytarget);
+   if(!gdt)
+      goto no_gdt;
+
+   gdt->format = format;
+   gdt->width = width;
+   gdt->height = height;
+
+   bpp = pf_get_bits(format);
+   cpp = pf_get_size(format);
+   
+   gdt->stride = round_up(width * cpp, alignment);
+   gdt->size = gdt->stride * height;
+   
+   gdt->data = align_malloc(gdt->size, alignment);
+   if(!gdt->data)
+      goto no_data;
+
+   gdt->bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+   gdt->bmi.bmiHeader.biWidth = gdt->stride / cpp;
+   gdt->bmi.bmiHeader.biHeight= -(long)height;
+   gdt->bmi.bmiHeader.biPlanes = 1;
+   gdt->bmi.bmiHeader.biBitCount = bpp;
+   gdt->bmi.bmiHeader.biCompression = BI_RGB;
+   gdt->bmi.bmiHeader.biSizeImage = 0;
+   gdt->bmi.bmiHeader.biXPelsPerMeter = 0;
+   gdt->bmi.bmiHeader.biYPelsPerMeter = 0;
+   gdt->bmi.bmiHeader.biClrUsed = 0;
+   gdt->bmi.bmiHeader.biClrImportant = 0;
+
+   *stride = gdt->stride;
+   return (struct llvmpipe_displaytarget *)gdt;
+
+no_data:
+   FREE(gdt);
+no_gdt:
+   return NULL;
+}
+
+
+static void
+gdi_llvmpipe_displaytarget_display(struct llvmpipe_winsys *winsys, 
+                                   struct llvmpipe_displaytarget *dt,
+                                   void *context_private)
+{
+   assert(0);
+}
+
+
+static void
+gdi_llvmpipe_destroy(struct llvmpipe_winsys *winsys)
+{
+   FREE(winsys);
+}
+
+
+static struct pipe_screen *
+gdi_llvmpipe_screen_create(void)
+{
+   static struct llvmpipe_winsys *winsys;
+   struct pipe_screen *screen;
+
+   winsys = CALLOC_STRUCT(llvmpipe_winsys);
+   if(!winsys)
+      goto no_winsys;
+
+   winsys->destroy = gdi_llvmpipe_destroy;
+   winsys->is_displaytarget_format_supported = gdi_llvmpipe_is_displaytarget_format_supported;
+   winsys->displaytarget_create = gdi_llvmpipe_displaytarget_create;
+   winsys->displaytarget_map = gdi_llvmpipe_displaytarget_map;
+   winsys->displaytarget_unmap = gdi_llvmpipe_displaytarget_unmap;
+   winsys->displaytarget_display = gdi_llvmpipe_displaytarget_display;
+   winsys->displaytarget_destroy = gdi_llvmpipe_displaytarget_destroy;
+
+   screen = llvmpipe_create_screen(winsys);
+   if(!screen)
+      goto no_screen;
+
+   return screen;
+   
+no_screen:
+   FREE(winsys);
+no_winsys:
+   return NULL;
+}
+
+
+static struct pipe_context *
+gdi_llvmpipe_context_create(struct pipe_screen *screen)
+{
+   return llvmpipe_create(screen);
+}
+
+
+static void
+gdi_llvmpipe_flush_frontbuffer(struct pipe_screen *screen,
+                               struct pipe_surface *surface,
+                               HDC hDC)
+{
+    struct llvmpipe_texture *texture;
+    struct gdi_llvmpipe_displaytarget *gdt;
+
+    texture = llvmpipe_texture(surface->texture);
+    gdt = gdi_llvmpipe_displaytarget(texture->dt);
+
+    StretchDIBits(hDC,
+                  0, 0, gdt->width, gdt->height,
+                  0, 0, gdt->width, gdt->height,
+                  gdt->data, &gdt->bmi, 0, SRCCOPY);
+}
+
+
+static const struct stw_winsys stw_winsys = {
+   &gdi_llvmpipe_screen_create,
+   &gdi_llvmpipe_context_create,
+   &gdi_llvmpipe_flush_frontbuffer
+};
+
+
+BOOL WINAPI
+DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
+{
+   switch (fdwReason) {
+   case DLL_PROCESS_ATTACH:
+      if (!stw_init(&stw_winsys)) {
+         return FALSE;
+      }
+      return stw_init_thread();
+
+   case DLL_THREAD_ATTACH:
+      return stw_init_thread();
+
+   case DLL_THREAD_DETACH:
+      stw_cleanup_thread();
+      break;
+
+   case DLL_PROCESS_DETACH:
+      stw_cleanup_thread();
+      stw_cleanup();
+      break;
+   }
+   return TRUE;
+}
diff --git a/src/gallium/winsys/gdi/gdi_softpipe_winsys.c b/src/gallium/winsys/gdi/gdi_softpipe_winsys.c
index 33826524d7..66120a6a98 100644
--- a/src/gallium/winsys/gdi/gdi_softpipe_winsys.c
+++ b/src/gallium/winsys/gdi/gdi_softpipe_winsys.c
@@ -166,6 +166,7 @@ gdi_softpipe_surface_buffer_create(struct pipe_winsys *winsys,
                                    unsigned width, unsigned height,
                                    enum pipe_format format,
                                    unsigned usage,
+                                   unsigned tex_usage,
                                    unsigned *stride)
 {
    const unsigned alignment = 64;
diff --git a/src/gallium/winsys/xlib/Makefile b/src/gallium/winsys/xlib/Makefile
index 522f6dc5ae..3a1945d92c 100644
--- a/src/gallium/winsys/xlib/Makefile
+++ b/src/gallium/winsys/xlib/Makefile
@@ -34,6 +34,7 @@ XLIB_WINSYS_SOURCES = \
 	xlib_brw_aub.c \
 	xlib_brw_context.c \
 	xlib_brw_screen.c \
+	xlib_llvmpipe.c \
 	xlib_softpipe.c \
 	xlib_trace.c 
 
diff --git a/src/gallium/winsys/xlib/xlib_llvmpipe.c b/src/gallium/winsys/xlib/xlib_llvmpipe.c
index bc876591c0..3dd15e099b 100644
--- a/src/gallium/winsys/xlib/xlib_llvmpipe.c
+++ b/src/gallium/winsys/xlib/xlib_llvmpipe.c
@@ -33,6 +33,8 @@
  */
 
 
+#if defined(GALLIUM_LLVMPIPE)
+
 #include "xm_api.h"
 
 #undef ASSERT
@@ -459,3 +461,4 @@ struct xm_driver xlib_llvmpipe_driver =
 
 
 
+#endif /* GALLIUM_LLVMPIPE */
diff --git a/src/glx/x11/glx_pbuffer.c b/src/glx/x11/glx_pbuffer.c
index 88a17df6f8..01569213f2 100644
--- a/src/glx/x11/glx_pbuffer.c
+++ b/src/glx/x11/glx_pbuffer.c
@@ -41,6 +41,23 @@
 
 
 /**
+ * Emit a warning when clients use GLX 1.3 functions on pre-1.3 systems.
+ */
+static void
+warn_GLX_1_3(Display *dpy, const char *function_name)
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+
+   if (priv->minorVersion < 3) {
+      fprintf(stderr, 
+	      "WARNING: Application calling GLX 1.3 function \"%s\" "
+	      "when GLX 1.3 is not supported!  This is an application bug!\n",
+	      function_name);
+   }
+}
+
+
+/**
  * Change a drawable's attribute.
  *
  * This function is used to implement \c glXSelectEvent and
@@ -559,6 +576,8 @@ glXCreatePbuffer(Display * dpy, GLXFBConfig config, const int *attrib_list)
    width = 0;
    height = 0;
 
+   warn_GLX_1_3(dpy, __func__);
+
    for (i = 0; attrib_list[i * 2]; i++) {
       switch (attrib_list[i * 2]) {
       case GLX_PBUFFER_WIDTH:
@@ -592,6 +611,7 @@ PUBLIC void
 glXQueryDrawable(Display * dpy, GLXDrawable drawable,
                  int attribute, unsigned int *value)
 {
+   warn_GLX_1_3(dpy, __func__);
    GetDrawableAttribute(dpy, drawable, attribute, value);
 }
 
@@ -645,6 +665,8 @@ PUBLIC GLXPixmap
 glXCreatePixmap(Display * dpy, GLXFBConfig config, Pixmap pixmap,
                 const int *attrib_list)
 {
+   warn_GLX_1_3(dpy, __func__);
+
    return CreateDrawable(dpy, (__GLcontextModes *) config,
                          (Drawable) pixmap, attrib_list, X_GLXCreatePixmap);
 }
@@ -654,6 +676,8 @@ PUBLIC GLXWindow
 glXCreateWindow(Display * dpy, GLXFBConfig config, Window win,
                 const int *attrib_list)
 {
+   warn_GLX_1_3(dpy, __func__);
+
    return CreateDrawable(dpy, (__GLcontextModes *) config,
                          (Drawable) win, attrib_list, X_GLXCreateWindow);
 }
@@ -662,6 +686,8 @@ glXCreateWindow(Display * dpy, GLXFBConfig config, Window win,
 PUBLIC void
 glXDestroyPixmap(Display * dpy, GLXPixmap pixmap)
 {
+   warn_GLX_1_3(dpy, __func__);
+
    DestroyDrawable(dpy, (GLXDrawable) pixmap, X_GLXDestroyPixmap);
 }
 
@@ -669,6 +695,8 @@ glXDestroyPixmap(Display * dpy, GLXPixmap pixmap)
 PUBLIC void
 glXDestroyWindow(Display * dpy, GLXWindow win)
 {
+   warn_GLX_1_3(dpy, __func__);
+
    DestroyDrawable(dpy, (GLXDrawable) win, X_GLXDestroyWindow);
 }
 
diff --git a/src/glx/x11/glxhash.c b/src/glx/x11/glxhash.c
index 74cd4f344d..7d28ada49c 100644
--- a/src/glx/x11/glxhash.c
+++ b/src/glx/x11/glxhash.c
@@ -87,9 +87,13 @@
 
 #define HASH_ALLOC malloc
 #define HASH_FREE  free
-#define HASH_RANDOM_DECL
-#define HASH_RANDOM_INIT(seed)  srandom(seed)
-#define HASH_RANDOM             random()
+#define HASH_RANDOM_DECL	struct random_data rd; int32_t rv; char rs[256]
+#define HASH_RANDOM_INIT(seed)					\
+   do {								\
+      (void) memset(&rd, 0, sizeof(rd));			\
+      (void) initstate_r(seed, rs, sizeof(rs), &rd);		\
+   } while(0)
+#define HASH_RANDOM             ((void) random_r(&rd, &rv), rv)
 #define HASH_RANDOM_DESTROY
 
 typedef struct __glxHashBucket
diff --git a/src/mesa/drivers/common/driverfuncs.c b/src/mesa/drivers/common/driverfuncs.c
index a9f3c8e727..f09106b77c 100644
--- a/src/mesa/drivers/common/driverfuncs.c
+++ b/src/mesa/drivers/common/driverfuncs.c
@@ -56,6 +56,7 @@
 #include "swrast/swrast.h"
 
 #include "driverfuncs.h"
+#include "meta.h"
 
 
 
@@ -100,11 +101,11 @@ _mesa_init_driver_functions(struct dd_function_table *driver)
    driver->TexSubImage2D = _mesa_store_texsubimage2d;
    driver->TexSubImage3D = _mesa_store_texsubimage3d;
    driver->GetTexImage = _mesa_get_teximage;
-   driver->CopyTexImage1D = _swrast_copy_teximage1d;
-   driver->CopyTexImage2D = _swrast_copy_teximage2d;
-   driver->CopyTexSubImage1D = _swrast_copy_texsubimage1d;
-   driver->CopyTexSubImage2D = _swrast_copy_texsubimage2d;
-   driver->CopyTexSubImage3D = _swrast_copy_texsubimage3d;
+   driver->CopyTexImage1D = _mesa_meta_CopyTexImage1D;
+   driver->CopyTexImage2D = _mesa_meta_CopyTexImage2D;
+   driver->CopyTexSubImage1D = _mesa_meta_CopyTexSubImage1D;
+   driver->CopyTexSubImage2D = _mesa_meta_CopyTexSubImage2D;
+   driver->CopyTexSubImage3D = _mesa_meta_CopyTexSubImage3D;
    driver->GenerateMipmap = _mesa_generate_mipmap;
    driver->TestProxyTexImage = _mesa_test_proxy_teximage;
    driver->CompressedTexImage1D = _mesa_store_compressed_teximage1d;
@@ -129,10 +130,10 @@ _mesa_init_driver_functions(struct dd_function_table *driver)
    driver->UpdateTexturePalette = NULL;
 
    /* imaging */
-   driver->CopyColorTable = _swrast_CopyColorTable;
-   driver->CopyColorSubTable = _swrast_CopyColorSubTable;
-   driver->CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
-   driver->CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
+   driver->CopyColorTable = _mesa_meta_CopyColorTable;
+   driver->CopyColorSubTable = _mesa_meta_CopyColorSubTable;
+   driver->CopyConvolutionFilter1D = _mesa_meta_CopyConvolutionFilter1D;
+   driver->CopyConvolutionFilter2D = _mesa_meta_CopyConvolutionFilter2D;
 
    /* Vertex/fragment programs */
    driver->BindProgram = NULL;
diff --git a/src/mesa/drivers/common/meta.c b/src/mesa/drivers/common/meta.c
index 965fb8697e..532b2c9263 100644
--- a/src/mesa/drivers/common/meta.c
+++ b/src/mesa/drivers/common/meta.c
@@ -37,15 +37,21 @@
 #include "main/arrayobj.h"
 #include "main/blend.h"
 #include "main/bufferobj.h"
+#include "main/buffers.h"
+#include "main/colortab.h"
+#include "main/convolve.h"
 #include "main/depth.h"
 #include "main/enable.h"
+#include "main/fbobject.h"
 #include "main/image.h"
 #include "main/macros.h"
 #include "main/matrix.h"
+#include "main/mipmap.h"
 #include "main/polygon.h"
 #include "main/readpix.h"
 #include "main/scissor.h"
 #include "main/shaders.h"
+#include "main/state.h"
 #include "main/stencil.h"
 #include "main/texobj.h"
 #include "main/texenv.h"
@@ -60,6 +66,33 @@
 #include "drivers/common/meta.h"
 
 
+/** Return offset in bytes of the field within a vertex struct */
+#define OFFSET(FIELD) ((void *) offsetof(struct vertex, FIELD))
+
+
+/**
+ * Flags passed to _mesa_meta_begin().
+ */
+/*@{*/
+#define META_ALL              ~0x0
+#define META_ALPHA_TEST        0x1
+#define META_BLEND             0x2  /**< includes logicop */
+#define META_COLOR_MASK        0x4
+#define META_DEPTH_TEST        0x8
+#define META_FOG              0x10
+#define META_PIXEL_STORE      0x20
+#define META_PIXEL_TRANSFER   0x40
+#define META_RASTERIZATION    0x80
+#define META_SCISSOR         0x100
+#define META_SHADER          0x200
+#define META_STENCIL_TEST    0x400
+#define META_TRANSFORM       0x800 /**< modelview, projection, clip planes */
+#define META_TEXTURE        0x1000
+#define META_VERTEX         0x2000
+#define META_VIEWPORT       0x4000
+/*@}*/
+
+
 /**
  * State which we may save/restore across meta ops.
  * XXX this may be incomplete...
@@ -87,6 +120,17 @@ struct save_state
    /** META_PIXEL_STORE */
    struct gl_pixelstore_attrib Pack, Unpack;
 
+   /** META_PIXEL_TRANSFER */
+   GLfloat RedBias, RedScale;
+   GLfloat GreenBias, GreenScale;
+   GLfloat BlueBias, BlueScale;
+   GLfloat AlphaBias, AlphaScale;
+   GLfloat DepthBias, DepthScale;
+   GLboolean MapColorFlag;
+   GLboolean Convolution1DEnabled;
+   GLboolean Convolution2DEnabled;
+   GLboolean Separable2DEnabled;
+
    /** META_RASTERIZATION */
    GLenum FrontPolygonMode, BackPolygonMode;
    GLboolean PolygonOffset;
@@ -138,6 +182,24 @@ struct save_state
 
 
 /**
+ * Temporary texture used for glBlitFramebuffer, glDrawPixels, etc.
+ * This is currently shared by all the meta ops.  But we could create a
+ * separate one for each of glDrawPixel, glBlitFramebuffer, glCopyPixels, etc.
+ */
+struct temp_texture
+{
+   GLuint TexObj;
+   GLenum Target;         /**< GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE */
+   GLsizei MinSize;       /**< Min texture size to allocate */
+   GLsizei MaxSize;       /**< Max possible texture size */
+   GLboolean NPOT;        /**< Non-power of two size OK? */
+   GLsizei Width, Height; /**< Current texture size */
+   GLenum IntFormat;
+   GLfloat Sright, Ttop;  /**< right, top texcoords */
+};
+
+
+/**
  * State for glBlitFramebufer()
  */
 struct blit_state
@@ -182,19 +244,24 @@ struct drawpix_state
 
 
 /**
- * Temporary texture used for glBlitFramebuffer, glDrawPixels, etc.
- * This is currently shared by all the meta ops.  But we could create a
- * separate one for each of glDrawPixel, glBlitFramebuffer, glCopyPixels, etc.
+ * State for glBitmap()
  */
-struct temp_texture
+struct bitmap_state
 {
-   GLuint TexObj;
-   GLenum Target;         /**< GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE */
-   GLsizei MaxSize;       /**< Max possible texture size */
-   GLboolean NPOT;        /**< Non-power of two size OK? */
-   GLsizei Width, Height; /**< Current texture size */
-   GLenum IntFormat;
-   GLfloat Sright, Ttop;  /**< right, top texcoords */
+   GLuint ArrayObj;
+   GLuint VBO;
+   struct temp_texture Tex;  /**< separate texture from other meta ops */
+};
+
+
+/**
+ * State for _mesa_meta_generate_mipmap()
+ */
+struct gen_mipmap_state
+{
+   GLuint ArrayObj;
+   GLuint VBO;
+   GLuint FBO;
 };
 
 
@@ -207,15 +274,12 @@ struct gl_meta_state
 
    struct temp_texture TempTex;
 
-   struct blit_state Blit;    /**< For _mesa_meta_blit_framebuffer() */
-   struct clear_state Clear;  /**< For _mesa_meta_clear() */
-   struct copypix_state CopyPix;  /**< For _mesa_meta_copy_pixels() */
-   struct drawpix_state DrawPix;  /**< For _mesa_meta_draw_pixels() */
-
-   /* other possible meta-ops:
-    * glBitmap()
-    * glGenerateMipmap()
-    */
+   struct blit_state Blit;    /**< For _mesa_meta_BlitFramebuffer() */
+   struct clear_state Clear;  /**< For _mesa_meta_Clear() */
+   struct copypix_state CopyPix;  /**< For _mesa_meta_CopyPixels() */
+   struct drawpix_state DrawPix;  /**< For _mesa_meta_DrawPixels() */
+   struct bitmap_state Bitmap;    /**< For _mesa_meta_Bitmap() */
+   struct gen_mipmap_state Mipmap;    /**< For _mesa_meta_GenerateMipmap() */
 };
 
 
@@ -246,6 +310,7 @@ _mesa_meta_free(GLcontext *ctx)
        * still get freed by _mesa_free_context_data().
        */
 
+      /* the temporary texture */
       _mesa_DeleteTextures(1, &meta->TempTex.TexObj);
 
       /* glBlitFramebuffer */
@@ -266,6 +331,11 @@ _mesa_meta_free(GLcontext *ctx)
       _mesa_DeleteVertexArraysAPPLE(1, &meta->DrawPix.ArrayObj);
       _mesa_DeletePrograms(1, &meta->DrawPix.DepthFP);
       _mesa_DeletePrograms(1, &meta->DrawPix.StencilFP);
+
+      /* glBitmap */
+      _mesa_DeleteBuffersARB(1, & meta->Bitmap.VBO);
+      _mesa_DeleteVertexArraysAPPLE(1, &meta->Bitmap.ArrayObj);
+      _mesa_DeleteTextures(1, &meta->Bitmap.Tex.TexObj);
    }
 
    _mesa_free(ctx->Meta);
@@ -290,16 +360,16 @@ _mesa_meta_begin(GLcontext *ctx, GLbitfield state)
    if (state & META_ALPHA_TEST) {
       save->AlphaEnabled = ctx->Color.AlphaEnabled;
       if (ctx->Color.AlphaEnabled)
-         _mesa_Disable(GL_ALPHA_TEST);
+         _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_FALSE);
    }
 
    if (state & META_BLEND) {
       save->BlendEnabled = ctx->Color.BlendEnabled;
       if (ctx->Color.BlendEnabled)
-         _mesa_Disable(GL_BLEND);
+         _mesa_set_enable(ctx, GL_BLEND, GL_FALSE);
       save->ColorLogicOpEnabled = ctx->Color.ColorLogicOpEnabled;
       if (ctx->Color.ColorLogicOpEnabled)
-         _mesa_Disable(GL_COLOR_LOGIC_OP);
+         _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, GL_FALSE);
    }
 
    if (state & META_COLOR_MASK) {
@@ -314,7 +384,7 @@ _mesa_meta_begin(GLcontext *ctx, GLbitfield state)
    if (state & META_DEPTH_TEST) {
       save->Depth = ctx->Depth; /* struct copy */
       if (ctx->Depth.Test)
-         _mesa_Disable(GL_DEPTH_TEST);
+         _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_FALSE);
    }
 
    if (state & META_FOG) {
@@ -330,6 +400,35 @@ _mesa_meta_begin(GLcontext *ctx, GLbitfield state)
       ctx->Unpack = ctx->DefaultPacking;
    }
 
+   if (state & META_PIXEL_TRANSFER) {
+      save->RedScale = ctx->Pixel.RedScale;
+      save->RedBias = ctx->Pixel.RedBias;
+      save->GreenScale = ctx->Pixel.GreenScale;
+      save->GreenBias = ctx->Pixel.GreenBias;
+      save->BlueScale = ctx->Pixel.BlueScale;
+      save->BlueBias = ctx->Pixel.BlueBias;
+      save->AlphaScale = ctx->Pixel.AlphaScale;
+      save->AlphaBias = ctx->Pixel.AlphaBias;
+      save->MapColorFlag = ctx->Pixel.MapColorFlag;
+      save->Convolution1DEnabled = ctx->Pixel.Convolution1DEnabled;
+      save->Convolution2DEnabled = ctx->Pixel.Convolution2DEnabled;
+      save->Separable2DEnabled = ctx->Pixel.Separable2DEnabled;
+      ctx->Pixel.RedScale = 1.0F;
+      ctx->Pixel.RedBias = 0.0F;
+      ctx->Pixel.GreenScale = 1.0F;
+      ctx->Pixel.GreenBias = 0.0F;
+      ctx->Pixel.BlueScale = 1.0F;
+      ctx->Pixel.BlueBias = 0.0F;
+      ctx->Pixel.AlphaScale = 1.0F;
+      ctx->Pixel.AlphaBias = 0.0F;
+      ctx->Pixel.MapColorFlag = GL_FALSE;
+      ctx->Pixel.Convolution1DEnabled = GL_FALSE;
+      ctx->Pixel.Convolution2DEnabled = GL_FALSE;
+      ctx->Pixel.Separable2DEnabled = GL_FALSE;
+      /* XXX more state */
+      ctx->NewState |=_NEW_PIXEL;
+   }
+
    if (state & META_RASTERIZATION) {
       save->FrontPolygonMode = ctx->Polygon.FrontMode;
       save->BackPolygonMode = ctx->Polygon.BackMode;
@@ -371,7 +470,7 @@ _mesa_meta_begin(GLcontext *ctx, GLbitfield state)
    if (state & META_STENCIL_TEST) {
       save->Stencil = ctx->Stencil; /* struct copy */
       if (ctx->Stencil.Enabled)
-         _mesa_Disable(GL_STENCIL_TEST);
+         _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_FALSE);
       /* NOTE: other stencil state not reset */
    }
 
@@ -525,6 +624,23 @@ _mesa_meta_end(GLcontext *ctx)
       ctx->Unpack = save->Unpack;
    }
 
+   if (state & META_PIXEL_TRANSFER) {
+      ctx->Pixel.RedScale = save->RedScale;
+      ctx->Pixel.RedBias = save->RedBias;
+      ctx->Pixel.GreenScale = save->GreenScale;
+      ctx->Pixel.GreenBias = save->GreenBias;
+      ctx->Pixel.BlueScale = save->BlueScale;
+      ctx->Pixel.BlueBias = save->BlueBias;
+      ctx->Pixel.AlphaScale = save->AlphaScale;
+      ctx->Pixel.AlphaBias = save->AlphaBias;
+      ctx->Pixel.MapColorFlag = save->MapColorFlag;
+      ctx->Pixel.Convolution1DEnabled = save->Convolution1DEnabled;
+      ctx->Pixel.Convolution2DEnabled = save->Convolution2DEnabled;
+      ctx->Pixel.Separable2DEnabled = save->Separable2DEnabled;
+      /* XXX more state */
+      ctx->NewState |=_NEW_PIXEL;
+   }
+
    if (state & META_RASTERIZATION) {
       _mesa_PolygonMode(GL_FRONT, save->FrontPolygonMode);
       _mesa_PolygonMode(GL_BACK, save->BackPolygonMode);
@@ -656,7 +772,6 @@ _mesa_meta_end(GLcontext *ctx)
 
       _mesa_MatrixMode(save->MatrixMode);
 
-      save->ClipPlanesEnabled = ctx->Transform.ClipPlanesEnabled;
       if (save->ClipPlanesEnabled) {
          GLuint i;
          for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
@@ -692,15 +807,39 @@ _mesa_meta_end(GLcontext *ctx)
    if (save->Lighting) {
       _mesa_set_enable(ctx, GL_LIGHTING, GL_TRUE);
    }
-   if (save->Fog) {
-      _mesa_set_enable(ctx, GL_FOG, GL_TRUE);
+}
+
+
+/**
+ * One-time init for a temp_texture object.
+ * Choose tex target, compute max tex size, etc.
+ */
+static void
+init_temp_texture(GLcontext *ctx, struct temp_texture *tex)
+{
+   /* prefer texture rectangle */
+   if (ctx->Extensions.NV_texture_rectangle) {
+      tex->Target = GL_TEXTURE_RECTANGLE;
+      tex->MaxSize = ctx->Const.MaxTextureRectSize;
+      tex->NPOT = GL_TRUE;
+   }
+   else {
+      /* use 2D texture, NPOT if possible */
+      tex->Target = GL_TEXTURE_2D;
+      tex->MaxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
+      tex->NPOT = ctx->Extensions.ARB_texture_non_power_of_two;
    }
+   tex->MinSize = 16;  /* 16 x 16 at least */
+   assert(tex->MaxSize > 0);
+
+   _mesa_GenTextures(1, &tex->TexObj);
+   _mesa_BindTexture(tex->Target, tex->TexObj);
 }
 
 
 /**
- * Return pointer to temp_texture info.  This does some one-time init
- * if needed.
+ * Return pointer to temp_texture info for non-bitmap ops.
+ * This does some one-time init if needed.
  */
 static struct temp_texture *
 get_temp_texture(GLcontext *ctx)
@@ -708,24 +847,25 @@ get_temp_texture(GLcontext *ctx)
    struct temp_texture *tex = &ctx->Meta->TempTex;
 
    if (!tex->TexObj) {
-      /* do one-time init */
+      init_temp_texture(ctx, tex);
+   }
+
+   return tex;
+}
 
-      /* prefer texture rectangle */
-      if (ctx->Extensions.NV_texture_rectangle) {
-         tex->Target = GL_TEXTURE_RECTANGLE;
-         tex->MaxSize = ctx->Const.MaxTextureRectSize;
-         tex->NPOT = GL_TRUE;
-      }
-      else {
-         /* use 2D texture, NPOT if possible */
-         tex->Target = GL_TEXTURE_2D;
-         tex->MaxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-         tex->NPOT = ctx->Extensions.ARB_texture_non_power_of_two;
-      }
-      assert(tex->MaxSize > 0);
 
-      _mesa_GenTextures(1, &tex->TexObj);
-      _mesa_BindTexture(tex->Target, tex->TexObj);
+/**
+ * Return pointer to temp_texture info for _mesa_meta_bitmap().
+ * We use a separate texture for bitmaps to reduce texture
+ * allocation/deallocation.
+ */
+static struct temp_texture *
+get_bitmap_temp_texture(GLcontext *ctx)
+{
+   struct temp_texture *tex = &ctx->Meta->Bitmap.Tex;
+
+   if (!tex->TexObj) {
+      init_temp_texture(ctx, tex);
    }
 
    return tex;
@@ -747,6 +887,9 @@ alloc_texture(struct temp_texture *tex,
 {
    GLboolean newTex = GL_FALSE;
 
+   ASSERT(width <= tex->MaxSize);
+   ASSERT(height <= tex->MaxSize);
+
    if (width > tex->Width ||
        height > tex->Height ||
        intFormat != tex->IntFormat) {
@@ -754,13 +897,13 @@ alloc_texture(struct temp_texture *tex,
 
       if (tex->NPOT) {
          /* use non-power of two size */
-         tex->Width = width;
-         tex->Height = height;
+         tex->Width = MAX2(tex->MinSize, width);
+         tex->Height = MAX2(tex->MinSize, height);
       }
       else {
          /* find power of two size */
          GLsizei w, h;
-         w = h = 16;
+         w = h = tex->MinSize;
          while (w < width)
             w *= 2;
          while (h < height)
@@ -908,10 +1051,10 @@ init_blit_depth_pixels(GLcontext *ctx)
  * of texture mapping and polygon rendering.
  */
 void
-_mesa_meta_blit_framebuffer(GLcontext *ctx,
-                            GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                            GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                            GLbitfield mask, GLenum filter)
+_mesa_meta_BlitFramebuffer(GLcontext *ctx,
+                           GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+                           GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+                           GLbitfield mask, GLenum filter)
 {
    struct blit_state *blit = &ctx->Meta->Blit;
    struct temp_texture *tex = get_temp_texture(ctx);
@@ -922,7 +1065,10 @@ _mesa_meta_blit_framebuffer(GLcontext *ctx,
    const GLint srcH = abs(srcY1 - srcY0);
    const GLboolean srcFlipX = srcX1 < srcX0;
    const GLboolean srcFlipY = srcY1 < srcY0;
-   GLfloat verts[4][4]; /* four verts of X,Y,S,T */
+   struct vertex {
+      GLfloat x, y, s, t;
+   };
+   struct vertex verts[4];
    GLboolean newTex;
 
    if (srcW > maxTexSize || srcH > maxTexSize) {
@@ -961,10 +1107,8 @@ _mesa_meta_blit_framebuffer(GLcontext *ctx,
                           NULL, GL_DYNAMIC_DRAW_ARB);
 
       /* setup vertex arrays */
-      _mesa_VertexPointer(2, GL_FLOAT, sizeof(verts[0]),
-                          (void *) (0 * sizeof(GLfloat)));
-      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
-                            (void *) (2 * sizeof(GLfloat)));
+      _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
       _mesa_EnableClientState(GL_VERTEX_ARRAY);
       _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
    }
@@ -977,29 +1121,29 @@ _mesa_meta_blit_framebuffer(GLcontext *ctx,
 
    /* vertex positions/texcoords (after texture allocation!) */
    {
-      verts[0][0] = (GLfloat) dstX0;
-      verts[0][1] = (GLfloat) dstY0;
-      verts[1][0] = (GLfloat) dstX1;
-      verts[1][1] = (GLfloat) dstY0;
-      verts[2][0] = (GLfloat) dstX1;
-      verts[2][1] = (GLfloat) dstY1;
-      verts[3][0] = (GLfloat) dstX0;
-      verts[3][1] = (GLfloat) dstY1;
-
-      verts[0][2] = 0.0F;
-      verts[0][3] = 0.0F;
-      verts[1][2] = tex->Sright;
-      verts[1][3] = 0.0F;
-      verts[2][2] = tex->Sright;
-      verts[2][3] = tex->Ttop;
-      verts[3][2] = 0.0F;
-      verts[3][3] = tex->Ttop;
+      verts[0].x = (GLfloat) dstX0;
+      verts[0].y = (GLfloat) dstY0;
+      verts[1].x = (GLfloat) dstX1;
+      verts[1].y = (GLfloat) dstY0;
+      verts[2].x = (GLfloat) dstX1;
+      verts[2].y = (GLfloat) dstY1;
+      verts[3].x = (GLfloat) dstX0;
+      verts[3].y = (GLfloat) dstY1;
+
+      verts[0].s = 0.0F;
+      verts[0].t = 0.0F;
+      verts[1].s = tex->Sright;
+      verts[1].t = 0.0F;
+      verts[2].s = tex->Sright;
+      verts[2].t = tex->Ttop;
+      verts[3].s = 0.0F;
+      verts[3].t = tex->Ttop;
 
       /* upload new vertex data */
       _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
    }
 
-   _mesa_Enable(tex->Target);
+   _mesa_set_enable(ctx, tex->Target, GL_TRUE);
 
    if (mask & GL_COLOR_BUFFER_BIT) {
       setup_copypix_texture(tex, newTex, srcX, srcY, srcW, srcH,
@@ -1041,7 +1185,7 @@ _mesa_meta_blit_framebuffer(GLcontext *ctx,
       /* XXX can't easily do stencil */
    }
 
-   _mesa_Disable(tex->Target);
+   _mesa_set_enable(ctx, tex->Target, GL_FALSE);
 
    _mesa_meta_end(ctx);
 
@@ -1056,10 +1200,13 @@ _mesa_meta_blit_framebuffer(GLcontext *ctx,
  * Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.
  */
 void
-_mesa_meta_clear(GLcontext *ctx, GLbitfield buffers)
+_mesa_meta_Clear(GLcontext *ctx, GLbitfield buffers)
 {
    struct clear_state *clear = &ctx->Meta->Clear;
-   GLfloat verts[4][7]; /* four verts of X,Y,Z,R,G,B,A */
+   struct vertex {
+      GLfloat x, y, z, r, g, b, a;
+   };
+   struct vertex verts[4];
    /* save all state but scissor, pixel pack/unpack */
    GLbitfield metaSave = META_ALL - META_SCISSOR - META_PIXEL_STORE;
 
@@ -1084,10 +1231,8 @@ _mesa_meta_clear(GLcontext *ctx, GLbitfield buffers)
                           NULL, GL_DYNAMIC_DRAW_ARB);
 
       /* setup vertex arrays */
-      _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
-                          (void *) (0 * sizeof(GLfloat)));
-      _mesa_ColorPointer(4, GL_FLOAT, sizeof(verts[0]),
-                         (void *) (3 * sizeof(GLfloat)));
+      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+      _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));
       _mesa_EnableClientState(GL_VERTEX_ARRAY);
       _mesa_EnableClientState(GL_COLOR_ARRAY);
    }
@@ -1137,22 +1282,25 @@ _mesa_meta_clear(GLcontext *ctx, GLbitfield buffers)
       const GLfloat z = 1.0 - 2.0 * ctx->Depth.Clear;
       GLuint i;
 
-      verts[0][0] = x0;
-      verts[0][1] = y0;
-      verts[0][2] = z;
-      verts[1][0] = x1;
-      verts[1][1] = y0;
-      verts[1][2] = z;
-      verts[2][0] = x1;
-      verts[2][1] = y1;
-      verts[2][2] = z;
-      verts[3][0] = x0;
-      verts[3][1] = y1;
-      verts[3][2] = z;
+      verts[0].x = x0;
+      verts[0].y = y0;
+      verts[0].z = z;
+      verts[1].x = x1;
+      verts[1].y = y0;
+      verts[1].z = z;
+      verts[2].x = x1;
+      verts[2].y = y1;
+      verts[2].z = z;
+      verts[3].x = x0;
+      verts[3].y = y1;
+      verts[3].z = z;
 
       /* vertex colors */
       for (i = 0; i < 4; i++) {
-         COPY_4FV(&verts[i][3], ctx->Color.ClearColor);
+         verts[i].r = ctx->Color.ClearColor[0];
+         verts[i].g = ctx->Color.ClearColor[1];
+         verts[i].b = ctx->Color.ClearColor[2];
+         verts[i].a = ctx->Color.ClearColor[3];
       }
 
       /* upload new vertex data */
@@ -1171,13 +1319,16 @@ _mesa_meta_clear(GLcontext *ctx, GLbitfield buffers)
  * of texture mapping and polygon rendering.
  */
 void
-_mesa_meta_copy_pixels(GLcontext *ctx, GLint srcX, GLint srcY,
-                       GLsizei width, GLsizei height,
-                       GLint dstX, GLint dstY, GLenum type)
+_mesa_meta_CopyPixels(GLcontext *ctx, GLint srcX, GLint srcY,
+                      GLsizei width, GLsizei height,
+                      GLint dstX, GLint dstY, GLenum type)
 {
    struct copypix_state *copypix = &ctx->Meta->CopyPix;
    struct temp_texture *tex = get_temp_texture(ctx);
-   GLfloat verts[4][5]; /* four verts of X,Y,Z,S,T */
+   struct vertex {
+      GLfloat x, y, z, s, t;
+   };
+   struct vertex verts[4];
    GLboolean newTex;
    GLenum intFormat = GL_RGBA;
 
@@ -1215,10 +1366,8 @@ _mesa_meta_copy_pixels(GLcontext *ctx, GLint srcX, GLint srcY,
                           NULL, GL_DYNAMIC_DRAW_ARB);
 
       /* setup vertex arrays */
-      _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
-                          (void *) (0 * sizeof(GLfloat)));
-      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
-                            (void *) (3 * sizeof(GLfloat)));
+      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
       _mesa_EnableClientState(GL_VERTEX_ARRAY);
       _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
    }
@@ -1237,26 +1386,26 @@ _mesa_meta_copy_pixels(GLcontext *ctx, GLint srcX, GLint srcY,
       const GLfloat dstY1 = dstY + height * ctx->Pixel.ZoomY;
       const GLfloat z = ctx->Current.RasterPos[2];
 
-      verts[0][0] = dstX0;
-      verts[0][1] = dstY0;
-      verts[0][2] = z;
-      verts[0][3] = 0.0F;
-      verts[0][4] = 0.0F;
-      verts[1][0] = dstX1;
-      verts[1][1] = dstY0;
-      verts[1][2] = z;
-      verts[1][3] = tex->Sright;
-      verts[1][4] = 0.0F;
-      verts[2][0] = dstX1;
-      verts[2][1] = dstY1;
-      verts[2][2] = z;
-      verts[2][3] = tex->Sright;
-      verts[2][4] = tex->Ttop;
-      verts[3][0] = dstX0;
-      verts[3][1] = dstY1;
-      verts[3][2] = z;
-      verts[3][3] = 0.0F;
-      verts[3][4] = tex->Ttop;
+      verts[0].x = dstX0;
+      verts[0].y = dstY0;
+      verts[0].z = z;
+      verts[0].s = 0.0F;
+      verts[0].t = 0.0F;
+      verts[1].x = dstX1;
+      verts[1].y = dstY0;
+      verts[1].z = z;
+      verts[1].s = tex->Sright;
+      verts[1].t = 0.0F;
+      verts[2].x = dstX1;
+      verts[2].y = dstY1;
+      verts[2].z = z;
+      verts[2].s = tex->Sright;
+      verts[2].t = tex->Ttop;
+      verts[3].x = dstX0;
+      verts[3].y = dstY1;
+      verts[3].z = z;
+      verts[3].s = 0.0F;
+      verts[3].t = tex->Ttop;
 
       /* upload new vertex data */
       _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
@@ -1266,12 +1415,12 @@ _mesa_meta_copy_pixels(GLcontext *ctx, GLint srcX, GLint srcY,
    setup_copypix_texture(tex, newTex, srcX, srcY, width, height,
                          GL_RGBA, GL_NEAREST);
 
-   _mesa_Enable(tex->Target);
+   _mesa_set_enable(ctx, tex->Target, GL_TRUE);
 
    /* draw textured quad */
    _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
-   _mesa_Disable(tex->Target);
+   _mesa_set_enable(ctx, tex->Target, GL_FALSE);
 
    _mesa_meta_end(ctx);
 }
@@ -1309,9 +1458,8 @@ tiled_draw_pixels(GLcontext *ctx,
 
          tileUnpack.SkipRows = unpack->SkipRows + j;
 
-         _mesa_meta_draw_pixels(ctx, tileX, tileY,
-                                tileWidth, tileHeight,
-                                format, type, &tileUnpack, pixels);
+         _mesa_meta_DrawPixels(ctx, tileX, tileY, tileWidth, tileHeight,
+                               format, type, &tileUnpack, pixels);
       }
    }
 }
@@ -1420,17 +1568,20 @@ init_draw_depth_pixels(GLcontext *ctx)
  * of texture mapping and polygon rendering.
  */
 void
-_mesa_meta_draw_pixels(GLcontext *ctx,
-		       GLint x, GLint y, GLsizei width, GLsizei height,
-		       GLenum format, GLenum type,
-		       const struct gl_pixelstore_attrib *unpack,
-		       const GLvoid *pixels)
+_mesa_meta_DrawPixels(GLcontext *ctx,
+                      GLint x, GLint y, GLsizei width, GLsizei height,
+                      GLenum format, GLenum type,
+                      const struct gl_pixelstore_attrib *unpack,
+                      const GLvoid *pixels)
 {
    struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
    struct temp_texture *tex = get_temp_texture(ctx);
    const struct gl_pixelstore_attrib unpackSave = ctx->Unpack;
    const GLuint origStencilMask = ctx->Stencil.WriteMask[0];
-   GLfloat verts[4][5]; /* four verts of X,Y,Z,S,T */
+   struct vertex {
+      GLfloat x, y, z, s, t;
+   };
+   struct vertex verts[4];
    GLenum texIntFormat;
    GLboolean fallback, newTex;
    GLbitfield metaExtraSave = 0x0;
@@ -1446,13 +1597,18 @@ _mesa_meta_draw_pixels(GLcontext *ctx,
 
    if (_mesa_is_color_format(format)) {
       /* use more compact format when possible */
-      if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA)
+      /* XXX disable special case for GL_LUMINANCE for now to work around
+       * apparent i965 driver bug (see bug #23670).
+       */
+      if (/*format == GL_LUMINANCE ||*/ format == GL_LUMINANCE_ALPHA)
          texIntFormat = format;
       else
          texIntFormat = GL_RGBA;
    }
    else if (_mesa_is_stencil_format(format)) {
       if (ctx->Extensions.ARB_fragment_program &&
+          ctx->Pixel.IndexShift == 0 &&
+          ctx->Pixel.IndexOffset == 0 &&
           type == GL_UNSIGNED_BYTE) {
          /* We'll store stencil as alpha.  This only works for GLubyte
           * image data because of how incoming values are mapped to alpha
@@ -1522,10 +1678,8 @@ _mesa_meta_draw_pixels(GLcontext *ctx,
                           NULL, GL_DYNAMIC_DRAW_ARB);
 
       /* setup vertex arrays */
-      _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
-                          (void *) (0 * sizeof(GLfloat)));
-      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
-                            (void *) (3 * sizeof(GLfloat)));
+      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
       _mesa_EnableClientState(GL_VERTEX_ARRAY);
       _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
    }
@@ -1544,26 +1698,26 @@ _mesa_meta_draw_pixels(GLcontext *ctx,
       const GLfloat y1 = y + height * ctx->Pixel.ZoomY;
       const GLfloat z = ctx->Current.RasterPos[2];
 
-      verts[0][0] = x0;
-      verts[0][1] = y0;
-      verts[0][2] = z;
-      verts[0][3] = 0.0F;
-      verts[0][4] = 0.0F;
-      verts[1][0] = x1;
-      verts[1][1] = y0;
-      verts[1][2] = z;
-      verts[1][3] = tex->Sright;
-      verts[1][4] = 0.0F;
-      verts[2][0] = x1;
-      verts[2][1] = y1;
-      verts[2][2] = z;
-      verts[2][3] = tex->Sright;
-      verts[2][4] = tex->Ttop;
-      verts[3][0] = x0;
-      verts[3][1] = y1;
-      verts[3][2] = z;
-      verts[3][3] = 0.0F;
-      verts[3][4] = tex->Ttop;
+      verts[0].x = x0;
+      verts[0].y = y0;
+      verts[0].z = z;
+      verts[0].s = 0.0F;
+      verts[0].t = 0.0F;
+      verts[1].x = x1;
+      verts[1].y = y0;
+      verts[1].z = z;
+      verts[1].s = tex->Sright;
+      verts[1].t = 0.0F;
+      verts[2].x = x1;
+      verts[2].y = y1;
+      verts[2].z = z;
+      verts[2].s = tex->Sright;
+      verts[2].t = tex->Ttop;
+      verts[3].x = x0;
+      verts[3].y = y1;
+      verts[3].z = z;
+      verts[3].s = 0.0F;
+      verts[3].t = tex->Ttop;
 
       /* upload new vertex data */
       _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
@@ -1572,7 +1726,7 @@ _mesa_meta_draw_pixels(GLcontext *ctx,
    /* set given unpack params */
    ctx->Unpack = *unpack;
 
-   _mesa_Enable(tex->Target);
+   _mesa_set_enable(ctx, tex->Target, GL_TRUE);
 
    if (_mesa_is_stencil_format(format)) {
       /* Drawing stencil */
@@ -1587,6 +1741,13 @@ _mesa_meta_draw_pixels(GLcontext *ctx,
       _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
       _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
+
+      /* set all stencil bits to 0 */
+      _mesa_StencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+      _mesa_StencilFunc(GL_ALWAYS, 0, 255);
+      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
+  
+      /* set stencil bits to 1 where needed */
       _mesa_StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 
       _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
@@ -1629,10 +1790,690 @@ _mesa_meta_draw_pixels(GLcontext *ctx,
       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
    }
 
-   _mesa_Disable(tex->Target);
+   _mesa_set_enable(ctx, tex->Target, GL_FALSE);
 
    /* restore unpack params */
    ctx->Unpack = unpackSave;
 
    _mesa_meta_end(ctx);
 }
+
+
+/**
+ * Do glBitmap with a alpha texture quad.  Use the alpha test to
+ * cull the 'off' bits.  If alpha test is already enabled, fall back
+ * to swrast (should be a rare case).
+ * A bitmap cache as in the gallium/mesa state tracker would
+ * improve performance a lot.
+ */
+void
+_mesa_meta_Bitmap(GLcontext *ctx,
+                  GLint x, GLint y, GLsizei width, GLsizei height,
+                  const struct gl_pixelstore_attrib *unpack,
+                  const GLubyte *bitmap1)
+{
+   struct bitmap_state *bitmap = &ctx->Meta->Bitmap;
+   struct temp_texture *tex = get_bitmap_temp_texture(ctx);
+   const GLenum texIntFormat = GL_ALPHA;
+   const struct gl_pixelstore_attrib unpackSave = *unpack;
+   struct vertex {
+      GLfloat x, y, z, s, t, r, g, b, a;
+   };
+   struct vertex verts[4];
+   GLboolean newTex;
+   GLubyte *bitmap8;
+
+   /*
+    * Check if swrast fallback is needed.
+    */
+   if (ctx->_ImageTransferState ||
+       ctx->Color.AlphaEnabled ||
+       ctx->Fog.Enabled ||
+       ctx->Texture._EnabledUnits ||
+       width > tex->MaxSize ||
+       height > tex->MaxSize) {
+      _swrast_Bitmap(ctx, x, y, width, height, unpack, bitmap1);
+      return;
+   }
+
+   /* Most GL state applies to glBitmap (like blending, stencil, etc),
+    * but a there's a few things we need to override:
+    */
+   _mesa_meta_begin(ctx, (META_ALPHA_TEST |
+                          META_PIXEL_STORE |
+                          META_RASTERIZATION |
+                          META_SHADER |
+                          META_TEXTURE |
+                          META_TRANSFORM |
+                          META_VERTEX |
+                          META_VIEWPORT));
+
+   if (bitmap->ArrayObj == 0) {
+      /* one-time setup */
+
+      /* create vertex array object */
+      _mesa_GenVertexArraysAPPLE(1, &bitmap->ArrayObj);
+      _mesa_BindVertexArrayAPPLE(bitmap->ArrayObj);
+
+      /* create vertex array buffer */
+      _mesa_GenBuffersARB(1, &bitmap->VBO);
+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);
+      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
+                          NULL, GL_DYNAMIC_DRAW_ARB);
+
+      /* setup vertex arrays */
+      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
+      _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));
+      _mesa_EnableClientState(GL_VERTEX_ARRAY);
+      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
+      _mesa_EnableClientState(GL_COLOR_ARRAY);
+   }
+   else {
+      _mesa_BindVertexArray(bitmap->ArrayObj);
+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);
+   }
+
+   newTex = alloc_texture(tex, width, height, texIntFormat);
+
+   /* vertex positions, texcoords, colors (after texture allocation!) */
+   {
+      const GLfloat x0 = (GLfloat) x;
+      const GLfloat y0 = (GLfloat) y;
+      const GLfloat x1 = (GLfloat) (x + width);
+      const GLfloat y1 = (GLfloat) (y + height);
+      const GLfloat z = ctx->Current.RasterPos[2];
+      GLuint i;
+
+      verts[0].x = x0;
+      verts[0].y = y0;
+      verts[0].z = z;
+      verts[0].s = 0.0F;
+      verts[0].t = 0.0F;
+      verts[1].x = x1;
+      verts[1].y = y0;
+      verts[1].z = z;
+      verts[1].s = tex->Sright;
+      verts[1].t = 0.0F;
+      verts[2].x = x1;
+      verts[2].y = y1;
+      verts[2].z = z;
+      verts[2].s = tex->Sright;
+      verts[2].t = tex->Ttop;
+      verts[3].x = x0;
+      verts[3].y = y1;
+      verts[3].z = z;
+      verts[3].s = 0.0F;
+      verts[3].t = tex->Ttop;
+
+      for (i = 0; i < 4; i++) {
+         verts[i].r = ctx->Current.RasterColor[0];
+         verts[i].g = ctx->Current.RasterColor[1];
+         verts[i].b = ctx->Current.RasterColor[2];
+         verts[i].a = ctx->Current.RasterColor[3];
+      }
+
+      /* upload new vertex data */
+      _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
+   }
+
+   bitmap1 = _mesa_map_pbo_source(ctx, &unpackSave, bitmap1);
+   if (!bitmap1)
+      return;
+
+   bitmap8 = (GLubyte *) _mesa_calloc(width * height);
+   if (bitmap8) {
+      _mesa_expand_bitmap(width, height, &unpackSave, bitmap1,
+                          bitmap8, width, 0xff);
+
+      _mesa_set_enable(ctx, tex->Target, GL_TRUE);
+
+      _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_TRUE);
+      _mesa_AlphaFunc(GL_GREATER, 0.0);
+
+      setup_drawpix_texture(tex, newTex, texIntFormat, width, height,
+                            GL_ALPHA, GL_UNSIGNED_BYTE, bitmap8);
+
+      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+      _mesa_set_enable(ctx, tex->Target, GL_FALSE);
+
+      _mesa_free(bitmap8);
+   }
+
+   _mesa_unmap_pbo_source(ctx, &unpackSave);
+
+   _mesa_meta_end(ctx);
+}
+
+
+void
+_mesa_meta_GenerateMipmap(GLcontext *ctx, GLenum target,
+                          struct gl_texture_object *texObj)
+{
+   struct gen_mipmap_state *mipmap = &ctx->Meta->Mipmap;
+   struct vertex {
+      GLfloat x, y, s, t, r;
+   };
+   struct vertex verts[4];
+   const GLuint baseLevel = texObj->BaseLevel;
+   const GLuint maxLevel = texObj->MaxLevel;
+   const GLenum minFilterSave = texObj->MinFilter;
+   const GLenum magFilterSave = texObj->MagFilter;
+   const GLuint fboSave = ctx->DrawBuffer->Name;
+   GLenum faceTarget;
+   GLuint level;
+   GLuint border = 0;
+
+   /* check for fallbacks */
+   if (!ctx->Extensions.EXT_framebuffer_object) {
+      _mesa_generate_mipmap(ctx, target, texObj);
+      return;
+   }
+
+   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
+       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z) {
+      faceTarget = target;
+      target = GL_TEXTURE_CUBE_MAP;
+   }
+   else {
+      faceTarget = target;
+   }
+
+   _mesa_meta_begin(ctx, META_ALL);
+
+   if (mipmap->ArrayObj == 0) {
+      /* one-time setup */
+
+      /* create vertex array object */
+      _mesa_GenVertexArraysAPPLE(1, &mipmap->ArrayObj);
+      _mesa_BindVertexArrayAPPLE(mipmap->ArrayObj);
+
+      /* create vertex array buffer */
+      _mesa_GenBuffersARB(1, &mipmap->VBO);
+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);
+      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
+                          NULL, GL_DYNAMIC_DRAW_ARB);
+
+      /* setup vertex arrays */
+      _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+      _mesa_TexCoordPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
+      _mesa_EnableClientState(GL_VERTEX_ARRAY);
+      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
+   }
+   else {
+      _mesa_BindVertexArray(mipmap->ArrayObj);
+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);
+   }
+
+   if (!mipmap->FBO) {
+      /* Bind the new renderbuffer to the color attachment point. */
+      _mesa_GenFramebuffersEXT(1, &mipmap->FBO);
+   }
+
+   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mipmap->FBO);
+
+   _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+   _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+   _mesa_set_enable(ctx, target, GL_TRUE);
+
+   /* setup texcoords once (XXX what about border?) */
+   switch (faceTarget) {
+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
+      break;
+   case GL_TEXTURE_2D:
+      verts[0].s = 0.0F;
+      verts[0].t = 0.0F;
+      verts[0].r = 0.0F;
+      verts[1].s = 1.0F;
+      verts[1].t = 0.0F;
+      verts[1].r = 0.0F;
+      verts[2].s = 1.0F;
+      verts[2].t = 1.0F;
+      verts[2].r = 0.0F;
+      verts[3].s = 0.0F;
+      verts[3].t = 1.0F;
+      verts[3].r = 0.0F;
+      break;
+   }
+
+
+   for (level = baseLevel + 1; level <= maxLevel; level++) {
+      const struct gl_texture_image *srcImage;
+      const GLuint srcLevel = level - 1;
+      GLsizei srcWidth, srcHeight;
+      GLsizei newWidth, newHeight;
+      GLenum status;
+
+      srcImage = _mesa_select_tex_image(ctx, texObj, target, srcLevel);
+      assert(srcImage->Border == 0); /* XXX we can fix this */
+
+      srcWidth = srcImage->Width - 2 * border;
+      srcHeight = srcImage->Height - 2 * border;
+
+      newWidth = MAX2(1, srcWidth / 2) + 2 * border;
+      newHeight = MAX2(1, srcHeight / 2) + 2 * border;
+
+      if (newWidth == srcImage->Width && newHeight == srcImage->Height) {
+	 break;
+      }
+
+      /* Create empty image */
+      _mesa_TexImage2D(GL_TEXTURE_2D, level, srcImage->InternalFormat,
+		       newWidth, newHeight, border,
+		       GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+
+      /* vertex positions */
+      {
+         verts[0].x = 0.0F;
+         verts[0].y = 0.0F;
+         verts[1].x = (GLfloat) newWidth;
+         verts[1].y = 0.0F;
+         verts[2].x = (GLfloat) newWidth;
+         verts[2].y = (GLfloat) newHeight;
+         verts[3].x = 0.0F;
+         verts[3].y = (GLfloat) newHeight;
+
+         /* upload new vertex data */
+         _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
+      }
+
+      /* limit sampling to src level */
+      _mesa_TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, srcLevel);
+      _mesa_TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, srcLevel);
+
+      /* Set to draw into the current level */
+      _mesa_FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
+                                    GL_COLOR_ATTACHMENT0_EXT,
+                                    target,
+                                    texObj->Name,
+                                    level);
+
+      /* Choose to render to the color attachment. */
+      _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
+
+      status = _mesa_CheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
+      if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+         abort();
+         break;
+      }
+
+      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
+   }
+
+   _mesa_meta_end(ctx);
+
+   _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);
+   _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);
+
+   /* restore (XXX add to meta_begin/end()? */
+   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboSave);
+}
+
+
+/**
+ * Determine the GL data type to use for the temporary image read with
+ * ReadPixels() and passed to Tex[Sub]Image().
+ */
+static GLenum
+get_temp_image_type(GLcontext *ctx, GLenum baseFormat)
+{
+   switch (baseFormat) {
+   case GL_RGBA:
+   case GL_RGB:
+   case GL_ALPHA:
+   case GL_LUMINANCE:
+   case GL_LUMINANCE_ALPHA:
+   case GL_INTENSITY:
+      if (ctx->DrawBuffer->Visual.redBits <= 8)
+         return GL_UNSIGNED_BYTE;
+      else if (ctx->DrawBuffer->Visual.redBits <= 8)
+         return GL_UNSIGNED_SHORT;
+      else
+         return GL_FLOAT;
+   case GL_DEPTH_COMPONENT:
+      return GL_UNSIGNED_INT;
+   case GL_DEPTH_STENCIL:
+      return GL_UNSIGNED_INT_24_8;
+   default:
+      _mesa_problem(ctx, "Unexpected format in get_temp_image_type()");
+      return 0;
+   }
+}
+
+
+/**
+ * Helper for _mesa_meta_CopyTexImage1/2D() functions.
+ * Have to be careful with locking and meta state for pixel transfer.
+ */
+static void
+copy_tex_image(GLcontext *ctx, GLuint dims, GLenum target, GLint level,
+               GLenum internalFormat, GLint x, GLint y,
+               GLsizei width, GLsizei height, GLint border)
+{
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   GLsizei postConvWidth = width, postConvHeight = height;
+   GLenum format, type;
+   GLint bpp;
+   void *buf;
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+
+   format = _mesa_base_tex_format(ctx, internalFormat);
+   type = get_temp_image_type(ctx, format);
+   bpp = _mesa_bytes_per_pixel(format, type);
+   if (bpp <= 0) {
+      _mesa_problem(ctx, "Bad bpp in meta copy_tex_image()");
+      return;
+   }
+
+   /*
+    * Alloc image buffer (XXX could use a PBO)
+    */
+   buf = _mesa_malloc(width * height * bpp);
+   if (!buf) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);
+      return;
+   }
+
+   _mesa_unlock_texture(ctx, texObj); /* need to unlock first */
+
+   /*
+    * Read image from framebuffer (disable pixel transfer ops)
+    */
+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
+   ctx->Driver.ReadPixels(ctx, x, y, width, height,
+			  format, type, &ctx->Pack, buf);
+   _mesa_meta_end(ctx);
+
+   /*
+    * Prepare for new texture image size/data
+    */
+#if FEATURE_convolve
+   if (_mesa_is_color_format(internalFormat)) {
+      _mesa_adjust_image_for_convolution(ctx, 2,
+                                         &postConvWidth, &postConvHeight);
+   }
+#endif
+
+   if (texImage->Data) {
+      ctx->Driver.FreeTexImageData(ctx, texImage);
+   }
+
+   _mesa_init_teximage_fields(ctx, target, texImage,
+                              postConvWidth, postConvHeight, 1,
+                              border, internalFormat);
+
+   /*
+    * Store texture data (with pixel transfer ops)
+    */
+   _mesa_meta_begin(ctx, META_PIXEL_STORE);
+
+   _mesa_update_state(ctx); /* to update pixel transfer state */
+
+   if (target == GL_TEXTURE_1D) {
+      ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
+                             width, border, format, type,
+                             buf, &ctx->Unpack, texObj, texImage);
+   }
+   else {
+      ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
+                             width, height, border, format, type,
+                             buf, &ctx->Unpack, texObj, texImage);
+   }
+   _mesa_meta_end(ctx);
+
+   _mesa_lock_texture(ctx, texObj); /* re-lock */
+
+   _mesa_free(buf);
+}
+
+
+void
+_mesa_meta_CopyTexImage1D(GLcontext *ctx, GLenum target, GLint level,
+                          GLenum internalFormat, GLint x, GLint y,
+                          GLsizei width, GLint border)
+{
+   copy_tex_image(ctx, 1, target, level, internalFormat, x, y,
+                  width, 1, border);
+}
+
+
+void
+_mesa_meta_CopyTexImage2D(GLcontext *ctx, GLenum target, GLint level,
+                          GLenum internalFormat, GLint x, GLint y,
+                          GLsizei width, GLsizei height, GLint border)
+{
+   copy_tex_image(ctx, 2, target, level, internalFormat, x, y,
+                  width, height, border);
+}
+
+
+
+/**
+ * Helper for _mesa_meta_CopyTexSubImage1/2/3D() functions.
+ * Have to be careful with locking and meta state for pixel transfer.
+ */
+static void
+copy_tex_sub_image(GLcontext *ctx, GLuint dims, GLenum target, GLint level,
+                   GLint xoffset, GLint yoffset, GLint zoffset,
+                   GLint x, GLint y,
+                   GLsizei width, GLsizei height)
+{
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   GLenum format, type;
+   GLint bpp;
+   void *buf;
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+
+   format = texImage->TexFormat->BaseFormat;
+   type = get_temp_image_type(ctx, format);
+   bpp = _mesa_bytes_per_pixel(format, type);
+   if (bpp <= 0) {
+      _mesa_problem(ctx, "Bad bpp in meta copy_tex_sub_image()");
+      return;
+   }
+
+   /*
+    * Alloc image buffer (XXX could use a PBO)
+    */
+   buf = _mesa_malloc(width * height * bpp);
+   if (!buf) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage%uD", dims);
+      return;
+   }
+
+   _mesa_unlock_texture(ctx, texObj); /* need to unlock first */
+
+   /*
+    * Read image from framebuffer (disable pixel transfer ops)
+    */
+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
+   ctx->Driver.ReadPixels(ctx, x, y, width, height,
+			  format, type, &ctx->Pack, buf);
+   _mesa_meta_end(ctx);
+
+   _mesa_update_state(ctx); /* to update pixel transfer state */
+
+   /*
+    * Store texture data (with pixel transfer ops)
+    */
+   _mesa_meta_begin(ctx, META_PIXEL_STORE);
+   if (target == GL_TEXTURE_1D) {
+      ctx->Driver.TexSubImage1D(ctx, target, level, xoffset,
+                                width, format, type, buf,
+                                &ctx->Unpack, texObj, texImage);
+   }
+   else if (target == GL_TEXTURE_3D) {
+      ctx->Driver.TexSubImage3D(ctx, target, level, xoffset, yoffset, zoffset,
+                                width, height, 1, format, type, buf,
+                                &ctx->Unpack, texObj, texImage);
+   }
+   else {
+      ctx->Driver.TexSubImage2D(ctx, target, level, xoffset, yoffset,
+                                width, height, format, type, buf,
+                                &ctx->Unpack, texObj, texImage);
+   }
+   _mesa_meta_end(ctx);
+
+   _mesa_lock_texture(ctx, texObj); /* re-lock */
+
+   _mesa_free(buf);
+}
+
+
+void
+_mesa_meta_CopyTexSubImage1D(GLcontext *ctx, GLenum target, GLint level,
+                             GLint xoffset,
+                             GLint x, GLint y, GLsizei width)
+{
+   copy_tex_sub_image(ctx, 1, target, level, xoffset, 0, 0,
+                      x, y, width, 1);
+}
+
+
+void
+_mesa_meta_CopyTexSubImage2D(GLcontext *ctx, GLenum target, GLint level,
+                             GLint xoffset, GLint yoffset,
+                             GLint x, GLint y,
+                             GLsizei width, GLsizei height)
+{
+   copy_tex_sub_image(ctx, 2, target, level, xoffset, yoffset, 0,
+                      x, y, width, height);
+}
+
+
+void
+_mesa_meta_CopyTexSubImage3D(GLcontext *ctx, GLenum target, GLint level,
+                             GLint xoffset, GLint yoffset, GLint zoffset,
+                             GLint x, GLint y,
+                             GLsizei width, GLsizei height)
+{
+   copy_tex_sub_image(ctx, 3, target, level, xoffset, yoffset, zoffset,
+                      x, y, width, height);
+}
+
+
+void
+_mesa_meta_CopyColorTable(GLcontext *ctx,
+                          GLenum target, GLenum internalformat,
+                          GLint x, GLint y, GLsizei width)
+{
+   GLfloat *buf;
+
+   buf = (GLfloat *) _mesa_malloc(width * 4 * sizeof(GLfloat));
+   if (!buf) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyColorTable");
+      return;
+   }
+
+   /*
+    * Read image from framebuffer (disable pixel transfer ops)
+    */
+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
+   ctx->Driver.ReadPixels(ctx, x, y, width, 1,
+                          GL_RGBA, GL_FLOAT, &ctx->Pack, buf);
+
+   _mesa_ColorTable(target, internalformat, width, GL_RGBA, GL_FLOAT, buf);
+
+   _mesa_meta_end(ctx);
+
+   _mesa_free(buf);
+}
+
+
+void
+_mesa_meta_CopyColorSubTable(GLcontext *ctx,GLenum target, GLsizei start,
+                             GLint x, GLint y, GLsizei width)
+{
+   GLfloat *buf;
+
+   buf = (GLfloat *) _mesa_malloc(width * 4 * sizeof(GLfloat));
+   if (!buf) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyColorSubTable");
+      return;
+   }
+
+   /*
+    * Read image from framebuffer (disable pixel transfer ops)
+    */
+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
+   ctx->Driver.ReadPixels(ctx, x, y, width, 1,
+                          GL_RGBA, GL_FLOAT, &ctx->Pack, buf);
+
+   _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_FLOAT, buf);
+
+   _mesa_meta_end(ctx);
+
+   _mesa_free(buf);
+}
+
+
+void
+_mesa_meta_CopyConvolutionFilter1D(GLcontext *ctx, GLenum target,
+                                   GLenum internalFormat,
+                                   GLint x, GLint y, GLsizei width)
+{
+   GLfloat *buf;
+
+   buf = (GLfloat *) _mesa_malloc(width * 4 * sizeof(GLfloat));
+   if (!buf) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyConvolutionFilter2D");
+      return;
+   }
+
+   /*
+    * Read image from framebuffer (disable pixel transfer ops)
+    */
+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
+   _mesa_update_state(ctx);
+   ctx->Driver.ReadPixels(ctx, x, y, width, 1,
+                          GL_RGBA, GL_FLOAT, &ctx->Pack, buf);
+
+   _mesa_ConvolutionFilter1D(target, internalFormat, width,
+                             GL_RGBA, GL_FLOAT, buf);
+
+   _mesa_meta_end(ctx);
+
+   _mesa_free(buf);
+}
+
+
+void
+_mesa_meta_CopyConvolutionFilter2D(GLcontext *ctx, GLenum target,
+                                   GLenum internalFormat, GLint x, GLint y,
+                                   GLsizei width, GLsizei height)
+{
+   GLfloat *buf;
+
+   buf = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));
+   if (!buf) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyConvolutionFilter2D");
+      return;
+   }
+
+   /*
+    * Read image from framebuffer (disable pixel transfer ops)
+    */
+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
+   _mesa_update_state(ctx);
+
+   ctx->Driver.ReadPixels(ctx, x, y, width, height,
+                          GL_RGBA, GL_FLOAT, &ctx->Pack, buf);
+
+   _mesa_ConvolutionFilter2D(target, internalFormat, width, height,
+                             GL_RGBA, GL_FLOAT, buf);
+
+   _mesa_meta_end(ctx);
+
+   _mesa_free(buf);
+}
diff --git a/src/mesa/drivers/common/meta.h b/src/mesa/drivers/common/meta.h
index b03b64c48a..7f659528dc 100644
--- a/src/mesa/drivers/common/meta.h
+++ b/src/mesa/drivers/common/meta.h
@@ -27,29 +27,6 @@
 #define META_H
 
 
-/**
- * Flags passed to _mesa_meta_begin().
- * XXX these flags may evolve...
- */
-/*@{*/
-#define META_ALPHA_TEST      0x1
-#define META_BLEND           0x2  /**< includes logicop */
-#define META_COLOR_MASK      0x4
-#define META_DEPTH_TEST      0x8
-#define META_FOG            0x10
-#define META_RASTERIZATION  0x20
-#define META_SCISSOR        0x40
-#define META_SHADER         0x80
-#define META_STENCIL_TEST  0x100
-#define META_TRANSFORM     0x200 /**< modelview, projection */
-#define META_TEXTURE       0x400
-#define META_VERTEX        0x800
-#define META_VIEWPORT     0x1000
-#define META_PIXEL_STORE  0x2000
-#define META_ALL            ~0x0
-/*@}*/
-
-
 extern void
 _mesa_meta_init(GLcontext *ctx);
 
@@ -57,25 +34,81 @@ extern void
 _mesa_meta_free(GLcontext *ctx);
 
 extern void
-_mesa_meta_blit_framebuffer(GLcontext *ctx,
-                            GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                            GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                            GLbitfield mask, GLenum filter);
+_mesa_meta_BlitFramebuffer(GLcontext *ctx,
+                           GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+                           GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+                           GLbitfield mask, GLenum filter);
+
+extern void
+_mesa_meta_Clear(GLcontext *ctx, GLbitfield buffers);
+
+extern void
+_mesa_meta_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
+                      GLsizei width, GLsizei height,
+                      GLint dstx, GLint dsty, GLenum type);
+
+extern void
+_mesa_meta_DrawPixels(GLcontext *ctx,
+                      GLint x, GLint y, GLsizei width, GLsizei height,
+                      GLenum format, GLenum type,
+                      const struct gl_pixelstore_attrib *unpack,
+                      const GLvoid *pixels);
+
+extern void
+_mesa_meta_Bitmap(GLcontext *ctx,
+                  GLint x, GLint y, GLsizei width, GLsizei height,
+                  const struct gl_pixelstore_attrib *unpack,
+                  const GLubyte *bitmap);
+
+extern void
+_mesa_meta_GenerateMipmap(GLcontext *ctx, GLenum target,
+                          struct gl_texture_object *texObj);
+
+extern void
+_mesa_meta_CopyTexImage1D(GLcontext *ctx, GLenum target, GLint level,
+                          GLenum internalFormat, GLint x, GLint y,
+                          GLsizei width, GLint border);
+
+extern void
+_mesa_meta_CopyTexImage2D(GLcontext *ctx, GLenum target, GLint level,
+                          GLenum internalFormat, GLint x, GLint y,
+                          GLsizei width, GLsizei height, GLint border);
+
+extern void
+_mesa_meta_CopyTexSubImage1D(GLcontext *ctx, GLenum target, GLint level,
+                             GLint xoffset,
+                             GLint x, GLint y, GLsizei width);
+
+extern void
+_mesa_meta_CopyTexSubImage2D(GLcontext *ctx, GLenum target, GLint level,
+                             GLint xoffset, GLint yoffset,
+                             GLint x, GLint y,
+                             GLsizei width, GLsizei height);
+
+extern void
+_mesa_meta_CopyTexSubImage3D(GLcontext *ctx, GLenum target, GLint level,
+                             GLint xoffset, GLint yoffset, GLint zoffset,
+                             GLint x, GLint y,
+                             GLsizei width, GLsizei height);
+
+extern void
+_mesa_meta_CopyColorTable(GLcontext *ctx,
+                          GLenum target, GLenum internalformat,
+                          GLint x, GLint y, GLsizei width);
 
 extern void
-_mesa_meta_clear(GLcontext *ctx, GLbitfield buffers);
+_mesa_meta_CopyColorSubTable(GLcontext *ctx,GLenum target, GLsizei start,
+                             GLint x, GLint y, GLsizei width);
 
 extern void
-_mesa_meta_copy_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
-                       GLsizei width, GLsizei height,
-                       GLint dstx, GLint dsty, GLenum type);
+_mesa_meta_CopyConvolutionFilter1D(GLcontext *ctx, GLenum target,
+                                   GLenum internalFormat,
+                                   GLint x, GLint y, GLsizei width);
 
 extern void
-_mesa_meta_draw_pixels(GLcontext *ctx,
-		       GLint x, GLint y, GLsizei width, GLsizei height,
-		       GLenum format, GLenum type,
-		       const struct gl_pixelstore_attrib *unpack,
-		       const GLvoid *pixels);
+_mesa_meta_CopyConvolutionFilter2D(GLcontext *ctx, GLenum target,
+                                   GLenum internalFormat, GLint x, GLint y,
+                                   GLsizei width, GLsizei height);
 
 
 #endif /* META_H */
diff --git a/src/mesa/drivers/dri/common/extension_helper.h b/src/mesa/drivers/dri/common/extension_helper.h
index 40a030ce0d..5e86324eec 100644
--- a/src/mesa/drivers/dri/common/extension_helper.h
+++ b/src/mesa/drivers/dri/common/extension_helper.h
@@ -316,6 +316,13 @@ static const char CombinerOutputNV_names[] =
     "";
 #endif
 
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttribs3fvNV_names[] =
+    "iip\0" /* Parameter signature */
+    "glVertexAttribs3fvNV\0"
+    "";
+#endif
+
 #if defined(need_GL_VERSION_2_0) || defined(need_GL_ARB_shader_objects)
 static const char Uniform2fARB_names[] =
     "iff\0" /* Parameter signature */
@@ -575,6 +582,13 @@ static const char MatrixIndexusvARB_names[] =
     "";
 #endif
 
+#if defined(need_GL_ARB_draw_elements_base_vertex)
+static const char DrawElementsBaseVertex_names[] =
+    "iiipi\0" /* Parameter signature */
+    "glDrawElementsBaseVertex\0"
+    "";
+#endif
+
 #if defined(need_GL_VERSION_2_0) || defined(need_GL_ARB_vertex_program)
 static const char DisableVertexAttribArrayARB_names[] =
     "i\0" /* Parameter signature */
@@ -970,10 +984,10 @@ static const char GlobalAlphaFactordSUN_names[] =
     "";
 #endif
 
-#if defined(need_GL_NV_vertex_program)
-static const char VertexAttribs3fvNV_names[] =
+#if defined(need_GL_NV_register_combiners)
+static const char GetFinalCombinerInputParameterfvNV_names[] =
     "iip\0" /* Parameter signature */
-    "glVertexAttribs3fvNV\0"
+    "glGetFinalCombinerInputParameterfvNV\0"
     "";
 #endif
 
@@ -3918,6 +3932,13 @@ static const char MapBufferARB_names[] =
     "";
 #endif
 
+#if defined(need_GL_ARB_draw_elements_base_vertex)
+static const char MultiDrawElementsBaseVertex_names[] =
+    "ipipip\0" /* Parameter signature */
+    "glMultiDrawElementsBaseVertex\0"
+    "";
+#endif
+
 #if defined(need_GL_EXT_coordinate_frame)
 static const char Binormal3svEXT_names[] =
     "p\0" /* Parameter signature */
@@ -4396,10 +4417,11 @@ static const char SpriteParameterivSGIX_names[] =
     "";
 #endif
 
-#if defined(need_GL_EXT_provoking_vertex)
+#if defined(need_GL_EXT_provoking_vertex) || defined(need_GL_ARB_provoking_vertex)
 static const char ProvokingVertexEXT_names[] =
     "i\0" /* Parameter signature */
     "glProvokingVertexEXT\0"
+    "glProvokingVertex\0"
     "";
 #endif
 
@@ -4554,10 +4576,10 @@ static const char UniformMatrix3x4fv_names[] =
     "";
 #endif
 
-#if defined(need_GL_EXT_coordinate_frame)
-static const char Binormal3fvEXT_names[] =
-    "p\0" /* Parameter signature */
-    "glBinormal3fvEXT\0"
+#if defined(need_GL_ARB_draw_elements_base_vertex)
+static const char DrawRangeElementsBaseVertex_names[] =
+    "iiiiipi\0" /* Parameter signature */
+    "glDrawRangeElementsBaseVertex\0"
     "";
 #endif
 
@@ -4710,10 +4732,10 @@ static const char GetFragmentLightfvSGIX_names[] =
     "";
 #endif
 
-#if defined(need_GL_NV_register_combiners)
-static const char GetFinalCombinerInputParameterfvNV_names[] =
-    "iip\0" /* Parameter signature */
-    "glGetFinalCombinerInputParameterfvNV\0"
+#if defined(need_GL_EXT_coordinate_frame)
+static const char Binormal3fvEXT_names[] =
+    "p\0" /* Parameter signature */
+    "glBinormal3fvEXT\0"
     "";
 #endif
 
@@ -5090,6 +5112,15 @@ static const struct dri_extension_function GL_ARB_draw_buffers_functions[] = {
 };
 #endif
 
+#if defined(need_GL_ARB_draw_elements_base_vertex)
+static const struct dri_extension_function GL_ARB_draw_elements_base_vertex_functions[] = {
+    { DrawElementsBaseVertex_names, DrawElementsBaseVertex_remap_index, -1 },
+    { MultiDrawElementsBaseVertex_names, MultiDrawElementsBaseVertex_remap_index, -1 },
+    { DrawRangeElementsBaseVertex_names, DrawRangeElementsBaseVertex_remap_index, -1 },
+    { NULL, 0, 0 }
+};
+#endif
+
 #if defined(need_GL_ARB_framebuffer_object)
 static const struct dri_extension_function GL_ARB_framebuffer_object_functions[] = {
     { BlitFramebufferEXT_names, BlitFramebufferEXT_remap_index, -1 },
@@ -5164,6 +5195,13 @@ static const struct dri_extension_function GL_ARB_point_parameters_functions[] =
 };
 #endif
 
+#if defined(need_GL_ARB_provoking_vertex)
+static const struct dri_extension_function GL_ARB_provoking_vertex_functions[] = {
+    { ProvokingVertexEXT_names, ProvokingVertexEXT_remap_index, -1 },
+    { NULL, 0, 0 }
+};
+#endif
+
 #if defined(need_GL_ARB_shader_objects)
 static const struct dri_extension_function GL_ARB_shader_objects_functions[] = {
     { UniformMatrix3fvARB_names, UniformMatrix3fvARB_remap_index, -1 },
@@ -5520,8 +5558,8 @@ static const struct dri_extension_function GL_EXT_coordinate_frame_functions[] =
     { Binormal3dvEXT_names, Binormal3dvEXT_remap_index, -1 },
     { Tangent3iEXT_names, Tangent3iEXT_remap_index, -1 },
     { Tangent3bvEXT_names, Tangent3bvEXT_remap_index, -1 },
-    { Binormal3fvEXT_names, Binormal3fvEXT_remap_index, -1 },
     { Tangent3bEXT_names, Tangent3bEXT_remap_index, -1 },
+    { Binormal3fvEXT_names, Binormal3fvEXT_remap_index, -1 },
     { BinormalPointerEXT_names, BinormalPointerEXT_remap_index, -1 },
     { Tangent3svEXT_names, Tangent3svEXT_remap_index, -1 },
     { Binormal3bEXT_names, Binormal3bEXT_remap_index, -1 },
@@ -5963,6 +6001,7 @@ static const struct dri_extension_function GL_NV_point_sprite_functions[] = {
 static const struct dri_extension_function GL_NV_register_combiners_functions[] = {
     { CombinerOutputNV_names, CombinerOutputNV_remap_index, -1 },
     { CombinerParameterfvNV_names, CombinerParameterfvNV_remap_index, -1 },
+    { GetFinalCombinerInputParameterfvNV_names, GetFinalCombinerInputParameterfvNV_remap_index, -1 },
     { GetCombinerOutputParameterfvNV_names, GetCombinerOutputParameterfvNV_remap_index, -1 },
     { FinalCombinerInputNV_names, FinalCombinerInputNV_remap_index, -1 },
     { GetCombinerInputParameterfvNV_names, GetCombinerInputParameterfvNV_remap_index, -1 },
@@ -5971,7 +6010,6 @@ static const struct dri_extension_function GL_NV_register_combiners_functions[]
     { GetFinalCombinerInputParameterivNV_names, GetFinalCombinerInputParameterivNV_remap_index, -1 },
     { CombinerInputNV_names, CombinerInputNV_remap_index, -1 },
     { CombinerParameterfNV_names, CombinerParameterfNV_remap_index, -1 },
-    { GetFinalCombinerInputParameterfvNV_names, GetFinalCombinerInputParameterfvNV_remap_index, -1 },
     { GetCombinerInputParameterivNV_names, GetCombinerInputParameterivNV_remap_index, -1 },
     { CombinerParameterivNV_names, CombinerParameterivNV_remap_index, -1 },
     { NULL, 0, 0 }
@@ -5998,6 +6036,7 @@ static const struct dri_extension_function GL_NV_vertex_array_range_functions[]
 static const struct dri_extension_function GL_NV_vertex_program_functions[] = {
     { VertexAttrib4ubvNV_names, VertexAttrib4ubvNV_remap_index, -1 },
     { VertexAttrib4svNV_names, VertexAttrib4svNV_remap_index, -1 },
+    { VertexAttribs3fvNV_names, VertexAttribs3fvNV_remap_index, -1 },
     { VertexAttribs1dvNV_names, VertexAttribs1dvNV_remap_index, -1 },
     { VertexAttrib1fvNV_names, VertexAttrib1fvNV_remap_index, -1 },
     { VertexAttrib4fNV_names, VertexAttrib4fNV_remap_index, -1 },
@@ -6006,7 +6045,6 @@ static const struct dri_extension_function GL_NV_vertex_program_functions[] = {
     { VertexAttribs3dvNV_names, VertexAttribs3dvNV_remap_index, -1 },
     { VertexAttribs4fvNV_names, VertexAttribs4fvNV_remap_index, -1 },
     { VertexAttrib2sNV_names, VertexAttrib2sNV_remap_index, -1 },
-    { VertexAttribs3fvNV_names, VertexAttribs3fvNV_remap_index, -1 },
     { ProgramEnvParameter4fvARB_names, ProgramEnvParameter4fvARB_remap_index, -1 },
     { LoadProgramNV_names, LoadProgramNV_remap_index, -1 },
     { VertexAttrib4fvNV_names, VertexAttrib4fvNV_remap_index, -1 },
diff --git a/src/mesa/drivers/dri/ffb/ffb_tex.c b/src/mesa/drivers/dri/ffb/ffb_tex.c
index 69d30aedba..95058e9069 100644
--- a/src/mesa/drivers/dri/ffb/ffb_tex.c
+++ b/src/mesa/drivers/dri/ffb/ffb_tex.c
@@ -30,24 +30,6 @@
 #include "ffb_tex.h"
 
 /* No texture unit, all software. */
-/* XXX this function isn't needed since _mesa_init_driver_functions()
- * will make all these assignments.
- */
 void ffbDDInitTexFuncs(GLcontext *ctx)
 {
-        /*
-	ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
-	ctx->Driver.TexImage1D = _mesa_store_teximage1d;
-	ctx->Driver.TexImage2D = _mesa_store_teximage2d;
-	ctx->Driver.TexImage3D = _mesa_store_teximage3d;
-	ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
-	ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d;
-	ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
-	ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
-	ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
-	ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
-	ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
-	ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
-	ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
-	*/
 }
diff --git a/src/mesa/drivers/dri/i965/brw_cc.c b/src/mesa/drivers/dri/i965/brw_cc.c
index c724218cf5..1088a7a607 100644
--- a/src/mesa/drivers/dri/i965/brw_cc.c
+++ b/src/mesa/drivers/dri/i965/brw_cc.c
@@ -39,12 +39,14 @@
 
 static void prepare_cc_vp( struct brw_context *brw )
 {
+   GLcontext *ctx = &brw->intel.ctx;
    struct brw_cc_viewport ccv;
 
    memset(&ccv, 0, sizeof(ccv));
 
-   ccv.min_depth = 0.0;
-   ccv.max_depth = 1.0;
+   /* _NEW_VIEWPORT */
+   ccv.min_depth = ctx->Viewport.Near;
+   ccv.max_depth = ctx->Viewport.Far;
 
    dri_bo_unreference(brw->cc.vp_bo);
    brw->cc.vp_bo = brw_cache_data( &brw->cache, BRW_CC_VP, &ccv, NULL, 0 );
@@ -52,7 +54,7 @@ static void prepare_cc_vp( struct brw_context *brw )
 
 const struct brw_tracked_state brw_cc_vp = {
    .dirty = {
-      .mesa = 0,
+      .mesa = _NEW_VIEWPORT,
       .brw = BRW_NEW_CONTEXT,
       .cache = 0
    },
diff --git a/src/mesa/drivers/dri/i965/brw_clip_state.c b/src/mesa/drivers/dri/i965/brw_clip_state.c
index 5762c9577c..234b3744bf 100644
--- a/src/mesa/drivers/dri/i965/brw_clip_state.c
+++ b/src/mesa/drivers/dri/i965/brw_clip_state.c
@@ -43,11 +43,14 @@ struct brw_clip_unit_key {
    unsigned int curbe_offset;
 
    unsigned int nr_urb_entries, urb_size;
+
+   GLboolean depth_clamp;
 };
 
 static void
 clip_unit_populate_key(struct brw_context *brw, struct brw_clip_unit_key *key)
 {
+   GLcontext *ctx = &brw->intel.ctx;
    memset(key, 0, sizeof(*key));
 
    /* CACHE_NEW_CLIP_PROG */
@@ -62,6 +65,9 @@ clip_unit_populate_key(struct brw_context *brw, struct brw_clip_unit_key *key)
    /* BRW_NEW_URB_FENCE */
    key->nr_urb_entries = brw->urb.nr_clip_entries;
    key->urb_size = brw->urb.vsize;
+
+   /* _NEW_TRANSOFORM */
+   key->depth_clamp = ctx->Transform.DepthClamp;
 }
 
 static dri_bo *
@@ -117,7 +123,8 @@ clip_unit_create_from_key(struct brw_context *brw,
    clip.clip5.userclip_enable_flags = 0x7f;
    clip.clip5.userclip_must_clip = 1;
    clip.clip5.guard_band_enable = 0;
-   clip.clip5.viewport_z_clip_enable = 1;
+   if (!key->depth_clamp)
+      clip.clip5.viewport_z_clip_enable = 1;
    clip.clip5.viewport_xy_clip_enable = 1;
    clip.clip5.vertex_position_space = BRW_CLIP_NDCSPACE;
    clip.clip5.api_mode = BRW_CLIP_API_OGL;
@@ -168,7 +175,7 @@ static void upload_clip_unit( struct brw_context *brw )
 
 const struct brw_tracked_state brw_clip_unit = {
    .dirty = {
-      .mesa  = 0,
+      .mesa  = _NEW_TRANSFORM,
       .brw   = (BRW_NEW_CURBE_OFFSETS |
 		BRW_NEW_URB_FENCE),
       .cache = CACHE_NEW_CLIP_PROG
diff --git a/src/mesa/drivers/dri/i965/brw_context.h b/src/mesa/drivers/dri/i965/brw_context.h
index 26a64d6528..a5209ac41b 100644
--- a/src/mesa/drivers/dri/i965/brw_context.h
+++ b/src/mesa/drivers/dri/i965/brw_context.h
@@ -390,6 +390,8 @@ struct brw_cached_batch_item {
 struct brw_vertex_element {
    const struct gl_client_array *glarray;
 
+   /** The corresponding Mesa vertex attribute */
+   gl_vert_attrib attrib;
    /** Size of a complete element */
    GLuint element_size;
    /** Number of uploaded elements for this input. */
diff --git a/src/mesa/drivers/dri/i965/brw_draw.c b/src/mesa/drivers/dri/i965/brw_draw.c
index 682094ff13..44bb7bd588 100644
--- a/src/mesa/drivers/dri/i965/brw_draw.c
+++ b/src/mesa/drivers/dri/i965/brw_draw.c
@@ -25,13 +25,15 @@
  * 
  **************************************************************************/
 
-#include <stdlib.h>
 
 #include "main/glheader.h"
 #include "main/context.h"
 #include "main/state.h"
-#include "main/api_validate.h"
 #include "main/enums.h"
+#include "tnl/tnl.h"
+#include "vbo/vbo_context.h"
+#include "swrast/swrast.h"
+#include "swrast_setup/swrast_setup.h"
 
 #include "brw_draw.h"
 #include "brw_defines.h"
@@ -42,11 +44,6 @@
 #include "intel_batchbuffer.h"
 #include "intel_buffer_objects.h"
 
-#include "tnl/tnl.h"
-#include "vbo/vbo_context.h"
-#include "swrast/swrast.h"
-#include "swrast_setup/swrast_setup.h"
-
 #define FILE_DEBUG_FLAG DEBUG_BATCH
 
 static GLuint prim_to_hw_prim[GL_POLYGON+1] = {
@@ -145,7 +142,7 @@ static void brw_emit_prim(struct brw_context *brw,
       prim_packet.start_vert_location += brw->ib.start_vertex_offset;
    prim_packet.instance_count = 1;
    prim_packet.start_instance_location = 0;
-   prim_packet.base_vert_location = 0;
+   prim_packet.base_vert_location = prim->basevertex;
 
    /* Can't wrap here, since we rely on the validated state. */
    brw->no_batch_wrap = GL_TRUE;
@@ -187,6 +184,7 @@ static void brw_merge_inputs( struct brw_context *brw,
 
    for (i = 0; i < VERT_ATTRIB_MAX; i++) {
       brw->vb.inputs[i].glarray = arrays[i];
+      brw->vb.inputs[i].attrib = (gl_vert_attrib) i;
 
       if (arrays[i]->StrideB != 0)
 	 brw->vb.info.sizes[i/16] |= (brw->vb.inputs[i].glarray->Size - 1) <<
diff --git a/src/mesa/drivers/dri/i965/brw_draw_upload.c b/src/mesa/drivers/dri/i965/brw_draw_upload.c
index d49fb0fd95..765ae5a2fe 100644
--- a/src/mesa/drivers/dri/i965/brw_draw_upload.c
+++ b/src/mesa/drivers/dri/i965/brw_draw_upload.c
@@ -25,9 +25,9 @@
  * 
  **************************************************************************/
 
-#include <stdlib.h>
 
 #include "main/glheader.h"
+#include "main/bufferobj.h"
 #include "main/context.h"
 #include "main/state.h"
 #include "main/api_validate.h"
@@ -384,7 +384,7 @@ static void brw_prepare_vertices(struct brw_context *brw)
 
       input->element_size = get_size(input->glarray->Type) * input->glarray->Size;
 
-      if (input->glarray->BufferObj->Name != 0) {
+      if (_mesa_is_bufferobj(input->glarray->BufferObj)) {
 	 struct intel_buffer_object *intel_buffer =
 	    intel_buffer_object(input->glarray->BufferObj);
 
@@ -423,7 +423,7 @@ static void brw_prepare_vertices(struct brw_context *brw)
 	 /* Queue the buffer object up to be uploaded in the next pass,
 	  * when we've decided if we're doing interleaved or not.
 	  */
-	 if (i == 0) {
+	 if (input->attrib == VERT_ATTRIB_POS) {
 	    /* Position array not properly enabled:
 	     */
             if (input->glarray->StrideB == 0) {
@@ -623,7 +623,7 @@ static void brw_prepare_indices(struct brw_context *brw)
 
    /* Turn into a proper VBO:
     */
-   if (!bufferobj->Name) {
+   if (!_mesa_is_bufferobj(bufferobj)) {
       brw->ib.start_vertex_offset = 0;
 
       /* Get new bufferobj, offset:
diff --git a/src/mesa/drivers/dri/i965/brw_vs_emit.c b/src/mesa/drivers/dri/i965/brw_vs_emit.c
index 584fdbdfc3..1638ef8111 100644
--- a/src/mesa/drivers/dri/i965/brw_vs_emit.c
+++ b/src/mesa/drivers/dri/i965/brw_vs_emit.c
@@ -1270,9 +1270,27 @@ post_vs_emit( struct brw_vs_compile *c,
 }
 
 static uint32_t
-get_predicate(uint32_t swizzle)
+get_predicate(const struct prog_instruction *inst)
 {
-   switch (swizzle) {
+   if (inst->DstReg.CondMask == COND_TR)
+      return BRW_PREDICATE_NONE;
+
+   /* All of GLSL only produces predicates for COND_NE and one channel per
+    * vector.  Fail badly if someone starts doing something else, as it might
+    * mean infinite looping or something.
+    *
+    * We'd like to support all the condition codes, but our hardware doesn't
+    * quite match the Mesa IR, which is modeled after the NV extensions.  For
+    * those, the instruction may update the condition codes or not, then any
+    * later instruction may use one of those condition codes.  For gen4, the
+    * instruction may update the flags register based on one of the condition
+    * codes output by the instruction, and then further instructions may
+    * predicate on that.  We can probably support this, but it won't
+    * necessarily be easy.
+    */
+   assert(inst->DstReg.CondMask == COND_NE);
+
+   switch (inst->DstReg.CondSwizzle) {
    case SWIZZLE_XXXX:
       return BRW_PREDICATE_ALIGN16_REPLICATE_X;
    case SWIZZLE_YYYY:
@@ -1282,7 +1300,8 @@ get_predicate(uint32_t swizzle)
    case SWIZZLE_WWWW:
       return BRW_PREDICATE_ALIGN16_REPLICATE_W;
    default:
-      _mesa_problem(NULL, "Unexpected predicate: 0x%08x\n", swizzle);
+      _mesa_problem(NULL, "Unexpected predicate: 0x%08x\n",
+		    inst->DstReg.CondMask);
       return BRW_PREDICATE_NORMAL;
    }
 }
@@ -1294,6 +1313,7 @@ void brw_vs_emit(struct brw_vs_compile *c )
 #define MAX_IF_DEPTH 32
 #define MAX_LOOP_DEPTH 32
    struct brw_compile *p = &c->func;
+   struct brw_context *brw = p->brw;
    const GLuint nr_insns = c->vp->program.Base.NumInstructions;
    GLuint insn, if_depth = 0, loop_depth = 0;
    GLuint end_offset = 0;
@@ -1492,8 +1512,8 @@ void brw_vs_emit(struct brw_vs_compile *c )
       case OPCODE_IF:
 	 assert(if_depth < MAX_IF_DEPTH);
 	 if_inst[if_depth] = brw_IF(p, BRW_EXECUTE_8);
-	 if_inst[if_depth]->header.predicate_control =
-	    get_predicate(inst->DstReg.CondSwizzle);
+	 /* Note that brw_IF smashes the predicate_control field. */
+	 if_inst[if_depth]->header.predicate_control = get_predicate(inst);
 	 if_depth++;
 	 break;
       case OPCODE_ELSE:
@@ -1503,45 +1523,48 @@ void brw_vs_emit(struct brw_vs_compile *c )
          assert(if_depth > 0);
 	 brw_ENDIF(p, if_inst[--if_depth]);
 	 break;			
-#if 0
       case OPCODE_BGNLOOP:
          loop_inst[loop_depth++] = brw_DO(p, BRW_EXECUTE_8);
          break;
       case OPCODE_BRK:
+	 brw_set_predicate_control(p, get_predicate(inst));
          brw_BREAK(p);
-         brw_set_predicate_control(p, BRW_PREDICATE_NONE);
+	 brw_set_predicate_control(p, BRW_PREDICATE_NONE);
          break;
       case OPCODE_CONT:
+	 brw_set_predicate_control(p, get_predicate(inst));
          brw_CONT(p);
          brw_set_predicate_control(p, BRW_PREDICATE_NONE);
          break;
       case OPCODE_ENDLOOP: 
          {
             struct brw_instruction *inst0, *inst1;
+	    GLuint br = 1;
+
             loop_depth--;
+
+	    if (BRW_IS_IGDNG(brw))
+	       br = 2;
+
             inst0 = inst1 = brw_WHILE(p, loop_inst[loop_depth]);
             /* patch all the BREAK/CONT instructions from last BEGINLOOP */
             while (inst0 > loop_inst[loop_depth]) {
                inst0--;
                if (inst0->header.opcode == BRW_OPCODE_BREAK) {
-                  inst0->bits3.if_else.jump_count = inst1 - inst0 + 1;
+                  inst0->bits3.if_else.jump_count = br * (inst1 - inst0 + 1);
                   inst0->bits3.if_else.pop_count = 0;
                }
                else if (inst0->header.opcode == BRW_OPCODE_CONTINUE) {
-                  inst0->bits3.if_else.jump_count = inst1 - inst0;
+                  inst0->bits3.if_else.jump_count = br * (inst1 - inst0);
                   inst0->bits3.if_else.pop_count = 0;
                }
             }
          }
          break;
-#else
-         (void) loop_inst;
-         (void) loop_depth;
-#endif
       case OPCODE_BRA:
-         brw_set_predicate_control(p, BRW_PREDICATE_NORMAL);
+	 brw_set_predicate_control(p, get_predicate(inst));
          brw_ADD(p, brw_ip_reg(), brw_ip_reg(), brw_imm_d(1*16));
-         brw_set_predicate_control_flag_value(p, 0xff);
+	 brw_set_predicate_control(p, BRW_PREDICATE_NONE);
          break;
       case OPCODE_CAL:
 	 brw_set_access_mode(p, BRW_ALIGN_1);
diff --git a/src/mesa/drivers/dri/i965/brw_wm.h b/src/mesa/drivers/dri/i965/brw_wm.h
index ae98b5492d..872b1f3ecf 100644
--- a/src/mesa/drivers/dri/i965/brw_wm.h
+++ b/src/mesa/drivers/dri/i965/brw_wm.h
@@ -38,6 +38,8 @@
 #include "brw_context.h"
 #include "brw_eu.h"
 
+#define SATURATE (1<<5)
+
 /* A big lookup table is used to figure out which and how many
  * additional regs will inserted before the main payload in the WM
  * program execution.  These mainly relate to depth and stencil
@@ -203,7 +205,6 @@ struct brw_wm_compile {
    GLuint fp_temp;
    GLuint fp_interp_emitted;
    GLuint fp_fragcolor_emitted;
-   GLuint fp_deriv_emitted;
 
    struct prog_src_register pixel_xy;
    struct prog_src_register delta_xy;
@@ -299,5 +300,10 @@ void brw_wm_lookup_iz( GLuint line_aa,
 GLboolean brw_wm_is_glsl(const struct gl_fragment_program *fp);
 void brw_wm_glsl_emit(struct brw_context *brw, struct brw_wm_compile *c);
 
+void emit_ddxy(struct brw_compile *p,
+	       const struct brw_reg *dst,
+	       GLuint mask,
+	       GLboolean is_ddx,
+	       const struct brw_reg *arg0);
 
 #endif
diff --git a/src/mesa/drivers/dri/i965/brw_wm_emit.c b/src/mesa/drivers/dri/i965/brw_wm_emit.c
index 981864323e..bf80a2942a 100644
--- a/src/mesa/drivers/dri/i965/brw_wm_emit.c
+++ b/src/mesa/drivers/dri/i965/brw_wm_emit.c
@@ -34,8 +34,6 @@
 #include "brw_context.h"
 #include "brw_wm.h"
 
-#define SATURATE (1<<5)
-
 /* Not quite sure how correct this is - need to understand horiz
  * vs. vertical strides a little better.
  */
@@ -281,6 +279,79 @@ static void emit_frontfacing( struct brw_compile *p,
    brw_set_predicate_control_flag_value(p, 0xff);
 }
 
+/* For OPCODE_DDX and OPCODE_DDY, per channel of output we've got input
+ * looking like:
+ *
+ * arg0: ss0.tl ss0.tr ss0.bl ss0.br ss1.tl ss1.tr ss1.bl ss1.br
+ *
+ * and we're trying to produce:
+ *
+ *           DDX                     DDY
+ * dst: (ss0.tr - ss0.tl)     (ss0.tl - ss0.bl)
+ *      (ss0.tr - ss0.tl)     (ss0.tr - ss0.br)
+ *      (ss0.br - ss0.bl)     (ss0.tl - ss0.bl)
+ *      (ss0.br - ss0.bl)     (ss0.tr - ss0.br)
+ *      (ss1.tr - ss1.tl)     (ss1.tl - ss1.bl)
+ *      (ss1.tr - ss1.tl)     (ss1.tr - ss1.br)
+ *      (ss1.br - ss1.bl)     (ss1.tl - ss1.bl)
+ *      (ss1.br - ss1.bl)     (ss1.tr - ss1.br)
+ *
+ * and add another set of two more subspans if in 16-pixel dispatch mode.
+ *
+ * For DDX, it ends up being easy: width = 2, horiz=0 gets us the same result
+ * for each pair, and vertstride = 2 jumps us 2 elements after processing a
+ * pair. But for DDY, it's harder, as we want to produce the pairs swizzled
+ * between each other.  We could probably do it like ddx and swizzle the right
+ * order later, but bail for now and just produce
+ * ((ss0.tl - ss0.bl)x4 (ss1.tl - ss1.bl)x4)
+ */
+void emit_ddxy(struct brw_compile *p,
+	       const struct brw_reg *dst,
+	       GLuint mask,
+	       GLboolean is_ddx,
+	       const struct brw_reg *arg0)
+{
+   int i;
+   struct brw_reg src0, src1;
+
+   if (mask & SATURATE)
+      brw_set_saturate(p, 1);
+   for (i = 0; i < 4; i++ ) {
+      if (mask & (1<<i)) {
+	 if (is_ddx) {
+	    src0 = brw_reg(arg0[i].file, arg0[i].nr, 1,
+			   BRW_REGISTER_TYPE_F,
+			   BRW_VERTICAL_STRIDE_2,
+			   BRW_WIDTH_2,
+			   BRW_HORIZONTAL_STRIDE_0,
+			   BRW_SWIZZLE_XYZW, WRITEMASK_XYZW);
+	    src1 = brw_reg(arg0[i].file, arg0[i].nr, 0,
+			   BRW_REGISTER_TYPE_F,
+			   BRW_VERTICAL_STRIDE_2,
+			   BRW_WIDTH_2,
+			   BRW_HORIZONTAL_STRIDE_0,
+			   BRW_SWIZZLE_XYZW, WRITEMASK_XYZW);
+	 } else {
+	    src0 = brw_reg(arg0[i].file, arg0[i].nr, 0,
+			   BRW_REGISTER_TYPE_F,
+			   BRW_VERTICAL_STRIDE_4,
+			   BRW_WIDTH_4,
+			   BRW_HORIZONTAL_STRIDE_0,
+			   BRW_SWIZZLE_XYZW, WRITEMASK_XYZW);
+	    src1 = brw_reg(arg0[i].file, arg0[i].nr, 2,
+			   BRW_REGISTER_TYPE_F,
+			   BRW_VERTICAL_STRIDE_4,
+			   BRW_WIDTH_4,
+			   BRW_HORIZONTAL_STRIDE_0,
+			   BRW_SWIZZLE_XYZW, WRITEMASK_XYZW);
+	 }
+	 brw_ADD(p, dst[i], src0, negate(src1));
+      }
+   }
+   if (mask & SATURATE)
+      brw_set_saturate(p, 0);
+}
+
 static void emit_alu1( struct brw_compile *p, 
 		       struct brw_instruction *(*func)(struct brw_compile *, 
 						       struct brw_reg, 
@@ -1272,6 +1343,14 @@ void brw_wm_emit( struct brw_wm_compile *c )
 	 emit_alu1(p, brw_RNDD, dst, dst_flags, args[0]);
 	 break;
 
+      case OPCODE_DDX:
+	 emit_ddxy(p, dst, dst_flags, GL_TRUE, args[0]);
+	 break;
+
+      case OPCODE_DDY:
+	 emit_ddxy(p, dst, dst_flags, GL_FALSE, args[0]);
+	 break;
+
       case OPCODE_DP3:
 	 emit_dp3(p, dst, dst_flags, args[0], args[1]);
 	 break;
diff --git a/src/mesa/drivers/dri/i965/brw_wm_fp.c b/src/mesa/drivers/dri/i965/brw_wm_fp.c
index 123fe841c3..4e3edfbbff 100644
--- a/src/mesa/drivers/dri/i965/brw_wm_fp.c
+++ b/src/mesa/drivers/dri/i965/brw_wm_fp.c
@@ -494,38 +494,6 @@ static void emit_interp( struct brw_wm_compile *c,
    c->fp_interp_emitted |= 1<<idx;
 }
 
-static void emit_ddx( struct brw_wm_compile *c,
-        const struct prog_instruction *inst )
-{
-    GLuint idx = inst->SrcReg[0].Index;
-    struct prog_src_register interp = src_reg(PROGRAM_PAYLOAD, idx);
-
-    c->fp_deriv_emitted |= 1<<idx;
-    emit_op(c,
-            OPCODE_DDX,
-            inst->DstReg,
-            0,
-            interp,
-            get_pixel_w(c),
-            src_undef());
-}
-
-static void emit_ddy( struct brw_wm_compile *c,
-        const struct prog_instruction *inst )
-{
-    GLuint idx = inst->SrcReg[0].Index;
-    struct prog_src_register interp = src_reg(PROGRAM_PAYLOAD, idx);
-
-    c->fp_deriv_emitted |= 1<<idx;
-    emit_op(c,
-            OPCODE_DDY,
-            inst->DstReg,
-            0,
-            interp,
-            get_pixel_w(c),
-            src_undef());
-}
-
 /***********************************************************************
  * Hacks to extend the program parameter and constant lists.
  */
@@ -1186,12 +1154,6 @@ void brw_wm_pass_fp( struct brw_wm_compile *c )
 	  */
 	 out->DstReg.WriteMask = 0;
 	 break;
-      case OPCODE_DDX:
-	 emit_ddx(c, inst);
-	 break;
-      case OPCODE_DDY:
-         emit_ddy(c, inst);
-	break;
       case OPCODE_END:
 	 emit_fb_write(c);
 	 break;
diff --git a/src/mesa/drivers/dri/i965/brw_wm_glsl.c b/src/mesa/drivers/dri/i965/brw_wm_glsl.c
index 7c210abbce..c9fe1dd8ad 100644
--- a/src/mesa/drivers/dri/i965/brw_wm_glsl.c
+++ b/src/mesa/drivers/dri/i965/brw_wm_glsl.c
@@ -22,6 +22,7 @@ static struct brw_reg get_dst_reg(struct brw_wm_compile *c,
 GLboolean brw_wm_is_glsl(const struct gl_fragment_program *fp)
 {
     int i;
+
     for (i = 0; i < fp->Base.NumInstructions; i++) {
 	const struct prog_instruction *inst = &fp->Base.Instructions[i];
 	switch (inst->Opcode) {
@@ -31,8 +32,6 @@ GLboolean brw_wm_is_glsl(const struct gl_fragment_program *fp)
 	    case OPCODE_CAL:
 	    case OPCODE_BRK:
 	    case OPCODE_RET:
-	    case OPCODE_DDX:
-	    case OPCODE_DDY:
 	    case OPCODE_NOISE1:
 	    case OPCODE_NOISE2:
 	    case OPCODE_NOISE3:
@@ -293,7 +292,7 @@ static void prealloc_reg(struct brw_wm_compile *c)
     int i, j;
     struct brw_reg reg;
     int urb_read_length = 0;
-    GLuint inputs = FRAG_BIT_WPOS | c->fp_interp_emitted | c->fp_deriv_emitted;
+    GLuint inputs = FRAG_BIT_WPOS | c->fp_interp_emitted;
     GLuint reg_index = 0;
 
     memset(c->used_grf, GL_FALSE, sizeof(c->used_grf));
@@ -1474,61 +1473,6 @@ static void emit_sne(struct brw_wm_compile *c,
     emit_sop(c, inst, BRW_CONDITIONAL_NEQ);
 }
 
-static void emit_ddx(struct brw_wm_compile *c,
-                     const struct prog_instruction *inst)
-{
-    struct brw_compile *p = &c->func;
-    GLuint mask = inst->DstReg.WriteMask;
-    struct brw_reg interp[4];
-    struct brw_reg dst;
-    struct brw_reg src0, w;
-    GLuint nr, i;
-    src0 = get_src_reg(c, inst, 0, 0);
-    w = get_src_reg(c, inst, 1, 3);
-    nr = src0.nr;
-    interp[0] = brw_vec1_grf(nr, 0);
-    interp[1] = brw_vec1_grf(nr, 4);
-    interp[2] = brw_vec1_grf(nr+1, 0);
-    interp[3] = brw_vec1_grf(nr+1, 4);
-    brw_set_saturate(p, inst->SaturateMode != SATURATE_OFF);
-    for(i = 0; i < 4; i++ ) {
-        if (mask & (1<<i)) {
-            dst = get_dst_reg(c, inst, i);
-            brw_MOV(p, dst, interp[i]);
-            brw_MUL(p, dst, dst, w);
-        }
-    }
-    brw_set_saturate(p, 0);
-}
-
-static void emit_ddy(struct brw_wm_compile *c,
-                     const struct prog_instruction *inst)
-{
-    struct brw_compile *p = &c->func;
-    GLuint mask = inst->DstReg.WriteMask;
-    struct brw_reg interp[4];
-    struct brw_reg dst;
-    struct brw_reg src0, w;
-    GLuint nr, i;
-
-    src0 = get_src_reg(c, inst, 0, 0);
-    nr = src0.nr;
-    w = get_src_reg(c, inst, 1, 3);
-    interp[0] = brw_vec1_grf(nr, 0);
-    interp[1] = brw_vec1_grf(nr, 4);
-    interp[2] = brw_vec1_grf(nr+1, 0);
-    interp[3] = brw_vec1_grf(nr+1, 4);
-    brw_set_saturate(p, inst->SaturateMode != SATURATE_OFF);
-    for(i = 0; i < 4; i++ ) {
-        if (mask & (1<<i)) {
-            dst = get_dst_reg(c, inst, i);
-            brw_MOV(p, dst, suboffset(interp[i], 1));
-            brw_MUL(p, dst, dst, w);
-        }
-    }
-    brw_set_saturate(p, 0);
-}
-
 static INLINE struct brw_reg high_words( struct brw_reg reg )
 {
     return stride( suboffset( retype( reg, BRW_REGISTER_TYPE_W ), 1 ),
@@ -2780,6 +2724,21 @@ static void post_wm_emit( struct brw_wm_compile *c )
     brw_resolve_cals(&c->func);
 }
 
+static void
+get_argument_regs(struct brw_wm_compile *c,
+		  const struct prog_instruction *inst,
+		  int index,
+		  struct brw_reg *regs,
+		  int mask)
+{
+    int i;
+
+    for (i = 0; i < 4; i++) {
+	if (mask & (1 << i))
+	    regs[i] = get_src_reg(c, inst, index, i);
+    }
+}
+
 static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c)
 {
 #define MAX_IF_DEPTH 32
@@ -2797,6 +2756,9 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c)
 
     for (i = 0; i < c->nr_fp_insns; i++) {
         const struct prog_instruction *inst = &c->prog_instructions[i];
+	int dst_flags;
+	struct brw_reg args[3][4], dst[4];
+	int j;
 
         c->cur_inst = i;
 
@@ -2814,6 +2776,10 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c)
 	else
 	    brw_set_conditionalmod(p, BRW_CONDITIONAL_NONE);
 
+	dst_flags = inst->DstReg.WriteMask;
+	if (inst->SaturateMode == SATURATE_ZERO_ONE)
+	    dst_flags |= SATURATE;
+
 	switch (inst->Opcode) {
 	    case WM_PIXELXY:
 		emit_pixel_xy(c, inst);
@@ -2899,10 +2865,16 @@ static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c)
 		emit_min_max(c, inst);
 		break;
 	    case OPCODE_DDX:
-		emit_ddx(c, inst);
-		break;
 	    case OPCODE_DDY:
-                emit_ddy(c, inst);
+		for (j = 0; j < 4; j++) {
+		    if (inst->DstReg.WriteMask & (1 << j))
+			dst[j] = get_dst_reg(c, inst, j);
+		    else
+			dst[j] = brw_null_reg();
+		}
+		get_argument_regs(c, inst, 0, args[0], WRITEMASK_XYZW);
+		emit_ddxy(p, dst, dst_flags, (inst->Opcode == OPCODE_DDX),
+			  args[0]);
                 break;
 	    case OPCODE_SLT:
 		emit_slt(c, inst);
diff --git a/src/mesa/drivers/dri/i965/brw_wm_pass1.c b/src/mesa/drivers/dri/i965/brw_wm_pass1.c
index 9c68bfd78b..b449394029 100644
--- a/src/mesa/drivers/dri/i965/brw_wm_pass1.c
+++ b/src/mesa/drivers/dri/i965/brw_wm_pass1.c
@@ -178,6 +178,11 @@ void brw_wm_pass1( struct brw_wm_compile *c )
 	 read1 = writemask;
 	 break;
 
+      case OPCODE_DDX:
+      case OPCODE_DDY:
+	 read0 = writemask;
+	 break;
+
       case OPCODE_MAD:	
       case OPCODE_CMP:
       case OPCODE_LRP:
diff --git a/src/mesa/drivers/dri/i965/brw_wm_state.c b/src/mesa/drivers/dri/i965/brw_wm_state.c
index 39f8c6d522..361f91292b 100644
--- a/src/mesa/drivers/dri/i965/brw_wm_state.c
+++ b/src/mesa/drivers/dri/i965/brw_wm_state.c
@@ -107,6 +107,12 @@ wm_unit_populate_key(struct brw_context *brw, struct brw_wm_unit_key *key)
    /* as far as we can tell */
    key->computes_depth =
       (fp->Base.OutputsWritten & (1 << FRAG_RESULT_DEPTH)) != 0;
+   /* BRW_NEW_DEPTH_BUFFER
+    * Override for NULL depthbuffer case, required by the Pixel Shader Computed
+    * Depth field.
+    */
+   if (brw->state.depth_region == NULL)
+      key->computes_depth = 0;
 
    /* _NEW_COLOR */
    key->uses_kill = fp->UsesKill || ctx->Color.AlphaEnabled;
@@ -300,6 +306,7 @@ const struct brw_tracked_state brw_wm_unit = {
 
       .brw = (BRW_NEW_FRAGMENT_PROGRAM | 
 	      BRW_NEW_CURBE_OFFSETS |
+	      BRW_NEW_DEPTH_BUFFER |
 	      BRW_NEW_NR_WM_SURFACES),
 
       .cache = (CACHE_NEW_WM_PROG |
diff --git a/src/mesa/drivers/dri/i965/brw_wm_surface_state.c b/src/mesa/drivers/dri/i965/brw_wm_surface_state.c
index 096f74394e..51539ac1e7 100644
--- a/src/mesa/drivers/dri/i965/brw_wm_surface_state.c
+++ b/src/mesa/drivers/dri/i965/brw_wm_surface_state.c
@@ -545,15 +545,20 @@ brw_update_renderbuffer_surface(struct brw_context *brw,
 		       irb->texformat->MesaFormat);
       }
       key.tiling = region->tiling;
-      key.width = region->width;
-      key.height = region->height;
+      if (brw->intel.intelScreen->driScrnPriv->dri2.enabled) {
+	 key.width = rb->Width;
+	 key.height = rb->Height;
+      } else {
+	 key.width = region->width;
+	 key.height = region->height;
+      }
       key.pitch = region->pitch;
       key.cpp = region->cpp;
       key.draw_offset = region->draw_offset; /* cur 3d or cube face offset */
    } else {
       key.surface_type = BRW_SURFACE_NULL;
       key.surface_format = BRW_SURFACEFORMAT_B8G8R8A8_UNORM;
-      key.tiling = 0;
+      key.tiling = I915_TILING_X;
       key.width = 1;
       key.height = 1;
       key.cpp = 4;
@@ -629,7 +634,7 @@ brw_update_renderbuffer_surface(struct brw_context *brw,
 	 drm_intel_bo_emit_reloc(brw->wm.surf_bo[unit],
 				 offsetof(struct brw_surface_state, ss1),
 				 region_bo,
-				 surf.ss1.base_addr,
+				 surf.ss1.base_addr - region_bo->offset,
 				 I915_GEM_DOMAIN_RENDER,
 				 I915_GEM_DOMAIN_RENDER);
       }
diff --git a/src/mesa/drivers/dri/intel/intel_blit.c b/src/mesa/drivers/dri/intel/intel_blit.c
index 0c5be4c798..43141c509c 100644
--- a/src/mesa/drivers/dri/intel/intel_blit.c
+++ b/src/mesa/drivers/dri/intel/intel_blit.c
@@ -26,9 +26,6 @@
  **************************************************************************/
 
 
-#include <stdio.h>
-#include <errno.h>
-
 #include "main/mtypes.h"
 #include "main/context.h"
 #include "main/enums.h"
diff --git a/src/mesa/drivers/dri/intel/intel_chipset.h b/src/mesa/drivers/dri/intel/intel_chipset.h
index 3c38f1676c..3dc8653a73 100644
--- a/src/mesa/drivers/dri/intel/intel_chipset.h
+++ b/src/mesa/drivers/dri/intel/intel_chipset.h
@@ -66,6 +66,7 @@
 #define PCI_CHIP_Q45_G                  0x2E12
 #define PCI_CHIP_G45_G                  0x2E22
 #define PCI_CHIP_G41_G                  0x2E32
+#define PCI_CHIP_B43_G                  0x2E42
 
 #define PCI_CHIP_ILD_G                  0x0042
 #define PCI_CHIP_ILM_G                  0x0046
@@ -83,7 +84,8 @@
 #define IS_G45(devid)           (devid == PCI_CHIP_IGD_E_G || \
                                  devid == PCI_CHIP_Q45_G || \
                                  devid == PCI_CHIP_G45_G || \
-                                 devid == PCI_CHIP_G41_G)
+                                 devid == PCI_CHIP_G41_G || \
+                                 devid == PCI_CHIP_B43_G)
 #define IS_GM45(devid)          (devid == PCI_CHIP_GM45_GM)
 #define IS_G4X(devid)		(IS_G45(devid) || IS_GM45(devid))
 
diff --git a/src/mesa/drivers/dri/intel/intel_clear.c b/src/mesa/drivers/dri/intel/intel_clear.c
index bce23724b3..fef977f465 100644
--- a/src/mesa/drivers/dri/intel/intel_clear.c
+++ b/src/mesa/drivers/dri/intel/intel_clear.c
@@ -38,6 +38,7 @@
 #include "intel_fbo.h"
 #include "intel_pixel.h"
 #include "intel_regions.h"
+#include "intel_batchbuffer.h"
 
 #define FILE_DEBUG_FLAG DEBUG_BLIT
 
@@ -170,7 +171,9 @@ intelClear(GLcontext *ctx, GLbitfield mask)
 	 }
 	 DBG("\n");
       }
-      _mesa_meta_clear(&intel->ctx, tri_mask);
+
+      _mesa_meta_Clear(&intel->ctx, tri_mask);
+      intel_batchbuffer_flush(intel->batch);
    }
 
    if (swrast_mask) {
diff --git a/src/mesa/drivers/dri/intel/intel_context.c b/src/mesa/drivers/dri/intel/intel_context.c
index 89f99f7ffd..d49d95768d 100644
--- a/src/mesa/drivers/dri/intel/intel_context.c
+++ b/src/mesa/drivers/dri/intel/intel_context.c
@@ -162,6 +162,9 @@ intelGetString(GLcontext * ctx, GLenum name)
       case PCI_CHIP_G41_G:
          chipset = "Intel(R) G41";
          break;
+      case PCI_CHIP_B43_G:
+         chipset = "Intel(R) B43";
+         break;
       case PCI_CHIP_ILD_G:
          chipset = "Intel(R) IGDNG_D";
          break;
@@ -504,7 +507,8 @@ intel_flush(GLcontext *ctx, GLboolean needs_mi_flush)
 
       if (screen->dri2.loader &&
           (screen->dri2.loader->base.version >= 2)
-	  && (screen->dri2.loader->flushFrontBuffer != NULL)) {
+	  && (screen->dri2.loader->flushFrontBuffer != NULL) &&
+          intel->driDrawable && intel->driDrawable->loaderPrivate) {
 	 (*screen->dri2.loader->flushFrontBuffer)(intel->driDrawable,
 						  intel->driDrawable->loaderPrivate);
 
@@ -584,11 +588,6 @@ intelInitDriverFunctions(struct dd_function_table *functions)
    functions->GetString = intelGetString;
    functions->UpdateState = intelInvalidateState;
 
-   functions->CopyColorTable = _swrast_CopyColorTable;
-   functions->CopyColorSubTable = _swrast_CopyColorSubTable;
-   functions->CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
-   functions->CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
-
    intelInitTextureFuncs(functions);
    intelInitTextureImageFuncs(functions);
    intelInitTextureSubImageFuncs(functions);
@@ -641,10 +640,6 @@ intelInitContext(struct intel_context *intel,
       intel->maxBatchSize = BATCH_SZ;
 
    intel->bufmgr = intelScreen->bufmgr;
-
-   if (0) /* for debug */
-      drm_intel_bufmgr_set_debug(intel->bufmgr, 1);
-
    intel->ttm = intelScreen->ttm;
    if (intel->ttm) {
       int bo_reuse_mode;
@@ -923,6 +918,14 @@ intelDestroyContext(__DRIcontextPrivate * driContextPriv)
 GLboolean
 intelUnbindContext(__DRIcontextPrivate * driContextPriv)
 {
+   struct intel_context *intel =
+      (struct intel_context *) driContextPriv->driverPrivate;
+
+   /* Deassociate the context with the drawables.
+    */
+   intel->driDrawable = NULL;
+   intel->driReadDrawable = NULL;
+
    return GL_TRUE;
 }
 
diff --git a/src/mesa/drivers/dri/intel/intel_extensions.c b/src/mesa/drivers/dri/intel/intel_extensions.c
index 2e61c556d8..5431cf90a1 100644
--- a/src/mesa/drivers/dri/intel/intel_extensions.c
+++ b/src/mesa/drivers/dri/intel/intel_extensions.c
@@ -31,6 +31,7 @@
 
 
 #define need_GL_ARB_copy_buffer
+#define need_GL_ARB_draw_elements_base_vertex
 #define need_GL_ARB_framebuffer_object
 #define need_GL_ARB_map_buffer_range
 #define need_GL_ARB_occlusion_query
@@ -73,6 +74,7 @@
  */
 static const struct dri_extension card_extensions[] = {
    { "GL_ARB_copy_buffer",                GL_ARB_copy_buffer_functions },
+   { "GL_ARB_draw_elements_base_vertex",  GL_ARB_draw_elements_base_vertex_functions },
    { "GL_ARB_half_float_pixel",           NULL },
    { "GL_ARB_map_buffer_range",           GL_ARB_map_buffer_range_functions },
    { "GL_ARB_multitexture",               NULL },
@@ -139,6 +141,7 @@ static const struct dri_extension i915_extensions[] = {
 
 /** i965-only extensions */
 static const struct dri_extension brw_extensions[] = {
+   { "GL_ARB_depth_clamp",                NULL },
    { "GL_ARB_depth_texture",              NULL },
    { "GL_ARB_fragment_program",           NULL },
    { "GL_ARB_fragment_program_shadow",    NULL },
diff --git a/src/mesa/drivers/dri/intel/intel_fbo.c b/src/mesa/drivers/dri/intel/intel_fbo.c
index 804c034840..8dfb24290d 100644
--- a/src/mesa/drivers/dri/intel/intel_fbo.c
+++ b/src/mesa/drivers/dri/intel/intel_fbo.c
@@ -715,5 +715,5 @@ intel_fbo_init(struct intel_context *intel)
    intel->ctx.Driver.FinishRenderTexture = intel_finish_render_texture;
    intel->ctx.Driver.ResizeBuffers = intel_resize_buffers;
    intel->ctx.Driver.ValidateFramebuffer = intel_validate_framebuffer;
-   intel->ctx.Driver.BlitFramebuffer = _mesa_meta_blit_framebuffer;
+   intel->ctx.Driver.BlitFramebuffer = _mesa_meta_BlitFramebuffer;
 }
diff --git a/src/mesa/drivers/dri/intel/intel_generatemipmap.c b/src/mesa/drivers/dri/intel/intel_generatemipmap.c
index fe986092db..237754d469 100644
--- a/src/mesa/drivers/dri/intel/intel_generatemipmap.c
+++ b/src/mesa/drivers/dri/intel/intel_generatemipmap.c
@@ -223,10 +223,6 @@ fail:
  *
  * The texture object's miptree must be mapped.
  *
- * It would be really nice if this was just called by Mesa whenever mipmaps
- * needed to be regenerated, rather than us having to remember to do so in
- * each texture image modification path.
- *
  * This function should also include an accelerated path.
  */
 void
diff --git a/src/mesa/drivers/dri/intel/intel_pixel_bitmap.c b/src/mesa/drivers/dri/intel/intel_pixel_bitmap.c
index b543a0bbc3..9a0bcc07a5 100644
--- a/src/mesa/drivers/dri/intel/intel_pixel_bitmap.c
+++ b/src/mesa/drivers/dri/intel/intel_pixel_bitmap.c
@@ -209,7 +209,7 @@ do_blit_bitmap( GLcontext *ctx,
    if (!dst)
        return GL_FALSE;
 
-   if (unpack->BufferObj->Name) {
+   if (_mesa_is_bufferobj(unpack->BufferObj)) {
       bitmap = map_pbo(ctx, width, height, unpack, bitmap);
       if (bitmap == NULL)
 	 return GL_TRUE;	/* even though this is an error, we're done */
@@ -329,7 +329,7 @@ out:
    if (INTEL_DEBUG & DEBUG_SYNC)
       intel_batchbuffer_flush(intel->batch);
 
-   if (unpack->BufferObj->Name) {
+   if (_mesa_is_bufferobj(unpack->BufferObj)) {
       /* done with PBO so unmap it now */
       ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
                               unpack->BufferObj);
@@ -418,7 +418,7 @@ intel_texture_bitmap(GLcontext * ctx,
       return GL_FALSE;
    }
 
-   if (unpack->BufferObj->Name) {
+   if (_mesa_is_bufferobj(unpack->BufferObj)) {
       bitmap = map_pbo(ctx, width, height, unpack, bitmap);
       if (bitmap == NULL)
 	 return GL_TRUE;	/* even though this is an error, we're done */
@@ -428,7 +428,7 @@ intel_texture_bitmap(GLcontext * ctx,
    a8_bitmap = _mesa_calloc(width * height);
    _mesa_expand_bitmap(width, height, unpack, bitmap, a8_bitmap, width, 0xff);
 
-   if (unpack->BufferObj->Name) {
+   if (_mesa_is_bufferobj(unpack->BufferObj)) {
       /* done with PBO so unmap it now */
       ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
                               unpack->BufferObj);
diff --git a/src/mesa/drivers/dri/intel/intel_pixel_copy.c b/src/mesa/drivers/dri/intel/intel_pixel_copy.c
index 07ca8f7ddb..f058b3c8e4 100644
--- a/src/mesa/drivers/dri/intel/intel_pixel_copy.c
+++ b/src/mesa/drivers/dri/intel/intel_pixel_copy.c
@@ -240,5 +240,5 @@ intelCopyPixels(GLcontext * ctx,
       return;
 
    /* this will use swrast if needed */
-   _mesa_meta_copy_pixels(ctx, srcx, srcy, width, height, destx, desty, type);
+   _mesa_meta_CopyPixels(ctx, srcx, srcy, width, height, destx, desty, type);
 }
diff --git a/src/mesa/drivers/dri/intel/intel_pixel_draw.c b/src/mesa/drivers/dri/intel/intel_pixel_draw.c
index 8c113881d6..5ffa847fd4 100644
--- a/src/mesa/drivers/dri/intel/intel_pixel_draw.c
+++ b/src/mesa/drivers/dri/intel/intel_pixel_draw.c
@@ -42,6 +42,7 @@
 #include "main/depth.h"
 #include "main/hash.h"
 #include "main/blend.h"
+#include "swrast/swrast.h"
 #include "drivers/common/meta.h"
 
 #include "intel_context.h"
@@ -53,7 +54,7 @@
 #include "intel_fbo.h"
 
 
-/** XXX compare perf of this vs. _mesa_meta_draw_pixels(STENCIL) */
+/** XXX compare perf of this vs. _mesa_meta_DrawPixels(STENCIL) */
 static GLboolean
 intel_stencil_drawpixels(GLcontext * ctx,
 			 GLint x, GLint y,
@@ -260,10 +261,25 @@ intelDrawPixels(GLcontext * ctx,
                 const struct gl_pixelstore_attrib *unpack,
                 const GLvoid * pixels)
 {
+#if 0
+   /* XXX this function doesn't seem to work reliably even when all
+    * the pre-requisite conditions are met.
+    * Note that this function is never hit with conform.
+    * Fall back to swrast because even the _mesa_meta_DrawPixels() approach
+    * isn't working because of an apparent stencil bug.
+    */
    if (intel_stencil_drawpixels(ctx, x, y, width, height, format, type,
 				unpack, pixels))
       return;
+#else
+   (void) intel_stencil_drawpixels; /* silence warning */
+   if (format == GL_STENCIL_INDEX) {
+      _swrast_DrawPixels(ctx, x, y, width, height, format, type,
+                         unpack, pixels);
+      return;
+   }
+#endif
 
-   _mesa_meta_draw_pixels(ctx, x, y, width, height, format, type,
-                          unpack, pixels);
+   _mesa_meta_DrawPixels(ctx, x, y, width, height, format, type,
+                         unpack, pixels);
 }
diff --git a/src/mesa/drivers/dri/intel/intel_pixel_read.c b/src/mesa/drivers/dri/intel/intel_pixel_read.c
index 8713463ace..bc67f6242a 100644
--- a/src/mesa/drivers/dri/intel/intel_pixel_read.c
+++ b/src/mesa/drivers/dri/intel/intel_pixel_read.c
@@ -180,16 +180,7 @@ do_blit_readpixels(GLcontext * ctx,
    if (!src)
       return GL_FALSE;
 
-   if (pack->BufferObj->Name) {
-      /* XXX This validation should be done by core mesa:
-       */
-      if (!_mesa_validate_pbo_access(2, pack, width, height, 1,
-                                     format, type, pixels)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels");
-         return GL_TRUE;
-      }
-   }
-   else {
+   if (!_mesa_is_bufferobj(pack->BufferObj)) {
       /* PBO only for now:
        */
       if (INTEL_DEBUG & DEBUG_PIXEL)
diff --git a/src/mesa/drivers/dri/intel/intel_regions.c b/src/mesa/drivers/dri/intel/intel_regions.c
index 068a3f3379..a86c66a844 100644
--- a/src/mesa/drivers/dri/intel/intel_regions.c
+++ b/src/mesa/drivers/dri/intel/intel_regions.c
@@ -196,6 +196,13 @@ intel_region_alloc(struct intel_context *intel,
    else
       height = ALIGN(height, 2);
 
+   /* If we're untiled, we have to align to 2 rows high because the
+    * data port accesses 2x2 blocks even if the bottom row isn't to be
+    * rendered, so failure to align means we could walk off the end of the
+    * GTT and fault.
+    */
+   height = ALIGN(height, 2);
+
    if (expect_accelerated_upload) {
       buffer = drm_intel_bo_alloc_for_render(intel->bufmgr, "region",
 					     pitch * cpp * height, 64);
diff --git a/src/mesa/drivers/dri/intel/intel_span.c b/src/mesa/drivers/dri/intel/intel_span.c
index 8df4990880..28eabbc005 100644
--- a/src/mesa/drivers/dri/intel/intel_span.c
+++ b/src/mesa/drivers/dri/intel/intel_span.c
@@ -444,23 +444,30 @@ intel_renderbuffer_unmap(struct intel_context *intel,
  * _ColorReadBuffer, _DepthBuffer or _StencilBuffer fields.
  */
 static void
-intel_map_unmap_buffers(struct intel_context *intel, GLboolean map)
+intel_map_unmap_framebuffer(struct intel_context *intel,
+			    struct gl_framebuffer *fb,
+			    GLboolean map)
 {
-   GLcontext *ctx = &intel->ctx;
-   GLuint i, j;
+   GLuint i;
 
    /* color draw buffers */
-   for (j = 0; j < ctx->DrawBuffer->_NumColorDrawBuffers; j++) {
+   for (i = 0; i < fb->_NumColorDrawBuffers; i++) {
       if (map)
-	 intel_renderbuffer_map(intel, ctx->DrawBuffer->_ColorDrawBuffers[j]);
+         intel_renderbuffer_map(intel, fb->_ColorDrawBuffers[i]);
       else
-	 intel_renderbuffer_unmap(intel, ctx->DrawBuffer->_ColorDrawBuffers[j]);
+         intel_renderbuffer_unmap(intel, fb->_ColorDrawBuffers[i]);
    }
 
+   /* color read buffer */
+   if (map)
+      intel_renderbuffer_map(intel, fb->_ColorReadBuffer);
+   else
+      intel_renderbuffer_unmap(intel, fb->_ColorReadBuffer);
+
    /* check for render to textures */
    for (i = 0; i < BUFFER_COUNT; i++) {
       struct gl_renderbuffer_attachment *att =
-         ctx->DrawBuffer->Attachment + i;
+         fb->Attachment + i;
       struct gl_texture_object *tex = att->Texture;
       if (tex) {
          /* render to texture */
@@ -472,34 +479,23 @@ intel_map_unmap_buffers(struct intel_context *intel, GLboolean map)
       }
    }
 
-   /* color read buffers */
-   if (map)
-      intel_renderbuffer_map(intel, ctx->ReadBuffer->_ColorReadBuffer);
-   else
-      intel_renderbuffer_unmap(intel, ctx->ReadBuffer->_ColorReadBuffer);
-
    /* depth buffer (Note wrapper!) */
-   if (ctx->DrawBuffer->_DepthBuffer) {
+   if (fb->_DepthBuffer) {
       if (map)
-	 intel_renderbuffer_map(intel, ctx->DrawBuffer->_DepthBuffer->Wrapped);
+         intel_renderbuffer_map(intel, fb->_DepthBuffer->Wrapped);
       else
-	 intel_renderbuffer_unmap(intel,
-				  ctx->DrawBuffer->_DepthBuffer->Wrapped);
+         intel_renderbuffer_unmap(intel, fb->_DepthBuffer->Wrapped);
    }
 
    /* stencil buffer (Note wrapper!) */
-   if (ctx->DrawBuffer->_StencilBuffer) {
+   if (fb->_StencilBuffer) {
       if (map)
-	 intel_renderbuffer_map(intel,
-				ctx->DrawBuffer->_StencilBuffer->Wrapped);
+         intel_renderbuffer_map(intel, fb->_StencilBuffer->Wrapped);
       else
-	 intel_renderbuffer_unmap(intel,
-				  ctx->DrawBuffer->_StencilBuffer->Wrapped);
+         intel_renderbuffer_unmap(intel, fb->_StencilBuffer->Wrapped);
    }
 }
 
-
-
 /**
  * Prepare for software rendering.  Map current read/draw framebuffers'
  * renderbuffes and all currently bound texture objects.
@@ -522,7 +518,9 @@ intelSpanRenderStart(GLcontext * ctx)
       }
    }
 
-   intel_map_unmap_buffers(intel, GL_TRUE);
+   intel_map_unmap_framebuffer(intel, ctx->DrawBuffer, GL_TRUE);
+   if (ctx->ReadBuffer != ctx->DrawBuffer)
+      intel_map_unmap_framebuffer(intel, ctx->ReadBuffer, GL_TRUE);
 }
 
 /**
@@ -544,7 +542,9 @@ intelSpanRenderFinish(GLcontext * ctx)
       }
    }
 
-   intel_map_unmap_buffers(intel, GL_FALSE);
+   intel_map_unmap_framebuffer(intel, ctx->DrawBuffer, GL_FALSE);
+   if (ctx->ReadBuffer != ctx->DrawBuffer)
+      intel_map_unmap_framebuffer(intel, ctx->ReadBuffer, GL_FALSE);
 
    UNLOCK_HARDWARE(intel);
 }
@@ -711,6 +711,9 @@ intel_set_span_functions(struct intel_context *intel,
 	    intel_YTile_InitStencilPointers_z24_s8(rb);
 	    break;
 	 }
+      } else {
+	 _mesa_problem(NULL,
+		       "Unexpected ActualFormat in intelSetSpanFunctions");
       }
       break;
    default:
diff --git a/src/mesa/drivers/dri/intel/intel_tex_copy.c b/src/mesa/drivers/dri/intel/intel_tex_copy.c
index 028b49c14d..ac557a9200 100644
--- a/src/mesa/drivers/dri/intel/intel_tex_copy.c
+++ b/src/mesa/drivers/dri/intel/intel_tex_copy.c
@@ -30,7 +30,8 @@
 #include "main/image.h"
 #include "main/teximage.h"
 #include "main/mipmap.h"
-#include "swrast/swrast.h"
+
+#include "drivers/common/meta.h"
 
 #include "intel_screen.h"
 #include "intel_context.h"
@@ -90,7 +91,6 @@ do_copy_texsubimage(struct intel_context *intel,
                     GLint x, GLint y, GLsizei width, GLsizei height)
 {
    GLcontext *ctx = &intel->ctx;
-   struct gl_texture_object *texObj = intelImage->base.TexObject;
    const struct intel_region *src =
       get_teximage_source(intel, internalFormat);
 
@@ -170,11 +170,6 @@ do_copy_texsubimage(struct intel_context *intel,
 
    UNLOCK_HARDWARE(intel);
 
-   /* GL_SGIS_generate_mipmap */
-   if (intelImage->level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      intel_generate_mipmap(ctx, target, texObj);
-   }
-
    return GL_TRUE;
 }
 
@@ -221,8 +216,8 @@ intelCopyTexImage1D(GLcontext * ctx, GLenum target, GLint level,
    return;
 
  fail:
-   _swrast_copy_teximage1d(ctx, target, level, internalFormat, x, y,
-                           width, border);
+   _mesa_meta_CopyTexImage1D(ctx, target, level, internalFormat, x, y,
+                             width, border);
 }
 
 
@@ -269,8 +264,8 @@ intelCopyTexImage2D(GLcontext * ctx, GLenum target, GLint level,
    return;
 
  fail:
-   _swrast_copy_teximage2d(ctx, target, level, internalFormat, x, y,
-                           width, height, border);
+   _mesa_meta_CopyTexImage2D(ctx, target, level, internalFormat, x, y,
+                             width, height, border);
 }
 
 
@@ -294,7 +289,7 @@ intelCopyTexSubImage1D(GLcontext * ctx, GLenum target, GLint level,
    if (!do_copy_texsubimage(intel_context(ctx), target,
                             intel_texture_image(texImage),
                             internalFormat, xoffset, 0, x, y, width, 1)) {
-      _swrast_copy_texsubimage1d(ctx, target, level, xoffset, x, y, width);
+      _mesa_meta_CopyTexSubImage1D(ctx, target, level, xoffset, x, y, width);
    }
 }
 
@@ -320,10 +315,10 @@ intelCopyTexSubImage2D(GLcontext * ctx, GLenum target, GLint level,
                             internalFormat,
                             xoffset, yoffset, x, y, width, height)) {
 
-      DBG("%s - fallback to swrast\n", __FUNCTION__);
+      DBG("%s - fallback to _mesa_meta_CopyTexSubImage2D\n", __FUNCTION__);
 
-      _swrast_copy_texsubimage2d(ctx, target, level,
-                                 xoffset, yoffset, x, y, width, height);
+      _mesa_meta_CopyTexSubImage2D(ctx, target, level,
+                                   xoffset, yoffset, x, y, width, height);
    }
 }
 
diff --git a/src/mesa/drivers/dri/intel/intel_tex_image.c b/src/mesa/drivers/dri/intel/intel_tex_image.c
index c5f5220837..66201b1f46 100644
--- a/src/mesa/drivers/dri/intel/intel_tex_image.c
+++ b/src/mesa/drivers/dri/intel/intel_tex_image.c
@@ -1,15 +1,11 @@
 
-#include <stdlib.h>
-#include <stdio.h>
-
 #include "main/glheader.h"
 #include "main/macros.h"
 #include "main/mtypes.h"
 #include "main/enums.h"
-#include "main/colortab.h"
+#include "main/bufferobj.h"
 #include "main/convolve.h"
 #include "main/context.h"
-#include "main/simple_list.h"
 #include "main/texcompress.h"
 #include "main/texformat.h"
 #include "main/texgetimage.h"
@@ -206,7 +202,7 @@ try_pbo_upload(struct intel_context *intel,
    GLuint src_offset, src_stride;
    GLuint dst_offset, dst_stride;
 
-   if (unpack->BufferObj->Name == 0 ||
+   if (!_mesa_is_bufferobj(unpack->BufferObj) ||
        intel->ctx._ImageTransferState ||
        unpack->SkipPixels || unpack->SkipRows) {
       DBG("%s: failure 1\n", __FUNCTION__);
@@ -264,7 +260,7 @@ try_pbo_zcopy(struct intel_context *intel,
    GLuint src_offset, src_stride;
    GLuint dst_offset, dst_stride;
 
-   if (unpack->BufferObj->Name == 0 ||
+   if (!_mesa_is_bufferobj(unpack->BufferObj) ||
        intel->ctx._ImageTransferState ||
        unpack->SkipPixels || unpack->SkipRows) {
       DBG("%s: failure 1\n", __FUNCTION__);
@@ -427,7 +423,7 @@ intelTexImage(GLcontext * ctx,
     */
    if (dims <= 2 &&
        intelImage->mt &&
-       unpack->BufferObj->Name != 0 &&
+       _mesa_is_bufferobj(unpack->BufferObj) &&
        check_pbo_format(internalFormat, format,
                         type, intelImage->base.TexFormat)) {
 
@@ -550,11 +546,6 @@ intelTexImage(GLcontext * ctx,
    }
 
    UNLOCK_HARDWARE(intel);
-
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      intel_generate_mipmap(ctx, target, texObj);
-   }
 }
 
 
diff --git a/src/mesa/drivers/dri/intel/intel_tex_subimage.c b/src/mesa/drivers/dri/intel/intel_tex_subimage.c
index 89037073f8..751ec2c98c 100644
--- a/src/mesa/drivers/dri/intel/intel_tex_subimage.c
+++ b/src/mesa/drivers/dri/intel/intel_tex_subimage.c
@@ -129,11 +129,6 @@ intelTexSubimage(GLcontext * ctx,
    }
 
    UNLOCK_HARDWARE(intel);
-
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      intel_generate_mipmap(ctx, target, texObj);
-   }
 }
 
 
diff --git a/src/mesa/drivers/dri/r200/Makefile b/src/mesa/drivers/dri/r200/Makefile
index 42635bf9d9..fbce70c37b 100644
--- a/src/mesa/drivers/dri/r200/Makefile
+++ b/src/mesa/drivers/dri/r200/Makefile
@@ -55,8 +55,7 @@ C_SOURCES = $(COMMON_SOURCES) $(DRIVER_SOURCES)
 
 X86_SOURCES = 
 
-DRIVER_DEFINES = -DRADEON_COMMON=1 -DRADEON_COMMON_FOR_R200 \
-				 -Wall
+DRIVER_DEFINES = -DRADEON_R200 -Wall
 
 DRI_LIB_DEPS += $(RADEON_LDFLAGS)
 
diff --git a/src/mesa/drivers/dri/r300/Makefile b/src/mesa/drivers/dri/r300/Makefile
index 06c31ce7f2..c64f940623 100644
--- a/src/mesa/drivers/dri/r300/Makefile
+++ b/src/mesa/drivers/dri/r300/Makefile
@@ -63,8 +63,7 @@ DRIVER_SOURCES = \
 
 C_SOURCES = $(COMMON_SOURCES) $(DRIVER_SOURCES)
 
-DRIVER_DEFINES = -DCOMPILE_R300 -DR200_MERGED=0 \
-	-DRADEON_COMMON=1 -DRADEON_COMMON_FOR_R300 \
+DRIVER_DEFINES = -DRADEON_R300
 #	-DRADEON_BO_TRACK \
 	-Wall
 
diff --git a/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c b/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c
index 58953f6b04..2dad3dba4a 100644
--- a/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c
+++ b/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c
@@ -352,7 +352,7 @@ void r300BuildFragmentProgramHwCode(struct r300_fragment_program_compiler *compi
 	if (emit.current_node < 3) {
 		int shift = 3 - emit.current_node;
 		int i;
-		for(i = 0; i <= emit.current_node; ++i)
+		for(i = emit.current_node; i >= 0; --i)
 			code->code_addr[shift + i] = code->code_addr[i];
 		for(i = 0; i < shift; ++i)
 			code->code_addr[i] = 0;
diff --git a/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog.c b/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog.c
index c64648ff3b..ac72f8cbb6 100644
--- a/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog.c
+++ b/src/mesa/drivers/dri/r300/compiler/r3xx_vertprog.c
@@ -81,6 +81,7 @@ static unsigned long t_src_class(rc_register_file file)
 	default:
 		fprintf(stderr, "%s: Bad register file %i\n", __FUNCTION__, file);
 		/* fall-through */
+	case RC_FILE_NONE:
 	case RC_FILE_TEMPORARY:
 		return PVS_SRC_REG_TEMPORARY;
 	case RC_FILE_INPUT:
diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_program_alu.c b/src/mesa/drivers/dri/r300/compiler/radeon_program_alu.c
index 041e3cab82..e25bc4ec87 100644
--- a/src/mesa/drivers/dri/r300/compiler/radeon_program_alu.c
+++ b/src/mesa/drivers/dri/r300/compiler/radeon_program_alu.c
@@ -500,23 +500,23 @@ static void sincos_constants(struct radeon_compiler* c, unsigned int *constants)
  * MAD dest, tmp.y, weight, tmp.x
  */
 static void sin_approx(
-	struct radeon_compiler* c, struct rc_instruction * after,
+	struct radeon_compiler* c, struct rc_instruction * before,
 	struct rc_dst_register dst, struct rc_src_register src, const unsigned int* constants)
 {
 	unsigned int tempreg = rc_find_free_temporary(c);
 
-	emit2(c, after->Prev, RC_OPCODE_MUL, 0, dstregtmpmask(tempreg, RC_MASK_XY),
+	emit2(c, before, RC_OPCODE_MUL, 0, dstregtmpmask(tempreg, RC_MASK_XY),
 		swizzle(src, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X),
 		srcreg(RC_FILE_CONSTANT, constants[0]));
-	emit3(c, after->Prev, RC_OPCODE_MAD, 0, dstregtmpmask(tempreg, RC_MASK_X),
+	emit3(c, before, RC_OPCODE_MAD, 0, dstregtmpmask(tempreg, RC_MASK_X),
 		swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_Y, RC_SWIZZLE_Y, RC_SWIZZLE_Y, RC_SWIZZLE_Y),
 		absolute(swizzle(src, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X)),
 		swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X));
-	emit3(c, after->Prev, RC_OPCODE_MAD, 0, dstregtmpmask(tempreg, RC_MASK_Y),
+	emit3(c, before, RC_OPCODE_MAD, 0, dstregtmpmask(tempreg, RC_MASK_Y),
 		swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X),
 		absolute(swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X)),
 		negate(swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X)));
-	emit3(c, after->Prev, RC_OPCODE_MAD, 0, dst,
+	emit3(c, before, RC_OPCODE_MAD, 0, dst,
 		swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_Y, RC_SWIZZLE_Y, RC_SWIZZLE_Y, RC_SWIZZLE_Y),
 		swizzle(srcreg(RC_FILE_CONSTANT, constants[0]), RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W),
 		swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X));
@@ -556,7 +556,7 @@ int radeonTransformTrigSimple(struct radeon_compiler* c,
 			swizzle(srcreg(RC_FILE_CONSTANT, constants[1]), RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W),
 			negate(swizzle(srcreg(RC_FILE_CONSTANT, constants[0]), RC_SWIZZLE_Z, RC_SWIZZLE_Z, RC_SWIZZLE_Z, RC_SWIZZLE_Z)));
 
-		sin_approx(c, inst->Prev, inst->I.DstReg,
+		sin_approx(c, inst, inst->I.DstReg,
 			swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W),
 			constants);
 	} else if (inst->I.Opcode == RC_OPCODE_SIN) {
@@ -571,7 +571,7 @@ int radeonTransformTrigSimple(struct radeon_compiler* c,
 			swizzle(srcreg(RC_FILE_CONSTANT, constants[1]), RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W),
 			negate(swizzle(srcreg(RC_FILE_CONSTANT, constants[0]), RC_SWIZZLE_Z, RC_SWIZZLE_Z, RC_SWIZZLE_Z, RC_SWIZZLE_Z)));
 
-		sin_approx(c, inst->Prev, inst->I.DstReg,
+		sin_approx(c, inst, inst->I.DstReg,
 			swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W, RC_SWIZZLE_W),
 			constants);
 	} else {
@@ -589,12 +589,12 @@ int radeonTransformTrigSimple(struct radeon_compiler* c,
 		struct rc_dst_register dst = inst->I.DstReg;
 
 		dst.WriteMask = inst->I.DstReg.WriteMask & RC_MASK_X;
-		sin_approx(c, inst->Prev, dst,
+		sin_approx(c, inst, dst,
 			swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X, RC_SWIZZLE_X),
 			constants);
 
 		dst.WriteMask = inst->I.DstReg.WriteMask & RC_MASK_Y;
-		sin_approx(c, inst->Prev, dst,
+		sin_approx(c, inst, dst,
 			swizzle(srcreg(RC_FILE_TEMPORARY, tempreg), RC_SWIZZLE_Y, RC_SWIZZLE_Y, RC_SWIZZLE_Y, RC_SWIZZLE_Y),
 			constants);
 	}
diff --git a/src/mesa/drivers/dri/r300/r300_cmdbuf.c b/src/mesa/drivers/dri/r300/r300_cmdbuf.c
index 0fe32a5443..da5b7ba642 100644
--- a/src/mesa/drivers/dri/r300/r300_cmdbuf.c
+++ b/src/mesa/drivers/dri/r300/r300_cmdbuf.c
@@ -684,11 +684,7 @@ void r300InitCmdBuf(r300ContextPtr r300)
 	r300->hw.rb3d_dither_ctl.cmd[0] = cmdpacket0(r300->radeon.radeonScreen, R300_RB3D_DITHER_CTL, 9);
 	ALLOC_STATE(rb3d_aaresolve_ctl, always, 2, 0);
 	r300->hw.rb3d_aaresolve_ctl.cmd[0] = cmdpacket0(r300->radeon.radeonScreen, R300_RB3D_AARESOLVE_CTL, 1);
-	if ((r300->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) ||
-	      ( !r300->radeon.radeonScreen->kernel_mm && (
-	    (r300->radeon.radeonScreen->chip_family == CHIP_FAMILY_RS400) ||
-	    (r300->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV410) ||
-	    (r300->radeon.radeonScreen->chip_family == CHIP_FAMILY_R420) ) ) ) {
+	if (r300->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV350) {
 		ALLOC_STATE(rb3d_discard_src_pixel_lte_threshold, always, 3, 0);
 	} else {
 		ALLOC_STATE(rb3d_discard_src_pixel_lte_threshold, never, 3, 0);
@@ -697,6 +693,14 @@ void r300InitCmdBuf(r300ContextPtr r300)
 	ALLOC_STATE(zs, always, R300_ZS_CMDSIZE, 0);
 	r300->hw.zs.cmd[R300_ZS_CMD_0] =
 	    cmdpacket0(r300->radeon.radeonScreen, R300_ZB_CNTL, 3);
+	if (is_r500) {
+		if (r300->radeon.radeonScreen->kernel_mm)
+			ALLOC_STATE(zsb, always, R300_ZSB_CMDSIZE, 0);
+		else
+			ALLOC_STATE(zsb, never, R300_ZSB_CMDSIZE, 0);
+		r300->hw.zsb.cmd[R300_ZSB_CMD_0] =
+			cmdpacket0(r300->radeon.radeonScreen, R500_ZB_STENCILREFMASK_BF, 1);
+	}
 
 	ALLOC_STATE(zstencil_format, always, 5, 0);
 	r300->hw.zstencil_format.cmd[0] =
diff --git a/src/mesa/drivers/dri/r300/r300_context.h b/src/mesa/drivers/dri/r300/r300_context.h
index 1dadcc0a69..518d5cdbf4 100644
--- a/src/mesa/drivers/dri/r300/r300_context.h
+++ b/src/mesa/drivers/dri/r300/r300_context.h
@@ -234,6 +234,10 @@ typedef struct r300_context *r300ContextPtr;
 #define R300_ZS_CNTL_2		3
 #define R300_ZS_CMDSIZE		4
 
+#define R300_ZSB_CMD_0		0
+#define R300_ZSB_CNTL_0		1
+#define R300_ZSB_CMDSIZE	2
+
 #define R300_ZB_CMD_0		0
 #define R300_ZB_OFFSET		1
 #define R300_ZB_PITCH		2
@@ -343,6 +347,7 @@ struct r300_hw_state {
 	struct radeon_state_atom rb3d_aaresolve_ctl;	/* (4E88) */
 	struct radeon_state_atom rb3d_discard_src_pixel_lte_threshold;	/* (4E88) I saw it only written on RV350 hardware..  */
 	struct radeon_state_atom zs;	/* zstencil control (4F00) */
+	struct radeon_state_atom zsb;	/* zstencil bf */
 	struct radeon_state_atom zstencil_format;
 	struct radeon_state_atom zb;	/* z buffer (4F20) */
 	struct radeon_state_atom zb_depthclearvalue;	/* (4F28) */
diff --git a/src/mesa/drivers/dri/r300/r300_reg.h b/src/mesa/drivers/dri/r300/r300_reg.h
index 98512d778e..b9ccd098dc 100644
--- a/src/mesa/drivers/dri/r300/r300_reg.h
+++ b/src/mesa/drivers/dri/r300/r300_reg.h
@@ -2313,6 +2313,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #	define R300_Z_WRITE_ENABLE		 (1 << 2)
 #	define R300_Z_SIGNED_COMPARE		 (1 << 3)
 #	define R300_STENCIL_FRONT_BACK		 (1 << 4)
+#	define R400_ZSIGNED_MAGNITUDE		 (1 << 5)
+#	define R500_STENCIL_REFMASK_FRONT_BACK	 (1 << 6)
 
 #define R300_ZB_ZSTENCILCNTL                   0x4f04
 	/* functions */
diff --git a/src/mesa/drivers/dri/r300/r300_state.c b/src/mesa/drivers/dri/r300/r300_state.c
index d4c3ecee66..3060f49aaf 100644
--- a/src/mesa/drivers/dri/r300/r300_state.c
+++ b/src/mesa/drivers/dri/r300/r300_state.c
@@ -590,7 +590,9 @@ static void r300SetDepthState(GLcontext * ctx)
 	r300ContextPtr r300 = R300_CONTEXT(ctx);
 
 	R300_STATECHANGE(r300, zs);
-	r300->hw.zs.cmd[R300_ZS_CNTL_0] &= R300_STENCIL_ENABLE|R300_STENCIL_FRONT_BACK;
+	r300->hw.zs.cmd[R300_ZS_CNTL_0] &= (R300_STENCIL_ENABLE |
+					    R300_STENCIL_FRONT_BACK |
+					    R500_STENCIL_REFMASK_FRONT_BACK);
 	r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_Z_FUNC_SHIFT);
 
 	if (ctx->Depth.Test) {
@@ -604,11 +606,16 @@ static void r300SetDepthState(GLcontext * ctx)
 
 static void r300CatchStencilFallback(GLcontext *ctx)
 {
+	r300ContextPtr rmesa = R300_CONTEXT(ctx);
 	const unsigned back = ctx->Stencil._BackFace;
 
-	if (ctx->Stencil._Enabled && (ctx->Stencil.Ref[0] != ctx->Stencil.Ref[back]
-		|| ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[back]
-		|| ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[back])) {
+	if (rmesa->radeon.radeonScreen->kernel_mm &&
+	    (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)) {
+		r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_FALSE);
+	} else if (ctx->Stencil._Enabled &&
+		   (ctx->Stencil.Ref[0] != ctx->Stencil.Ref[back]
+		    || ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[back]
+		    || ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[back])) {
 		r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_TRUE);
 	} else {
 		r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_FALSE);
@@ -915,11 +922,24 @@ static void r300StencilFuncSeparate(GLcontext * ctx, GLenum face,
 	rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
 	    (flag << R300_S_BACK_FUNC_SHIFT);
 	rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
+
+	if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
+		rmesa->hw.zs.cmd[R300_ZS_CNTL_0] |= R500_STENCIL_REFMASK_FRONT_BACK;
+		R300_STATECHANGE(rmesa, zsb);
+		refmask = ((ctx->Stencil.Ref[back] & 0xff) << R300_STENCILREF_SHIFT)
+			| ((ctx->Stencil.ValueMask[back] & 0xff) << R300_STENCILMASK_SHIFT);
+
+		rmesa->hw.zsb.cmd[R300_ZSB_CNTL_0] &=
+			~((R300_STENCILREF_MASK << R300_STENCILREF_SHIFT) |
+			  (R300_STENCILREF_MASK << R300_STENCILMASK_SHIFT));
+		rmesa->hw.zsb.cmd[R300_ZSB_CNTL_0] |= refmask;
+	}
 }
 
 static void r300StencilMaskSeparate(GLcontext * ctx, GLenum face, GLuint mask)
 {
 	r300ContextPtr rmesa = R300_CONTEXT(ctx);
+	const unsigned back = ctx->Stencil._BackFace;
 
 	r300CatchStencilFallback(ctx);
 
@@ -931,6 +951,13 @@ static void r300StencilMaskSeparate(GLcontext * ctx, GLenum face, GLuint mask)
 	    (ctx->Stencil.
 	     WriteMask[0] & R300_STENCILREF_MASK) <<
 	     R300_STENCILWRITEMASK_SHIFT;
+	if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
+		R300_STATECHANGE(rmesa, zsb);
+		rmesa->hw.zsb.cmd[R300_ZSB_CNTL_0] |=
+			(ctx->Stencil.
+			 WriteMask[back] & R300_STENCILREF_MASK) <<
+			R300_STENCILWRITEMASK_SHIFT;
+	}
 }
 
 static void r300StencilOpSeparate(GLcontext * ctx, GLenum face,
diff --git a/src/mesa/drivers/dri/r300/r300_vertprog.c b/src/mesa/drivers/dri/r300/r300_vertprog.c
index d5e2cf9b14..8ad75fb5c0 100644
--- a/src/mesa/drivers/dri/r300/r300_vertprog.c
+++ b/src/mesa/drivers/dri/r300/r300_vertprog.c
@@ -203,6 +203,34 @@ static void t_inputs_outputs(struct r300_vertex_program_compiler * c)
 	}
 }
 
+/**
+ * The NV_vertex_program spec mandates that all registers be
+ * initialized to zero. We do this here unconditionally.
+ *
+ * \note We rely on dead-code elimination in the compiler.
+ */
+static void initialize_NV_registers(struct radeon_compiler * compiler)
+{
+	unsigned int reg;
+	struct rc_instruction * inst;
+
+	for(reg = 0; reg < 12; ++reg) {
+		inst = rc_insert_new_instruction(compiler, &compiler->Program.Instructions);
+		inst->I.Opcode = RC_OPCODE_MOV;
+		inst->I.DstReg.File = RC_FILE_TEMPORARY;
+		inst->I.DstReg.Index = reg;
+		inst->I.SrcReg[0].File = RC_FILE_NONE;
+		inst->I.SrcReg[0].Swizzle = RC_SWIZZLE_0000;
+	}
+
+	inst = rc_insert_new_instruction(compiler, &compiler->Program.Instructions);
+	inst->I.Opcode = RC_OPCODE_ARL;
+	inst->I.DstReg.File = RC_FILE_ADDRESS;
+	inst->I.DstReg.Index = 0;
+	inst->I.DstReg.WriteMask = WRITEMASK_X;
+	inst->I.SrcReg[0].File = RC_FILE_NONE;
+	inst->I.SrcReg[0].Swizzle = RC_SWIZZLE_0000;
+}
 
 static struct r300_vertex_program *build_program(GLcontext *ctx,
 						 struct r300_vertex_program_key *wanted_key,
@@ -234,6 +262,9 @@ static struct r300_vertex_program *build_program(GLcontext *ctx,
 
 	radeon_mesa_to_rc_program(&compiler.Base, &vp->Base->Base);
 
+	if (mesa_vp->IsNVProgram)
+		initialize_NV_registers(&compiler.Base);
+
 	rc_move_output(&compiler.Base, VERT_RESULT_PSIZ, VERT_RESULT_PSIZ, WRITEMASK_X);
 
 	if (vp->key.WPosAttr != FRAG_ATTRIB_MAX) {
diff --git a/src/mesa/drivers/dri/r300/radeon_context.h b/src/mesa/drivers/dri/r300/radeon_context.h
index 250570f6b8..da4812d323 100644
--- a/src/mesa/drivers/dri/r300/radeon_context.h
+++ b/src/mesa/drivers/dri/r300/radeon_context.h
@@ -51,26 +51,12 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "radeon_screen.h"
 
-#if R200_MERGED
-extern void radeonFallback(GLcontext * ctx, GLuint bit, GLboolean mode);
-
-#define FALLBACK( radeon, bit, mode ) do {			\
-   if ( 0 ) fprintf( stderr, "FALLBACK in %s: #%d=%d\n",	\
-		     __FUNCTION__, bit, mode );			\
-   radeonFallback( (radeon)->glCtx, bit, mode );		\
-} while (0)
-#else
 #define FALLBACK( radeon, bit, mode ) fprintf(stderr, "%s:%s\n", __LINE__, __FILE__);
-#endif
 
 /* TCL fallbacks */
 extern void radeonTclFallback(GLcontext * ctx, GLuint bit, GLboolean mode);
 
-#if R200_MERGED
-#define TCL_FALLBACK( ctx, bit, mode )	radeonTclFallback( ctx, bit, mode )
-#else
 #define TCL_FALLBACK( ctx, bit, mode )	;
-#endif
 
 
 #endif				/* __RADEON_CONTEXT_H__ */
diff --git a/src/mesa/drivers/dri/r300/radeon_mesa_to_rc.c b/src/mesa/drivers/dri/r300/radeon_mesa_to_rc.c
index 1e8fc3de4e..fb9bb9ce91 100644
--- a/src/mesa/drivers/dri/r300/radeon_mesa_to_rc.c
+++ b/src/mesa/drivers/dri/r300/radeon_mesa_to_rc.c
@@ -94,7 +94,6 @@ static rc_saturate_mode translate_saturate(unsigned int saturate)
 	default:
 	case SATURATE_OFF: return RC_SATURATE_NONE;
 	case SATURATE_ZERO_ONE: return RC_SATURATE_ZERO_ONE;
-	case SATURATE_PLUS_MINUS_ONE: return RC_SATURATE_MINUS_PLUS_ONE;
 	}
 }
 
@@ -189,13 +188,36 @@ void radeon_mesa_to_rc_program(struct radeon_compiler * c, struct gl_program * p
 	c->Program.InputsRead = program->InputsRead;
 	c->Program.OutputsWritten = program->OutputsWritten;
 
-	for(i = 0; i < program->Parameters->NumParameters; ++i) {
-		struct rc_constant constant;
+	int isNVProgram = 0;
 
-		constant.Type = RC_CONSTANT_EXTERNAL;
-		constant.Size = 4;
-		constant.u.External = i;
+	if (program->Target == GL_VERTEX_PROGRAM_ARB) {
+		struct gl_vertex_program * vp = (struct gl_vertex_program *) program;
+		isNVProgram = vp->IsNVProgram;
+	}
 
-		rc_constants_add(&c->Program.Constants, &constant);
+	if (isNVProgram) {
+		/* NV_vertex_program has a fixed-sized constant environment.
+		 * This could be handled more efficiently for programs that
+		 * do not use relative addressing.
+		 */
+		for(i = 0; i < 96; ++i) {
+			struct rc_constant constant;
+
+			constant.Type = RC_CONSTANT_EXTERNAL;
+			constant.Size = 4;
+			constant.u.External = i;
+
+			rc_constants_add(&c->Program.Constants, &constant);
+		}
+	} else {
+		for(i = 0; i < program->Parameters->NumParameters; ++i) {
+			struct rc_constant constant;
+
+			constant.Type = RC_CONSTANT_EXTERNAL;
+			constant.Size = 4;
+			constant.u.External = i;
+
+			rc_constants_add(&c->Program.Constants, &constant);
+		}
 	}
 }
diff --git a/src/mesa/drivers/dri/r600/Makefile b/src/mesa/drivers/dri/r600/Makefile
index d925a2dfe3..36bf773c05 100644
--- a/src/mesa/drivers/dri/r600/Makefile
+++ b/src/mesa/drivers/dri/r600/Makefile
@@ -65,8 +65,7 @@ DRIVER_SOURCES = \
 
 C_SOURCES = $(COMMON_SOURCES) $(DRIVER_SOURCES)
 
-DRIVER_DEFINES = -DCOMPILE_R600 -DR200_MERGED=0 \
-	-DRADEON_COMMON=1 -DRADEON_COMMON_FOR_R600 \
+DRIVER_DEFINES = -DRADEON_R600 \
 #	-DRADEON_BO_TRACK \
 	-Wall
 
diff --git a/src/mesa/drivers/dri/r600/r600_context.c b/src/mesa/drivers/dri/r600/r600_context.c
index 07a7bcf11f..f8fd9c13d7 100644
--- a/src/mesa/drivers/dri/r600/r600_context.c
+++ b/src/mesa/drivers/dri/r600/r600_context.c
@@ -385,9 +385,6 @@ GLboolean r600CreateContext(const __GLcontextModes * glVisual,
 
 	if (driQueryOptionb(&r600->radeon.optionCache, "no_rast")) {
 		radeon_warning("disabling 3D acceleration\n");
-#if R200_MERGED
-		FALLBACK(&r600->radeon, RADEON_FALLBACK_DISABLE, 1);
-#endif
 	}
 
 	return GL_TRUE;
diff --git a/src/mesa/drivers/dri/r600/r600_context.h b/src/mesa/drivers/dri/r600/r600_context.h
index 8ae05a301c..c59df7505a 100644
--- a/src/mesa/drivers/dri/r600/r600_context.h
+++ b/src/mesa/drivers/dri/r600/r600_context.h
@@ -51,6 +51,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "r700_chip.h"
 #include "r600_tex.h"
 #include "r700_oglprog.h"
+#include "r700_vertprog.h"
 
 struct r600_context;
 typedef struct r600_context context_t;
@@ -155,6 +156,8 @@ struct r600_context {
 
 	struct r600_hw_state atoms;
 
+	struct r700_vertex_program *selected_vp;
+
 	/* Vertex buffers
 	 */
 	GLvector4f dummy_attrib[_TNL_ATTRIB_MAX];
diff --git a/src/mesa/drivers/dri/r600/r600_reg_auto_r6xx.h b/src/mesa/drivers/dri/r600/r600_reg_auto_r6xx.h
index 9d5aa3c7e4..edd85b0fac 100644
--- a/src/mesa/drivers/dri/r600/r600_reg_auto_r6xx.h
+++ b/src/mesa/drivers/dri/r600/r600_reg_auto_r6xx.h
@@ -1366,6 +1366,7 @@ enum {
 	DB_DEPTH_INFO__READ_SIZE_bit                      = 1 << 3,
 	DB_DEPTH_INFO__ARRAY_MODE_mask                    = 0x0f << 15,
 	DB_DEPTH_INFO__ARRAY_MODE_shift                   = 15,
+	    ARRAY_1D_TILED_THIN1                          = 0x02,
 	    ARRAY_2D_TILED_THIN1                          = 0x04,
 	TILE_SURFACE_ENABLE_bit                           = 1 << 25,
 	TILE_COMPACT_bit                                  = 1 << 26,
@@ -1449,6 +1450,7 @@ enum {
 	CB_COLOR0_INFO__ARRAY_MODE_shift                  = 8,
 	    ARRAY_LINEAR_GENERAL                          = 0x00,
 	    ARRAY_LINEAR_ALIGNED                          = 0x01,
+/*	    ARRAY_1D_TILED_THIN1                          = 0x02, */
 /* 	    ARRAY_2D_TILED_THIN1                          = 0x04, */
 	NUMBER_TYPE_mask                                  = 0x07 << 12,
 	NUMBER_TYPE_shift                                 = 12,
diff --git a/src/mesa/drivers/dri/r600/r600_texstate.c b/src/mesa/drivers/dri/r600/r600_texstate.c
index fff6e74386..7d7e77d355 100644
--- a/src/mesa/drivers/dri/r600/r600_texstate.c
+++ b/src/mesa/drivers/dri/r600/r600_texstate.c
@@ -69,7 +69,7 @@ void r600UpdateTextureState(GLcontext * ctx)
 	for (unit = 0; unit < R700_MAX_TEXTURE_UNITS; unit++) {
 		texUnit = &ctx->Texture.Unit[unit];
 		t = radeon_tex_obj(ctx->Texture.Unit[unit]._Current);
-
+		r700->textures[unit] = NULL;
 		if (texUnit->_ReallyEnabled) {
 			if (!t)
 				continue;
@@ -608,6 +608,11 @@ static void setup_hardware_state(context_t *rmesa, struct gl_texture_object *tex
 	int firstlevel = t->mt ? t->mt->firstLevel : 0;
 	GLuint uTexelPitch, row_align;
 
+	if (rmesa->radeon.radeonScreen->driScreen->dri2.enabled &&
+	    t->image_override &&
+	    t->bo)
+		return;
+
 	firstImage = t->base.Image[0][firstlevel];
 
 	if (!t->image_override) {
diff --git a/src/mesa/drivers/dri/r600/r700_assembler.c b/src/mesa/drivers/dri/r600/r700_assembler.c
index 2d8480daaf..efeccb25f1 100644
--- a/src/mesa/drivers/dri/r600/r700_assembler.c
+++ b/src/mesa/drivers/dri/r600/r700_assembler.c
@@ -1149,41 +1149,49 @@ GLboolean tex_dst(r700_AssemblerBase *pAsm)
 GLboolean tex_src(r700_AssemblerBase *pAsm)
 {
     struct prog_instruction *pILInst = &(pAsm->pILInst[pAsm->uiCurInst]);
- 
+
     GLboolean bValidTexCoord = GL_FALSE;
 
-    switch (pILInst->SrcReg[0].File)
-    {
+    switch (pILInst->SrcReg[0].File) {
+    case PROGRAM_CONSTANT:
+    case PROGRAM_LOCAL_PARAM:
+    case PROGRAM_ENV_PARAM:
+    case PROGRAM_STATE_VAR:
+	    bValidTexCoord = GL_TRUE;
+	    setaddrmode_PVSSRC(&(pAsm->S[0].src), ADDR_ABSOLUTE);
+	    pAsm->S[0].src.rtype = SRC_REG_TEMPORARY;
+	    pAsm->S[0].src.reg   = pAsm->aArgSubst[1];
+	    break;
     case PROGRAM_TEMPORARY:
-        bValidTexCoord = GL_TRUE;
-
-        pAsm->S[0].src.reg   = pILInst->SrcReg[0].Index + pAsm->starting_temp_register_number;
-        pAsm->S[0].src.rtype = SRC_REG_TEMPORARY;
-
-        break;
+	    bValidTexCoord = GL_TRUE;
+	    pAsm->S[0].src.reg   = pILInst->SrcReg[0].Index +
+		    pAsm->starting_temp_register_number;
+	    pAsm->S[0].src.rtype = SRC_REG_TEMPORARY;
+       break;
     case PROGRAM_INPUT:
-        switch (pILInst->SrcReg[0].Index)
-        {
-        case FRAG_ATTRIB_COL0:
-        case FRAG_ATTRIB_COL1:
-        case FRAG_ATTRIB_TEX0:
-        case FRAG_ATTRIB_TEX1:
-        case FRAG_ATTRIB_TEX2:
-        case FRAG_ATTRIB_TEX3:
-        case FRAG_ATTRIB_TEX4:
-        case FRAG_ATTRIB_TEX5:
-        case FRAG_ATTRIB_TEX6:
-        case FRAG_ATTRIB_TEX7:
-            bValidTexCoord = GL_TRUE;
-
-            pAsm->S[0].src.reg   = pAsm->uiFP_AttributeMap[pILInst->SrcReg[0].Index];
-            pAsm->S[0].src.rtype = SRC_REG_INPUT;
-        }
-        break;
+	    switch (pILInst->SrcReg[0].Index)
+	    {
+	    case FRAG_ATTRIB_COL0:
+	    case FRAG_ATTRIB_COL1:
+	    case FRAG_ATTRIB_TEX0:
+	    case FRAG_ATTRIB_TEX1:
+	    case FRAG_ATTRIB_TEX2:
+	    case FRAG_ATTRIB_TEX3:
+	    case FRAG_ATTRIB_TEX4:
+	    case FRAG_ATTRIB_TEX5:
+	    case FRAG_ATTRIB_TEX6:
+	    case FRAG_ATTRIB_TEX7:
+		    bValidTexCoord = GL_TRUE;
+		    pAsm->S[0].src.reg   =
+			    pAsm->uiFP_AttributeMap[pILInst->SrcReg[0].Index];
+		    pAsm->S[0].src.rtype = SRC_REG_INPUT;
+		    break;
+	    }
+	    break;
     }
 
     if(GL_TRUE == bValidTexCoord)
-    { 
+    {
         setaddrmode_PVSSRC(&(pAsm->S[0].src), ADDR_ABSOLUTE);
     }
     else
@@ -1201,7 +1209,7 @@ GLboolean tex_src(r700_AssemblerBase *pAsm)
     pAsm->S[0].src.negy = (pILInst->SrcReg[0].Negate >> 1) & 0x1;
     pAsm->S[0].src.negz = (pILInst->SrcReg[0].Negate >> 2) & 0x1;
     pAsm->S[0].src.negw = (pILInst->SrcReg[0].Negate >> 3) & 0x1;
-     
+
     return GL_TRUE;
 }
 
@@ -2202,7 +2210,9 @@ GLboolean next_ins(r700_AssemblerBase *pAsm)
 {
     struct prog_instruction *pILInst = &(pAsm->pILInst[pAsm->uiCurInst]);
 
-    if( GL_TRUE == IsTex(pILInst->Opcode) )
+    if( GL_TRUE == IsTex(pILInst->Opcode) &&
+        /* handle const moves to temp register */ 
+        !(pAsm->D.dst.opcode == SQ_OP2_INST_MOV) )
     {
 	    if (pILInst->TexSrcTarget == TEXTURE_RECT_INDEX) {
 		    if( GL_FALSE == assemble_tex_instruction(pAsm, GL_FALSE) ) 
@@ -3374,28 +3384,31 @@ GLboolean assemble_TEX(r700_AssemblerBase *pAsm)
     case PROGRAM_ENV_PARAM:
     case PROGRAM_STATE_VAR:
         src_const = GL_TRUE;
+        break;
     case PROGRAM_TEMPORARY:
     case PROGRAM_INPUT:
+    default:
         src_const = GL_FALSE;
+	break;
     }
 
-    if (GL_TRUE == src_const) 
+    if (GL_TRUE == src_const)
     {
-        radeon_error("TODO: Texture coordinates from a constant register not supported.\n");
-        return GL_FALSE;
+	    if ( GL_FALSE == mov_temp(pAsm, 0) )
+		    return GL_FALSE;
     }
 
-    switch (pAsm->pILInst[pAsm->uiCurInst].Opcode) 
+    switch (pAsm->pILInst[pAsm->uiCurInst].Opcode)
     {
         case OPCODE_TEX:
-            pAsm->D.dst.opcode = SQ_TEX_INST_SAMPLE;            
+            pAsm->D.dst.opcode = SQ_TEX_INST_SAMPLE;
             break;
-        case OPCODE_TXB:            
+        case OPCODE_TXB:
             radeon_error("do not support TXB yet\n");
             return GL_FALSE;
             break;
-        case OPCODE_TXP:            
-            /* TODO : tex proj version : divid first 3 components by 4th */ 
+        case OPCODE_TXP:
+            /* TODO : tex proj version : divid first 3 components by 4th */
             pAsm->D.dst.opcode = SQ_TEX_INST_SAMPLE;
             break;
         default:
@@ -3418,13 +3431,13 @@ GLboolean assemble_TEX(r700_AssemblerBase *pAsm)
     {
         return GL_FALSE;
     }
- 
+
     if( GL_FALSE == tex_src(pAsm) )
     {
         return GL_FALSE;
     }
 
-    if ( GL_FALSE == next_ins(pAsm) ) 
+    if ( GL_FALSE == next_ins(pAsm) )
     {
         return GL_FALSE;
     }
diff --git a/src/mesa/drivers/dri/r600/r700_chip.c b/src/mesa/drivers/dri/r600/r700_chip.c
index 37bff56f5a..06d7e9c9ab 100644
--- a/src/mesa/drivers/dri/r600/r700_chip.c
+++ b/src/mesa/drivers/dri/r600/r700_chip.c
@@ -52,38 +52,40 @@ static void r700SendTexState(GLcontext *ctx, struct radeon_state_atom *atom)
 	radeon_print(RADEON_STATE, RADEON_VERBOSE, "%s\n", __func__);
 
 	for (i = 0; i < R700_TEXTURE_NUMBERUNITS; i++) {
-		radeonTexObj *t = r700->textures[i];
-		if (t) {
-			if (!t->image_override)
-				bo = t->mt->bo;
-			else
-				bo = t->bo;
-			if (bo) {
-
-				r700SyncSurf(context, bo,
-					     RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM,
-					     0, TC_ACTION_ENA_bit);
-
-				BEGIN_BATCH_NO_AUTOSTATE(9 + 4);
-				R600_OUT_BATCH(CP_PACKET3(R600_IT_SET_RESOURCE, 7));
-				R600_OUT_BATCH(i * 7);
-				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE0);
-				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE1);
-				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE2);
-				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE3);
-				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE4);
-				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE5);
-				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE6);
-				R600_OUT_BATCH_RELOC(r700->textures[i]->SQ_TEX_RESOURCE2,
-						     bo,
-						     0,
-						     RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM, 0, 0);
-				R600_OUT_BATCH_RELOC(r700->textures[i]->SQ_TEX_RESOURCE3,
-						     bo,
-						     r700->textures[i]->SQ_TEX_RESOURCE3,
-						     RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM, 0, 0);
-				END_BATCH();
-				COMMIT_BATCH();
+		if (ctx->Texture.Unit[i]._ReallyEnabled) {
+			radeonTexObj *t = r700->textures[i];
+			if (t) {
+				if (!t->image_override)
+					bo = t->mt->bo;
+				else
+					bo = t->bo;
+				if (bo) {
+
+					r700SyncSurf(context, bo,
+						     RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM,
+						     0, TC_ACTION_ENA_bit);
+
+					BEGIN_BATCH_NO_AUTOSTATE(9 + 4);
+					R600_OUT_BATCH(CP_PACKET3(R600_IT_SET_RESOURCE, 7));
+					R600_OUT_BATCH(i * 7);
+					R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE0);
+					R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE1);
+					R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE2);
+					R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE3);
+					R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE4);
+					R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE5);
+					R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE6);
+					R600_OUT_BATCH_RELOC(r700->textures[i]->SQ_TEX_RESOURCE2,
+							     bo,
+							     0,
+							     RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM, 0, 0);
+					R600_OUT_BATCH_RELOC(r700->textures[i]->SQ_TEX_RESOURCE3,
+							     bo,
+							     r700->textures[i]->SQ_TEX_RESOURCE3,
+							     RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM, 0, 0);
+					END_BATCH();
+					COMMIT_BATCH();
+				}
 			}
 		}
 	}
@@ -98,16 +100,18 @@ static void r700SendTexSamplerState(GLcontext *ctx, struct radeon_state_atom *at
 	radeon_print(RADEON_STATE, RADEON_VERBOSE, "%s\n", __func__);
 
 	for (i = 0; i < R700_TEXTURE_NUMBERUNITS; i++) {
-		radeonTexObj *t = r700->textures[i];
-		if (t) {
-			BEGIN_BATCH_NO_AUTOSTATE(5);
-			R600_OUT_BATCH(CP_PACKET3(R600_IT_SET_SAMPLER, 3));
-			R600_OUT_BATCH(i * 3);
-			R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER0);
-			R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER1);
-			R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER2);
-			END_BATCH();
-			COMMIT_BATCH();
+		if (ctx->Texture.Unit[i]._ReallyEnabled) {
+			radeonTexObj *t = r700->textures[i];
+			if (t) {
+				BEGIN_BATCH_NO_AUTOSTATE(5);
+				R600_OUT_BATCH(CP_PACKET3(R600_IT_SET_SAMPLER, 3));
+				R600_OUT_BATCH(i * 3);
+				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER0);
+				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER1);
+				R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER2);
+				END_BATCH();
+				COMMIT_BATCH();
+			}
 		}
 	}
 }
@@ -121,16 +125,18 @@ static void r700SendTexBorderColorState(GLcontext *ctx, struct radeon_state_atom
 	radeon_print(RADEON_STATE, RADEON_VERBOSE, "%s\n", __func__);
 
 	for (i = 0; i < R700_TEXTURE_NUMBERUNITS; i++) {
-		radeonTexObj *t = r700->textures[i];
-		if (t) {
-			BEGIN_BATCH_NO_AUTOSTATE(2 + 4);
-			R600_OUT_BATCH_REGSEQ((TD_PS_SAMPLER0_BORDER_RED + (i * 16)), 4);
-			R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_RED);
-			R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_GREEN);
-			R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_BLUE);
-			R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_ALPHA);
-			END_BATCH();
-			COMMIT_BATCH();
+		if (ctx->Texture.Unit[i]._ReallyEnabled) {
+			radeonTexObj *t = r700->textures[i];
+			if (t) {
+				BEGIN_BATCH_NO_AUTOSTATE(2 + 4);
+				R600_OUT_BATCH_REGSEQ((TD_PS_SAMPLER0_BORDER_RED + (i * 16)), 4);
+				R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_RED);
+				R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_GREEN);
+				R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_BLUE);
+				R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_ALPHA);
+				END_BATCH();
+				COMMIT_BATCH();
+			}
 		}
 	}
 }
@@ -205,8 +211,7 @@ static void r700SetupVTXConstants(GLcontext  * ctx,
 void r700SetupStreams(GLcontext *ctx)
 {
     context_t         *context = R700_CONTEXT(ctx);
-     struct r700_vertex_program *vpc
-             = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+    struct r700_vertex_program *vp = context->selected_vp;
     TNLcontext *tnl = TNL_CONTEXT(ctx);
     struct vertex_buffer *vb = &tnl->vb;
     unsigned int i, j = 0;
@@ -215,7 +220,7 @@ void r700SetupStreams(GLcontext *ctx)
     R600_STATECHANGE(context, vtx);
 
     for(i=0; i<VERT_ATTRIB_MAX; i++) {
-	    if(vpc->mesa_program.Base.InputsRead & (1 << i)) {
+	    if(vp->mesa_program->Base.InputsRead & (1 << i)) {
 		    rcommon_emit_vector(ctx,
 					&context->radeon.tcl.aos[j],
 					vb->AttribPtr[i]->data,
@@ -231,8 +236,7 @@ void r700SetupStreams(GLcontext *ctx)
 static void r700SendVTXState(GLcontext *ctx, struct radeon_state_atom *atom)
 {
     context_t         *context = R700_CONTEXT(ctx);
-    struct r700_vertex_program *vpc
-             = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+    struct r700_vertex_program *vp = context->selected_vp;
     unsigned int i, j = 0;
     BATCH_LOCALS(&context->radeon);
 	radeon_print(RADEON_STATE, RADEON_VERBOSE, "%s\n", __func__);
@@ -252,7 +256,7 @@ static void r700SendVTXState(GLcontext *ctx, struct radeon_state_atom *atom)
     COMMIT_BATCH();
 
     for(i=0; i<VERT_ATTRIB_MAX; i++) {
-	    if(vpc->mesa_program.Base.InputsRead & (1 << i)) {
+	    if(vp->mesa_program->Base.InputsRead & (1 << i)) {
 		    /* currently aos are packed */
 		    r700SetupVTXConstants(ctx,
 					  i,
@@ -347,7 +351,7 @@ static void r700SetDepthTarget(context_t *context)
         SETfield(r700->DB_DEPTH_INFO.u32All, DEPTH_16,
                      DB_DEPTH_INFO__FORMAT_shift, DB_DEPTH_INFO__FORMAT_mask);
     }
-    SETfield(r700->DB_DEPTH_INFO.u32All, ARRAY_2D_TILED_THIN1,
+    SETfield(r700->DB_DEPTH_INFO.u32All, ARRAY_1D_TILED_THIN1,
              DB_DEPTH_INFO__ARRAY_MODE_shift, DB_DEPTH_INFO__ARRAY_MODE_mask);
     /* r700->DB_PREFETCH_LIMIT.bits.DEPTH_HEIGHT_TILE_MAX = (context->currentDraw->h >> 3) - 1; */ /* z buffer sie may much bigger than what need, so use actual used h. */
 }
@@ -1176,9 +1180,11 @@ static int check_tx(GLcontext *ctx, struct radeon_state_atom *atom)
 	R700_CHIP_CONTEXT *r700 = (R700_CHIP_CONTEXT*)(&context->hw);
 
 	for (i = 0; i < R700_TEXTURE_NUMBERUNITS; i++) {
-		radeonTexObj *t = r700->textures[i];
-		if (t)
-			count++;
+		if (ctx->Texture.Unit[i]._ReallyEnabled) {
+			radeonTexObj *t = r700->textures[i];
+			if (t)
+				count++;
+		}
 	}
 	radeon_print(RADEON_STATE, RADEON_TRACE, "%s %d\n", __func__, count);
 	return count * 31;
diff --git a/src/mesa/drivers/dri/r600/r700_oglprog.c b/src/mesa/drivers/dri/r600/r700_oglprog.c
index 3c8c1fd7a3..5290ef31be 100644
--- a/src/mesa/drivers/dri/r600/r700_oglprog.c
+++ b/src/mesa/drivers/dri/r600/r700_oglprog.c
@@ -46,7 +46,7 @@ static struct gl_program *r700NewProgram(GLcontext * ctx,
 {
 	struct gl_program *pProgram = NULL;
 
-    struct r700_vertex_program *vp;
+    struct r700_vertex_program_cont *vpc;
 	struct r700_fragment_program *fp;
 
 	radeon_print(RADEON_SHADER, RADEON_VERBOSE,
@@ -56,16 +56,11 @@ static struct gl_program *r700NewProgram(GLcontext * ctx,
     {
     case GL_VERTEX_STATE_PROGRAM_NV:
     case GL_VERTEX_PROGRAM_ARB:	    
-        vp       = CALLOC_STRUCT(r700_vertex_program);
+        vpc       = CALLOC_STRUCT(r700_vertex_program_cont);
 	    pProgram = _mesa_init_vertex_program(ctx, 
-                                             &vp->mesa_program,
+                                             &vpc->mesa_program,
 					                         target, 
                                              id);
-        vp->translated = GL_FALSE;
-        vp->loaded     = GL_FALSE;
- 
-        vp->shaderbo   = NULL;
-
 	    break;
     case GL_FRAGMENT_PROGRAM_NV:
     case GL_FRAGMENT_PROGRAM_ARB:
@@ -89,7 +84,8 @@ static struct gl_program *r700NewProgram(GLcontext * ctx,
 
 static void r700DeleteProgram(GLcontext * ctx, struct gl_program *prog)
 {
-    struct r700_vertex_program   * vp;
+    struct r700_vertex_program_cont   * vpc;
+    struct r700_vertex_program *vp, *tmp;
     struct r700_fragment_program * fp;
 
 	radeon_print(RADEON_SHADER, RADEON_VERBOSE,
@@ -99,14 +95,20 @@ static void r700DeleteProgram(GLcontext * ctx, struct gl_program *prog)
     {
     case GL_VERTEX_STATE_PROGRAM_NV:
     case GL_VERTEX_PROGRAM_ARB:	    
-        vp = (struct r700_vertex_program*)prog;
-        /* Release DMA region */
-
-        r600DeleteShader(ctx, vp->shaderbo);
-
-        /* Clean up */
-        Clean_Up_Assembler(&(vp->r700AsmCode));
-        Clean_Up_Shader(&(vp->r700Shader));
+        vpc = (struct r700_vertex_program_cont*)prog;
+        vp = vpc->progs;
+	while (vp) {
+		tmp = vp->next;
+		/* Release DMA region */
+	 
+	        r600DeleteShader(ctx, vp->shaderbo);
+
+	        /* Clean up */
+	        Clean_Up_Assembler(&(vp->r700AsmCode));
+	        Clean_Up_Shader(&(vp->r700Shader));
+		_mesa_free(vp);
+		vp = tmp;
+	}
 	    break;
     case GL_FRAGMENT_PROGRAM_NV:
     case GL_FRAGMENT_PROGRAM_ARB:
diff --git a/src/mesa/drivers/dri/r600/r700_render.c b/src/mesa/drivers/dri/r600/r700_render.c
index 3566bf3ca7..b1c3648ca5 100644
--- a/src/mesa/drivers/dri/r600/r700_render.c
+++ b/src/mesa/drivers/dri/r600/r700_render.c
@@ -319,14 +319,13 @@ static GLuint r700PredictRenderSize(GLcontext* ctx)
 {
     context_t *context = R700_CONTEXT(ctx);
     TNLcontext *tnl = TNL_CONTEXT(ctx);
-    struct r700_vertex_program *vpc
-        = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+    struct r700_vertex_program *vp = context->selected_vp;
     struct vertex_buffer *vb = &tnl->vb;
     GLboolean flushed;
     GLuint dwords, i;
     GLuint state_size;
     /* pre calculate aos count so state prediction works */
-    context->radeon.tcl.aos_count = _mesa_bitcount(vpc->mesa_program.Base.InputsRead);
+    context->radeon.tcl.aos_count = _mesa_bitcount(vp->mesa_program->Base.InputsRead);
 
     dwords = PRE_EMIT_STATE_BUFSZ;
     for (i = 0; i < vb->PrimitiveCount; i++)
@@ -365,7 +364,6 @@ static GLboolean r700RunRender(GLcontext * ctx,
     /* mark vtx as dirty since it changes per-draw */
     R600_STATECHANGE(context, vtx);
 
-    r700UpdateShaders(ctx);
     r700SetScissor(context);
     r700SetupVertexProgram(ctx);
     r700SetupFragmentProgram(ctx);
@@ -427,7 +425,10 @@ static GLboolean r700RunTCLRender(GLcontext * ctx,  /*----------------------*/
 
     /* TODO : sw fallback */
 
+    /* Need shader bo's setup before bo check */
+    r700UpdateShaders(ctx);
     /**
+
     * Ensure all enabled and complete textures are uploaded along with any buffers being used.
     */
     if(!r600ValidateBuffers(ctx))
diff --git a/src/mesa/drivers/dri/r600/r700_state.c b/src/mesa/drivers/dri/r600/r700_state.c
index 93b4ebfdb9..fc0b511684 100644
--- a/src/mesa/drivers/dri/r600/r700_state.c
+++ b/src/mesa/drivers/dri/r600/r700_state.c
@@ -845,9 +845,9 @@ static void r700PointSize(GLcontext * ctx, GLfloat size)
 	size = CLAMP(size, ctx->Const.MinPointSize, ctx->Const.MaxPointSize);
 
 	/* format is 12.4 fixed point */
-	SETfield(r700->PA_SU_POINT_SIZE.u32All, (int)(size * 16),
+	SETfield(r700->PA_SU_POINT_SIZE.u32All, (int)(size * 8.0),
 		 PA_SU_POINT_SIZE__HEIGHT_shift, PA_SU_POINT_SIZE__HEIGHT_mask);
-	SETfield(r700->PA_SU_POINT_SIZE.u32All, (int)(size * 16),
+	SETfield(r700->PA_SU_POINT_SIZE.u32All, (int)(size * 8.0),
 		 PA_SU_POINT_SIZE__WIDTH_shift, PA_SU_POINT_SIZE__WIDTH_mask);
 
 }
@@ -862,11 +862,11 @@ static void r700PointParameter(GLcontext * ctx, GLenum pname, const GLfloat * pa
 	/* format is 12.4 fixed point */
 	switch (pname) {
 	case GL_POINT_SIZE_MIN:
-		SETfield(r700->PA_SU_POINT_MINMAX.u32All, (int)(ctx->Point.MinSize * 16.0),
+		SETfield(r700->PA_SU_POINT_MINMAX.u32All, (int)(ctx->Point.MinSize * 8.0),
 			 MIN_SIZE_shift, MIN_SIZE_mask);
 		break;
 	case GL_POINT_SIZE_MAX:
-		SETfield(r700->PA_SU_POINT_MINMAX.u32All, (int)(ctx->Point.MaxSize * 16.0),
+		SETfield(r700->PA_SU_POINT_MINMAX.u32All, (int)(ctx->Point.MaxSize * 8.0),
 			 MAX_SIZE_shift, MAX_SIZE_mask);
 		break;
 	case GL_POINT_DISTANCE_ATTENUATION:
@@ -1130,20 +1130,25 @@ static void r700PolygonOffset(GLcontext * ctx, GLfloat factor, GLfloat units) //
 	context_t *context = R700_CONTEXT(ctx);
 	R700_CHIP_CONTEXT *r700 = (R700_CHIP_CONTEXT*)(&context->hw);
 	GLfloat constant = units;
+	GLchar depth = 0;
+
+	R600_STATECHANGE(context, poly);
 
 	switch (ctx->Visual.depthBits) {
 	case 16:
 		constant *= 4.0;
+		depth = -16;
 		break;
 	case 24:
 		constant *= 2.0;
+		depth = -24;
 		break;
 	}
 
 	factor *= 12.0;
-
-	R600_STATECHANGE(context, poly);
-
+	SETfield(r700->PA_SU_POLY_OFFSET_DB_FMT_CNTL.u32All, depth,
+		 POLY_OFFSET_NEG_NUM_DB_BITS_shift, POLY_OFFSET_NEG_NUM_DB_BITS_mask);
+	//r700->PA_SU_POLY_OFFSET_CLAMP.f32All = constant; //???
 	r700->PA_SU_POLY_OFFSET_FRONT_SCALE.f32All = factor;
 	r700->PA_SU_POLY_OFFSET_FRONT_OFFSET.f32All = constant;
 	r700->PA_SU_POLY_OFFSET_BACK_SCALE.f32All = factor;
@@ -1280,8 +1285,8 @@ void r700SetScissor(context_t *context) //---------------
 		if (context->radeon.radeonScreen->driScreen->dri2.enabled) {
 			x1 = 0;
 			y1 = 0;
-			x2 = rrb->base.Width - 1;
-			y2 = rrb->base.Height - 1;
+			x2 = rrb->base.Width;
+			y2 = rrb->base.Height;
 		} else {
 			x1 = rrb->dPriv->x;
 			y1 = rrb->dPriv->y;
diff --git a/src/mesa/drivers/dri/r600/r700_vertprog.c b/src/mesa/drivers/dri/r600/r700_vertprog.c
index d107f99e7b..9ee26286d9 100644
--- a/src/mesa/drivers/dri/r600/r700_vertprog.c
+++ b/src/mesa/drivers/dri/r600/r700_vertprog.c
@@ -35,12 +35,14 @@
 #include "main/mtypes.h"
 
 #include "tnl/t_context.h"
+#include "shader/program.h"
 #include "shader/prog_parameter.h"
 #include "shader/prog_statevars.h"
 
 #include "radeon_debug.h"
 #include "r600_context.h"
 #include "r600_cmdbuf.h"
+#include "shader/programopt.c"
 
 #include "r700_debug.h"
 #include "r700_vertprog.h"
@@ -258,28 +260,59 @@ GLboolean Find_Instruction_Dependencies_vp(struct r700_vertex_program *vp,
     return GL_TRUE;
 }
 
-GLboolean r700TranslateVertexShader(struct r700_vertex_program *vp,
-							   struct gl_vertex_program   *mesa_vp)
+struct r700_vertex_program* r700TranslateVertexShader(GLcontext *ctx,
+						struct gl_vertex_program *mesa_vp)
 {
+	context_t *context = R700_CONTEXT(ctx);
+	struct r700_vertex_program *vp;
+	TNLcontext *tnl = TNL_CONTEXT(ctx);
+	struct vertex_buffer *vb = &tnl->vb;
+	unsigned int unBit;
+	unsigned int i;
+
+	vp = _mesa_calloc(sizeof(*vp));
+	vp->mesa_program = (struct gl_vertex_program *)_mesa_clone_program(ctx, &mesa_vp->Base);
+
+	if (mesa_vp->IsPositionInvariant)
+	{
+                _mesa_insert_mvp_code(ctx, vp->mesa_program);
+        }
+
+	for(i=0; i<VERT_ATTRIB_MAX; i++)
+	{
+		unBit = 1 << i;
+		if(vp->mesa_program->Base.InputsRead & unBit) /* ctx->Array.ArrayObj->xxxxxxx */
+		{
+			vp->aos_desc[i].size   = vb->AttribPtr[i]->size;
+			vp->aos_desc[i].stride = vb->AttribPtr[i]->size * sizeof(GL_FLOAT);/* when emit array, data is packed. vb->AttribPtr[i]->stride;*/
+			vp->aos_desc[i].type   = GL_FLOAT;
+		}
+	}
+	
+	if (context->radeon.radeonScreen->chip_family < CHIP_FAMILY_RV770)
+	{
+		vp->r700AsmCode.bR6xx = 1;
+	}
+
 	//Init_Program
 	Init_r700_AssemblerBase(SPT_VP, &(vp->r700AsmCode), &(vp->r700Shader) );
-	Map_Vertex_Program( vp, mesa_vp );
+	Map_Vertex_Program( vp, vp->mesa_program );
 
-	if(GL_FALSE == Find_Instruction_Dependencies_vp(vp, mesa_vp))
+	if(GL_FALSE == Find_Instruction_Dependencies_vp(vp, vp->mesa_program))
 	{
-		return GL_FALSE;
+		return NULL;
     }
 
-	if(GL_FALSE == AssembleInstr(mesa_vp->Base.NumInstructions,
-                                 &(mesa_vp->Base.Instructions[0]), 
+	if(GL_FALSE == AssembleInstr(vp->mesa_program->Base.NumInstructions,
+                                 &(vp->mesa_program->Base.Instructions[0]), 
                                  &(vp->r700AsmCode)) )
 	{
-		return GL_FALSE;
+		return NULL;
 	} 
 
-    if(GL_FALSE == Process_Vertex_Exports(&(vp->r700AsmCode), mesa_vp->Base.OutputsWritten) )
+    if(GL_FALSE == Process_Vertex_Exports(&(vp->r700AsmCode), vp->mesa_program->Base.OutputsWritten) )
     {
-        return GL_FALSE;
+        return NULL;
     }
 
     vp->r700Shader.nRegs = (vp->r700AsmCode.number_used_registers == 0) ? 0 
@@ -289,72 +322,82 @@ GLboolean r700TranslateVertexShader(struct r700_vertex_program *vp,
 
     vp->translated = GL_TRUE;
 
-	return GL_TRUE;
+	return vp;
 }
 
 void r700SelectVertexShader(GLcontext *ctx)
 {
     context_t *context = R700_CONTEXT(ctx);
-    struct r700_vertex_program *vpc
-             = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+    struct r700_vertex_program_cont *vpc;
+    struct r700_vertex_program *vp;
     TNLcontext *tnl = TNL_CONTEXT(ctx);
     struct vertex_buffer *vb = &tnl->vb;
     unsigned int unBit;
     unsigned int i;
+    GLboolean match;
+    GLbitfield InputsRead;
 
-    if (context->radeon.NewGLState & (_NEW_PROGRAM_CONSTANTS|_NEW_PROGRAM))
-    {
-	vpc->needUpdateVF = 1;
-    }
+    vpc = (struct r700_vertex_program_cont *)ctx->VertexProgram._Current;
 
-    if (context->radeon.radeonScreen->chip_family < CHIP_FAMILY_RV770)
+    InputsRead = vpc->mesa_program.Base.InputsRead;
+    if (vpc->mesa_program.IsPositionInvariant)
     {
-        vpc->r700AsmCode.bR6xx = 1;
-    }
-
+	InputsRead |= VERT_BIT_POS;
+    } 
+    
+    for (vp = vpc->progs; vp; vp = vp->next)
+    {
+	match = GL_TRUE;	
 	for(i=0; i<VERT_ATTRIB_MAX; i++)
 	{
 		unBit = 1 << i;
-		if(vpc->mesa_program.Base.InputsRead & unBit) /* ctx->Array.ArrayObj->xxxxxxx */
+		if(InputsRead & unBit)
 		{
-			vpc->aos_desc[i].size   = vb->AttribPtr[i]->size;
-			vpc->aos_desc[i].stride = vb->AttribPtr[i]->size * sizeof(GL_FLOAT);/* when emit array, data is packed. vb->AttribPtr[i]->stride;*/
-			vpc->aos_desc[i].type   = GL_FLOAT;
+			if (vp->aos_desc[i].size != vb->AttribPtr[i]->size)
+				match = GL_FALSE;
+				break;
 		}
 	}
-
-	if(GL_FALSE == vpc->translated) {
-		r700TranslateVertexShader(vpc, &(vpc->mesa_program) );
+	if (match) 
+	{
+		context->selected_vp = vp;
+		return;
 	}
+    }
+
+    vp = r700TranslateVertexShader(ctx, &(vpc->mesa_program) );
+    if(!vp)
+    {
+	radeon_error("Failed to translate vertex shader. \n");
+	return;
+    }
+    vp->next = vpc->progs;
+    vpc->progs = vp;
+    context->selected_vp = vp;
+    return;
 }
 
 void * r700GetActiveVpShaderBo(GLcontext * ctx)
 {
-    struct r700_vertex_program *vp
-             = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+    context_t *context = R700_CONTEXT(ctx);
+    struct r700_vertex_program *vp = context->selected_vp;;
 
-    return vp->shaderbo;
+    if (vp)
+	return vp->shaderbo;
+    else
+	return NULL;
 }
 
 GLboolean r700SetupVertexProgram(GLcontext * ctx)
 {
     context_t *context = R700_CONTEXT(ctx);
     R700_CHIP_CONTEXT *r700 = (R700_CHIP_CONTEXT*)(&context->hw);
-    struct r700_vertex_program *vp
-             = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+    struct r700_vertex_program *vp = context->selected_vp;
 
     struct gl_program_parameter_list *paramList;
     unsigned int unNumParamData;
     unsigned int ui;
 
-    if (vp->needUpdateVF)
-    {
-	vp->loaded = GL_FALSE;
-	vp->r700Shader.bNeedsAssembly = GL_TRUE;
-	Process_Vertex_Program_Vfetch_Instructions(vp, &(vp->mesa_program));
-	r600DeleteShader(ctx, vp->shaderbo);
-    }
-
     if(GL_FALSE == vp->loaded)
     {
 	    if(vp->r700Shader.bNeedsAssembly == GL_TRUE)
@@ -410,7 +453,7 @@ GLboolean r700SetupVertexProgram(GLcontext * ctx)
     */
 
     /* sent out shader constants. */
-    paramList = vp->mesa_program.Base.Parameters;
+    paramList = vp->mesa_program->Base.Parameters;
 
     if(NULL != paramList) {
 	    _mesa_load_state_parameters(ctx, paramList);
diff --git a/src/mesa/drivers/dri/r600/r700_vertprog.h b/src/mesa/drivers/dri/r600/r700_vertprog.h
index e2e65021fd..c48764c43b 100644
--- a/src/mesa/drivers/dri/r600/r700_vertprog.h
+++ b/src/mesa/drivers/dri/r600/r700_vertprog.h
@@ -43,7 +43,7 @@ typedef struct ArrayDesc //TEMP
 
 struct r700_vertex_program 
 {
-    struct gl_vertex_program mesa_program; /* Must be first */
+    struct gl_vertex_program *mesa_program; /* Must be first */
 
     struct r700_vertex_program *next;
 
@@ -59,6 +59,13 @@ struct r700_vertex_program
     ArrayDesc              aos_desc[VERT_ATTRIB_MAX];
 };
 
+struct r700_vertex_program_cont
+{
+    struct gl_vertex_program mesa_program;
+
+    struct r700_vertex_program *progs;
+};
+
 //Internal
 unsigned int Map_Vertex_Output(r700_AssemblerBase       *pAsm, 
 			       struct gl_vertex_program *mesa_vp,
@@ -74,7 +81,7 @@ void Map_Vertex_Program(struct r700_vertex_program *vp,
 GLboolean Find_Instruction_Dependencies_vp(struct r700_vertex_program *vp,
 					   struct gl_vertex_program   *mesa_vp);
 
-GLboolean r700TranslateVertexShader(struct r700_vertex_program *vp,
+struct r700_vertex_program* r700TranslateVertexShader(GLcontext *ctx,
 				    struct gl_vertex_program   *mesa_vp);
 
 /* Interface */
diff --git a/src/mesa/drivers/dri/radeon/Makefile b/src/mesa/drivers/dri/radeon/Makefile
index 1f286776b5..b1efc72872 100644
--- a/src/mesa/drivers/dri/radeon/Makefile
+++ b/src/mesa/drivers/dri/radeon/Makefile
@@ -47,8 +47,7 @@ C_SOURCES = \
 	$(DRIVER_SOURCES) \
 	$(CS_SOURCES)
 
-DRIVER_DEFINES = -DRADEON_COMMON=0 \
-				 -Wall
+DRIVER_DEFINES = -DRADEON_R100 -Wall
 
 DRI_LIB_DEPS += $(RADEON_LDFLAGS)
 
diff --git a/src/mesa/drivers/dri/radeon/radeon_common.c b/src/mesa/drivers/dri/radeon/radeon_common.c
index e53eb0904d..264392b327 100644
--- a/src/mesa/drivers/dri/radeon/radeon_common.c
+++ b/src/mesa/drivers/dri/radeon/radeon_common.c
@@ -1234,7 +1234,9 @@ int rcommonFlushCmdBuf(radeonContextPtr rmesa, const char *caller)
 	UNLOCK_HARDWARE(rmesa);
 
 	if (ret) {
-		fprintf(stderr, "drmRadeonCmdBuffer: %d\n", ret);
+		fprintf(stderr, "drmRadeonCmdBuffer: %d. Kernel failed to "
+				"parse or rejected command stream. See dmesg "
+				"for more info.\n", ret);
 		_mesa_exit(ret);
 	}
 
@@ -1343,5 +1345,5 @@ void rcommonBeginBatch(radeonContextPtr rmesa, int n,
 
 void radeonUserClear(GLcontext *ctx, GLuint mask)
 {
-   _mesa_meta_clear(ctx, mask);
+   _mesa_meta_Clear(ctx, mask);
 }
diff --git a/src/mesa/drivers/dri/radeon/radeon_common_context.c b/src/mesa/drivers/dri/radeon/radeon_common_context.c
index 71ee06d9a7..1c53c04da7 100644
--- a/src/mesa/drivers/dri/radeon/radeon_common_context.c
+++ b/src/mesa/drivers/dri/radeon/radeon_common_context.c
@@ -47,7 +47,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "swrast_setup/swrast_setup.h"
 #include "tnl/tnl.h"
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R600) /* +r6/r7 */
+#if defined(RADEON_R600)
 #include "r600_context.h"
 #endif
 
diff --git a/src/mesa/drivers/dri/radeon/radeon_debug.c b/src/mesa/drivers/dri/radeon/radeon_debug.c
index a1ed39683f..413000b6c0 100644
--- a/src/mesa/drivers/dri/radeon/radeon_debug.c
+++ b/src/mesa/drivers/dri/radeon/radeon_debug.c
@@ -32,11 +32,14 @@
 #include "radeon_debug.h"
 #include "radeon_common_context.h"
 
+#include <stdarg.h>
+#include <stdio.h>
+
 static const struct dri_debug_control debug_control[] = {
 	{"fall", RADEON_FALLBACKS},
 	{"tex", RADEON_TEXTURE},
 	{"ioctl", RADEON_IOCTL},
-	{"verts", RADEON_RENDER},
+	{"verts", RADEON_VERTS},
 	{"render", RADEON_RENDER},
 	{"swrender", RADEON_SWRENDER},
 	{"state", RADEON_STATE},
@@ -85,10 +88,10 @@ void _radeon_debug_remove_indent(void)
 	}
 }
 
-extern void _radeon_print(const radeon_debug_type_t type,
+void _radeon_print(const radeon_debug_type_t type,
 	   const radeon_debug_level_t level,
 	   const char* message,
-	   va_list values)
+	   ...)
 {
 	GET_CURRENT_CONTEXT(ctx);
 	if (ctx) {
@@ -97,5 +100,8 @@ extern void _radeon_print(const radeon_debug_type_t type,
 		if (radeon->debug.indent_depth)
 			fprintf(stderr, "%s", radeon->debug.indent);
 	}
+	va_list values;
+	va_start( values, message );
 	vfprintf(stderr, message, values);
+	va_end( values );
 }
diff --git a/src/mesa/drivers/dri/radeon/radeon_debug.h b/src/mesa/drivers/dri/radeon/radeon_debug.h
index 132e27351d..26da31c1c4 100644
--- a/src/mesa/drivers/dri/radeon/radeon_debug.h
+++ b/src/mesa/drivers/dri/radeon/radeon_debug.h
@@ -30,8 +30,7 @@
 #ifndef RADEON_DEBUG_H_INCLUDED
 #define RADEON_DEBUG_H_INCLUDED
 
-#include <stdarg.h>
-#include <stdio.h>
+#include <stdlib.h>
 
 typedef enum radeon_debug_levels {
 	RADEON_CRITICAL  = 0, /* Only errors */
@@ -102,57 +101,36 @@ static inline int radeon_is_debug_enabled(const radeon_debug_type_t type,
 extern void _radeon_print(const radeon_debug_type_t type,
 	   const radeon_debug_level_t level,
 	   const char* message,
-	   va_list values);
-/**
- * Format attribute requires declaration for setting it. Don't ask me why!
- */
-static inline void radeon_print(const radeon_debug_type_t type,
-	   const radeon_debug_level_t level,
-	   const char* message,
-	   ...) __attribute__((format(printf,3,4)));
-
+	   ...)  __attribute__((format(printf,3,4)));
 /**
  * Print out debug message if channel specified by type is enabled
  * and compile time debugging level is at least as high as level parameter
  */
-static inline void radeon_print(const radeon_debug_type_t type,
-	   const radeon_debug_level_t level,
-	   const char* message,
-	   ...)
-{
-	/* Compile out if level of message is too high */
-	if (radeon_is_debug_enabled(type, level)) {
-
-		va_list values;
-		va_start( values, message );
-		_radeon_print(type, level, message, values);
-		va_end( values );
-	}
-}
+#define radeon_print(type, level, message, ...) do {		\
+	const radeon_debug_level_t _debug_level = (level);	\
+	const radeon_debug_type_t _debug_type = (type);		\
+	/* Compile out if level of message is too high */	\
+	if (radeon_is_debug_enabled(type, level)) {		\
+		_radeon_print(_debug_type, _debug_level,	\
+			(message), ## __VA_ARGS__);		\
+	}							\
+} while(0)
 
-static inline void radeon_error(const char* message, ...)  __attribute__((format(printf,1,2)));
 /**
  * printf style function for writing error messages.
  */
-static inline void radeon_error(const char* message, ...)
-{
-       va_list values;
-       va_start( values, message );
-       radeon_print(RADEON_GENERAL, RADEON_CRITICAL, message, values);
-       va_end( values );
-}
+#define radeon_error(message, ...) do {				\
+	radeon_print(RADEON_GENERAL, RADEON_CRITICAL,		\
+		(message), ## __VA_ARGS__);			\
+} while(0)
 
-static inline void radeon_warning(const char* message, ...)  __attribute__((format(printf,1,2)));
 /**
  * printf style function for writing warnings.
  */
-static inline void radeon_warning(const char* message, ...)
-{
-       va_list values;
-       va_start( values, message );
-       radeon_print(RADEON_GENERAL, RADEON_IMPORTANT, message, values);
-       va_end( values );
-}
+#define radeon_warning(message, ...) do {			\
+	radeon_print(RADEON_GENERAL, RADEON_IMPORTANT,		\
+		(message), ## __VA_ARGS__);			\
+} while(0)
 
 extern void radeon_init_debug(void);
 extern void _radeon_debug_add_indent(void);
@@ -171,21 +149,22 @@ static inline void radeon_debug_remove_indent(void)
        }
 }
 
+
 /* From http://gcc. gnu.org/onlinedocs/gcc-3.2.3/gcc/Variadic-Macros.html .
    I suppose we could inline this and use macro to fetch out __LINE__ and stuff in case we run into trouble
    with other compilers ... GLUE!
 */
-#define WARN_ONCE(a, ...)      { \
-       static int warn##__LINE__=1; \
-       if(warn##__LINE__){ \
+#define WARN_ONCE(a, ...)      do { \
+       static int __warn_once=1; \
+       if(__warn_once){ \
                radeon_warning("*********************************WARN_ONCE*********************************\n"); \
                radeon_warning("File %s function %s line %d\n", \
                        __FILE__, __FUNCTION__, __LINE__); \
                radeon_warning(  (a), ## __VA_ARGS__);\
                radeon_warning("***************************************************************************\n"); \
-               warn##__LINE__=0;\
+               __warn_once=0;\
                } \
-       }
+       } while(0)
 
 
 #endif
diff --git a/src/mesa/drivers/dri/radeon/radeon_dma.c b/src/mesa/drivers/dri/radeon/radeon_dma.c
index 2eefa3f2b1..c6edbae9a1 100644
--- a/src/mesa/drivers/dri/radeon/radeon_dma.c
+++ b/src/mesa/drivers/dri/radeon/radeon_dma.c
@@ -207,7 +207,6 @@ again_alloc:
 		   counter on unused buffers for later freeing them from
 		   begin of list */
 		dma_bo = last_elem(&rmesa->dma.free);
-		assert(dma_bo->bo->cref == 1);
 		remove_from_list(dma_bo);
 		insert_at_head(&rmesa->dma.reserved, dma_bo);
 	}
@@ -263,7 +262,7 @@ void radeonAllocDmaRegion(radeonContextPtr rmesa,
 
 void radeonFreeDmaRegions(radeonContextPtr rmesa)
 {
-	struct radeon_dma_bo *dma_bo = CALLOC_STRUCT(radeon_dma_bo);
+	struct radeon_dma_bo *dma_bo;
 	struct radeon_dma_bo *temp;
 	if (RADEON_DEBUG & RADEON_DMA)
 		fprintf(stderr, "%s\n", __FUNCTION__);
@@ -307,6 +306,10 @@ static int radeon_bo_is_idle(struct radeon_bo* bo)
 		WARN_ONCE("Your libdrm or kernel doesn't have support for busy query.\n"
 			"This may cause small performance drop for you.\n");
 	}
+	/* Protect against bug in legacy bo handling that causes bos stay
+	 * referenced even after they should be freed */
+	if (bo->cref != 1)
+		return 0;
 	return ret != -EBUSY;
 }
 
@@ -343,7 +346,9 @@ void radeonReleaseDmaRegions(radeonContextPtr rmesa)
 	foreach_s(dma_bo, temp, &rmesa->dma.wait) {
 		if (dma_bo->expire_counter == time) {
 			WARN_ONCE("Leaking dma buffer object!\n");
-			radeon_bo_unref(dma_bo->bo);
+			/* force free of buffer so we don't realy start
+			 * leaking stuff now*/
+			while ((dma_bo->bo = radeon_bo_unref(dma_bo->bo))) {}
 			remove_from_list(dma_bo);
 			FREE(dma_bo);
 			continue;
diff --git a/src/mesa/drivers/dri/radeon/radeon_fbo.c b/src/mesa/drivers/dri/radeon/radeon_fbo.c
index d83b166742..7ac53ec0ca 100644
--- a/src/mesa/drivers/dri/radeon/radeon_fbo.c
+++ b/src/mesa/drivers/dri/radeon/radeon_fbo.c
@@ -583,7 +583,7 @@ void radeon_fbo_init(struct radeon_context *radeon)
   radeon->glCtx->Driver.FinishRenderTexture = radeon_finish_render_texture;
   radeon->glCtx->Driver.ResizeBuffers = radeon_resize_buffers;
   radeon->glCtx->Driver.ValidateFramebuffer = radeon_validate_framebuffer;
-  radeon->glCtx->Driver.BlitFramebuffer = _mesa_meta_blit_framebuffer;
+  radeon->glCtx->Driver.BlitFramebuffer = _mesa_meta_BlitFramebuffer;
 }
 
   
diff --git a/src/mesa/drivers/dri/radeon/radeon_screen.c b/src/mesa/drivers/dri/radeon/radeon_screen.c
index 5ffb55db5e..573eb6c9c1 100644
--- a/src/mesa/drivers/dri/radeon/radeon_screen.c
+++ b/src/mesa/drivers/dri/radeon/radeon_screen.c
@@ -48,17 +48,17 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "radeon_screen.h"
 #include "radeon_common.h"
 #include "radeon_span.h"
-#if !RADEON_COMMON
+#if defined(RADEON_R100)
 #include "radeon_context.h"
 #include "radeon_tex.h"
-#elif RADEON_COMMON && defined(RADEON_COMMON_FOR_R200)
+#elif defined(RADEON_R200)
 #include "r200_context.h"
 #include "r200_ioctl.h"
 #include "r200_tex.h"
-#elif RADEON_COMMON && defined(RADEON_COMMON_FOR_R300)
+#elif defined(RADEON_R300)
 #include "r300_context.h"
 #include "r300_tex.h"
-#elif RADEON_COMMON && defined(RADEON_COMMON_FOR_R600)
+#elif defined(RADEON_R600)
 #include "r600_context.h"
 #include "r700_driconf.h" /* +r6/r7 */
 #include "r600_tex.h"     /* +r6/r7 */
@@ -82,7 +82,7 @@ DRI_CONF_OPT_BEGIN_V(command_buffer_size,int,def, # min ":" # max ) \
         DRI_CONF_DESC(de,"Grösse des Befehlspuffers (in KB)") \
 DRI_CONF_OPT_END
 
-#if !RADEON_COMMON	/* R100 */
+#if defined(RADEON_R100)	/* R100 */
 PUBLIC const char __driConfigOptions[] =
 DRI_CONF_BEGIN
     DRI_CONF_SECTION_PERFORMANCE
@@ -109,7 +109,7 @@ DRI_CONF_BEGIN
 DRI_CONF_END;
 static const GLuint __driNConfigOptions = 15;
 
-#elif RADEON_COMMON && defined(RADEON_COMMON_FOR_R200)
+#elif defined(RADEON_R200)
 
 PUBLIC const char __driConfigOptions[] =
 DRI_CONF_BEGIN
@@ -147,7 +147,7 @@ extern const struct dri_extension NV_vp_extension[];
 extern const struct dri_extension ATI_fs_extension[];
 extern const struct dri_extension point_extensions[];
 
-#elif RADEON_COMMON && (defined(RADEON_COMMON_FOR_R300) || defined(RADEON_COMMON_FOR_R600))
+#elif defined(RADEON_R300) || defined(RADEON_R600)
 
 #define DRI_CONF_FP_OPTIMIZATION_SPEED   0
 #define DRI_CONF_FP_OPTIMIZATION_QUALITY 1
@@ -220,7 +220,7 @@ static const GLuint __driNConfigOptions = 17;
 
 extern const struct dri_extension gl_20_extension[];
 
-#endif /* RADEON_COMMON && defined(RADEON_COMMON_FOR_R300) */
+#endif
 
 extern const struct dri_extension card_extensions[];
 extern const struct dri_extension mm_extensions[];
@@ -337,7 +337,7 @@ radeonFillInModes( __DRIscreenPrivate *psp,
     return (const __DRIconfig **) configs;
 }
 
-#if !RADEON_COMMON
+#if defined(RADEON_R100)
 static const __DRItexOffsetExtension radeonTexOffsetExtension = {
     { __DRI_TEX_OFFSET, __DRI_TEX_OFFSET_VERSION },
     radeonSetTexOffset,
@@ -350,7 +350,7 @@ static const __DRItexBufferExtension radeonTexBufferExtension = {
 };
 #endif
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R200)
+#if defined(RADEON_R200)
 static const __DRIallocateExtension r200AllocateExtension = {
     { __DRI_ALLOCATE, __DRI_ALLOCATE_VERSION },
     r200AllocateMemoryMESA,
@@ -370,7 +370,7 @@ static const __DRItexBufferExtension r200TexBufferExtension = {
 };
 #endif
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R300)
+#if defined(RADEON_R300)
 static const __DRItexOffsetExtension r300texOffsetExtension = {
     { __DRI_TEX_OFFSET, __DRI_TEX_OFFSET_VERSION },
    r300SetTexOffset,
@@ -383,7 +383,7 @@ static const __DRItexBufferExtension r300TexBufferExtension = {
 };
 #endif
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R600)
+#if defined(RADEON_R600)
 static const __DRItexOffsetExtension r600texOffsetExtension = {
     { __DRI_TEX_OFFSET, __DRI_TEX_OFFSET_VERSION },
    r600SetTexOffset, /* +r6/r7 */
@@ -1222,22 +1222,22 @@ radeonCreateScreen( __DRIscreenPrivate *sPriv )
        screen->extensions[i++] = &driMediaStreamCounterExtension.base;
    }
 
-#if !RADEON_COMMON
+#if defined(RADEON_R100)
    screen->extensions[i++] = &radeonTexOffsetExtension.base;
 #endif
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R200)
+#if defined(RADEON_R200)
    if (IS_R200_CLASS(screen))
       screen->extensions[i++] = &r200AllocateExtension.base;
 
    screen->extensions[i++] = &r200texOffsetExtension.base;
 #endif
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R300)
+#if defined(RADEON_R300)
    screen->extensions[i++] = &r300texOffsetExtension.base;
 #endif
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R600)
+#if defined(RADEON_R600)
    screen->extensions[i++] = &r600texOffsetExtension.base;
 #endif
 
@@ -1376,22 +1376,22 @@ radeonCreateScreen2(__DRIscreenPrivate *sPriv)
        screen->extensions[i++] = &driMediaStreamCounterExtension.base;
    }
 
-#if !RADEON_COMMON
+#if defined(RADEON_R100)
    screen->extensions[i++] = &radeonTexBufferExtension.base;
 #endif
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R200)
+#if defined(RADEON_R200)
    if (IS_R200_CLASS(screen))
        screen->extensions[i++] = &r200AllocateExtension.base;
 
    screen->extensions[i++] = &r200TexBufferExtension.base;
 #endif
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R300)
+#if defined(RADEON_R300)
    screen->extensions[i++] = &r300TexBufferExtension.base;
 #endif
 
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R600)
+#if defined(RADEON_R600)
    screen->extensions[i++] = &r600TexBufferExtension.base;
 #endif
 
@@ -1589,22 +1589,22 @@ radeonDestroyBuffer(__DRIdrawablePrivate *driDrawPriv)
 static const __DRIconfig **
 radeonInitScreen(__DRIscreenPrivate *psp)
 {
-#if !RADEON_COMMON
+#if defined(RADEON_R100)
    static const char *driver_name = "Radeon";
    static const __DRIutilversion2 ddx_expected = { 4, 5, 0, 0 };
    static const __DRIversion dri_expected = { 4, 0, 0 };
    static const __DRIversion drm_expected = { 1, 6, 0 };
-#elif RADEON_COMMON && defined(RADEON_COMMON_FOR_R200)
+#elif defined(RADEON_R200)
    static const char *driver_name = "R200";
    static const __DRIutilversion2 ddx_expected = { 4, 5, 0, 0 };
    static const __DRIversion dri_expected = { 4, 0, 0 };
    static const __DRIversion drm_expected = { 1, 6, 0 };
-#elif RADEON_COMMON && defined(RADEON_COMMON_FOR_R300)
+#elif defined(RADEON_R300)
    static const char *driver_name = "R300";
    static const __DRIutilversion2 ddx_expected = { 4, 5, 0, 0 };
    static const __DRIversion dri_expected = { 4, 0, 0 };
    static const __DRIversion drm_expected = { 1, 24, 0 };
-#elif RADEON_COMMON && defined(RADEON_COMMON_FOR_R600)
+#elif defined(RADEON_R600)
    static const char *driver_name = "R600";
    static const __DRIutilversion2 ddx_expected = { 4, 5, 0, 0 };
    static const __DRIversion dri_expected = { 4, 0, 0 };
@@ -1630,13 +1630,13 @@ radeonInitScreen(__DRIscreenPrivate *psp)
     * Hello chicken.  Hello egg.  How are you two today?
     */
    driInitExtensions( NULL, card_extensions, GL_FALSE );
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R200)
+#if defined(RADEON_R200)
    driInitExtensions( NULL, blend_extensions, GL_FALSE );
    driInitSingleExtension( NULL, ARB_vp_extension );
    driInitSingleExtension( NULL, NV_vp_extension );
    driInitSingleExtension( NULL, ATI_fs_extension );
    driInitExtensions( NULL, point_extensions, GL_FALSE );
-#elif (defined(RADEON_COMMON_FOR_R300) || defined(RADEON_COMMON_FOR_R600))
+#elif (defined(RADEON_R300) || defined(RADEON_R600))
    driInitSingleExtension( NULL, gl_20_extension );
 #endif
 
@@ -1684,13 +1684,13 @@ __DRIconfig **radeonInitScreen2(__DRIscreenPrivate *psp)
     */
    driInitExtensions( NULL, card_extensions, GL_FALSE );
    driInitExtensions( NULL, mm_extensions, GL_FALSE );
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R200)
+#if defined(RADEON_R200)
    driInitExtensions( NULL, blend_extensions, GL_FALSE );
    driInitSingleExtension( NULL, ARB_vp_extension );
    driInitSingleExtension( NULL, NV_vp_extension );
    driInitSingleExtension( NULL, ATI_fs_extension );
    driInitExtensions( NULL, point_extensions, GL_FALSE );
-#elif (defined(RADEON_COMMON_FOR_R300) || defined(RADEON_COMMON_FOR_R600))
+#elif (defined(RADEON_R300) || defined(RADEON_R600))
    driInitSingleExtension( NULL, gl_20_extension );
 #endif
 
@@ -1772,13 +1772,13 @@ getSwapInfo( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo )
 const struct __DriverAPIRec driDriverAPI = {
    .InitScreen      = radeonInitScreen,
    .DestroyScreen   = radeonDestroyScreen,
-#if RADEON_COMMON && defined(RADEON_COMMON_FOR_R200)
+#if defined(RADEON_R200)
    .CreateContext   = r200CreateContext,
    .DestroyContext  = r200DestroyContext,
-#elif RADEON_COMMON && defined(RADEON_COMMON_FOR_R600)
+#elif defined(RADEON_R600)
    .CreateContext   = r600CreateContext,
    .DestroyContext  = radeonDestroyContext,
-#elif RADEON_COMMON && defined(RADEON_COMMON_FOR_R300)
+#elif defined(RADEON_R300)
    .CreateContext   = r300CreateContext,
    .DestroyContext  = radeonDestroyContext,
 #else
diff --git a/src/mesa/drivers/dri/radeon/radeon_span.c b/src/mesa/drivers/dri/radeon/radeon_span.c
index 4e100d854e..0c49c3713a 100644
--- a/src/mesa/drivers/dri/radeon/radeon_span.c
+++ b/src/mesa/drivers/dri/radeon/radeon_span.c
@@ -55,7 +55,7 @@ static void radeonSetSpanFunctions(struct radeon_renderbuffer *rrb);
 /* r200 depth buffer is always tiled - this is the formula
    according to the docs unless I typo'ed in it
 */
-#if defined(RADEON_COMMON_FOR_R200)
+#if defined(RADEON_R200)
 static GLubyte *r200_depth_2byte(const struct radeon_renderbuffer * rrb,
 				 GLint x, GLint y)
 {
@@ -106,6 +106,141 @@ static GLubyte *r200_depth_4byte(const struct radeon_renderbuffer * rrb,
 }
 #endif
 
+/* r600 tiling
+ * two main types:
+ * - 1D (akin to macro-linear/micro-tiled on older asics)
+ * - 2D (akin to macro-tiled/micro-tiled on older asics)
+ * only 1D tiling is implemented below
+ */
+#if defined(RADEON_R600)
+static inline GLint r600_1d_tile_helper(const struct radeon_renderbuffer * rrb,
+					GLint x, GLint y, GLint is_depth, GLint is_stencil)
+{
+    GLint element_bytes = rrb->cpp;
+    GLint num_samples = 1;
+    GLint tile_width = 8;
+    GLint tile_height = 8;
+    GLint tile_thickness = 1;
+    GLint pitch_elements = rrb->pitch / element_bytes;
+    GLint height = rrb->base.Height;
+    GLint z = 0;
+    GLint sample_number = 0;
+    /* */
+    GLint tile_bytes;
+    GLint tiles_per_row;
+    GLint tiles_per_slice;
+    GLint slice_offset;
+    GLint tile_row_index;
+    GLint tile_column_index;
+    GLint tile_offset;
+    GLint pixel_number = 0;
+    GLint element_offset;
+    GLint offset = 0;
+
+    tile_bytes = tile_width * tile_height * tile_thickness * element_bytes * num_samples;
+    tiles_per_row = pitch_elements / tile_width;
+    tiles_per_slice = tiles_per_row * (height / tile_height);
+    slice_offset = (z / tile_thickness) * tiles_per_slice * tile_bytes;
+    tile_row_index = y / tile_height;
+    tile_column_index = x / tile_width;
+    tile_offset = ((tile_row_index * tiles_per_row) + tile_column_index) * tile_bytes;
+
+    if (is_depth) {
+	    GLint pixel_offset = 0;
+
+	    pixel_number |= ((x >> 0) & 1) << 0; // pn[0] = x[0]
+	    pixel_number |= ((y >> 0) & 1) << 1; // pn[1] = y[0]
+	    pixel_number |= ((x >> 1) & 1) << 2; // pn[2] = x[1]
+	    pixel_number |= ((y >> 1) & 1) << 3; // pn[3] = y[1]
+	    pixel_number |= ((x >> 2) & 1) << 4; // pn[4] = x[2]
+	    pixel_number |= ((y >> 2) & 1) << 5; // pn[5] = y[2]
+	    switch (element_bytes) {
+	    case 2:
+		    pixel_offset = pixel_number * element_bytes * num_samples;
+		    break;
+	    case 4:
+		    /* stencil and depth data are stored separately within a tile.
+		     * stencil is stored in a contiguous tile before the depth tile.
+		     * stencil element is 1 byte, depth element is 3 bytes.
+		     * stencil tile is 64 bytes.
+		     */
+		    if (is_stencil)
+			    pixel_offset = pixel_number * 1 * num_samples;
+		    else
+			    pixel_offset = (pixel_number * 3 * num_samples) + 64;
+		    break;
+	    }
+	    element_offset = pixel_offset + (sample_number * element_bytes);
+    } else {
+	    GLint sample_offset;
+
+	    switch (element_bytes) {
+	    case 1:
+		    pixel_number |= ((x >> 0) & 1) << 0; // pn[0] = x[0]
+		    pixel_number |= ((x >> 1) & 1) << 1; // pn[1] = x[1]
+		    pixel_number |= ((x >> 2) & 1) << 2; // pn[2] = x[2]
+		    pixel_number |= ((y >> 1) & 1) << 3; // pn[3] = y[1]
+		    pixel_number |= ((y >> 0) & 1) << 4; // pn[4] = y[0]
+		    pixel_number |= ((y >> 2) & 1) << 5; // pn[5] = y[2]
+		    break;
+	    case 2:
+		    pixel_number |= ((x >> 0) & 1) << 0; // pn[0] = x[0]
+		    pixel_number |= ((x >> 1) & 1) << 1; // pn[1] = x[1]
+		    pixel_number |= ((x >> 2) & 1) << 2; // pn[2] = x[2]
+		    pixel_number |= ((y >> 0) & 1) << 3; // pn[3] = y[0]
+		    pixel_number |= ((y >> 1) & 1) << 4; // pn[4] = y[1]
+		    pixel_number |= ((y >> 2) & 1) << 5; // pn[5] = y[2]
+		    break;
+	    case 4:
+		    pixel_number |= ((x >> 0) & 1) << 0; // pn[0] = x[0]
+		    pixel_number |= ((x >> 1) & 1) << 1; // pn[1] = x[1]
+		    pixel_number |= ((y >> 0) & 1) << 2; // pn[2] = y[0]
+		    pixel_number |= ((x >> 2) & 1) << 3; // pn[3] = x[2]
+		    pixel_number |= ((y >> 1) & 1) << 4; // pn[4] = y[1]
+		    pixel_number |= ((y >> 2) & 1) << 5; // pn[5] = y[2]
+		    break;
+	    }
+	    sample_offset = sample_number * (tile_bytes / num_samples);
+	    element_offset = sample_offset + (pixel_number * element_bytes);
+    }
+    offset = slice_offset + tile_offset + element_offset;
+    return offset;
+}
+
+/* depth buffers */
+static GLubyte *r600_ptr_depth(const struct radeon_renderbuffer * rrb,
+			       GLint x, GLint y)
+{
+    GLubyte *ptr = rrb->bo->ptr;
+    GLint offset = r600_1d_tile_helper(rrb, x, y, 1, 0);
+    return &ptr[offset];
+}
+
+static GLubyte *r600_ptr_stencil(const struct radeon_renderbuffer * rrb,
+				 GLint x, GLint y)
+{
+    GLubyte *ptr = rrb->bo->ptr;
+    GLint offset = r600_1d_tile_helper(rrb, x, y, 1, 1);
+    return &ptr[offset];
+}
+
+static GLubyte *r600_ptr_color(const struct radeon_renderbuffer * rrb,
+			       GLint x, GLint y)
+{
+    GLubyte *ptr = rrb->bo->ptr;
+    uint32_t mask = RADEON_BO_FLAGS_MACRO_TILE | RADEON_BO_FLAGS_MICRO_TILE;
+    GLint offset;
+
+    if (rrb->has_surface || !(rrb->bo->flags & mask)) {
+        offset = x * rrb->cpp + y * rrb->pitch;
+    } else {
+	    offset = r600_1d_tile_helper(rrb, x, y, 0, 0);
+    }
+    return &ptr[offset];
+}
+
+#else
+
 /* radeon tiling on r300-r500 has 4 states,
    macro-linear/micro-linear
    macro-linear/micro-tiled
@@ -197,7 +332,10 @@ static GLubyte *radeon_ptr_2byte_8x2(const struct radeon_renderbuffer * rrb,
     return &ptr[offset];
 }
 
-#ifndef COMPILE_R300
+#endif
+
+#ifndef RADEON_R300
+#ifndef RADEON_R600
 static uint32_t
 z24s8_to_s8z24(uint32_t val)
 {
@@ -210,6 +348,7 @@ s8z24_to_z24s8(uint32_t val)
    return (val >> 24) | (val << 8);
 }
 #endif
+#endif
 
 /*
  * Note that all information needed to access pixels in a renderbuffer
@@ -270,7 +409,11 @@ s8z24_to_z24s8(uint32_t val)
 
 #define TAG(x)    radeon##x##_RGB565
 #define TAG2(x,y) radeon##x##_RGB565##y
+#if defined(RADEON_R600)
+#define GET_PTR(X,Y) r600_ptr_color(rrb, (X) + x_off, (Y) + y_off)
+#else
 #define GET_PTR(X,Y) radeon_ptr_2byte_8x2(rrb, (X) + x_off, (Y) + y_off)
+#endif
 #include "spantmp2.h"
 
 /* 16 bit, ARGB1555 color spanline and pixel functions
@@ -280,7 +423,11 @@ s8z24_to_z24s8(uint32_t val)
 
 #define TAG(x)    radeon##x##_ARGB1555
 #define TAG2(x,y) radeon##x##_ARGB1555##y
+#if defined(RADEON_R600)
+#define GET_PTR(X,Y) r600_ptr_color(rrb, (X) + x_off, (Y) + y_off)
+#else
 #define GET_PTR(X,Y) radeon_ptr_2byte_8x2(rrb, (X) + x_off, (Y) + y_off)
+#endif
 #include "spantmp2.h"
 
 /* 16 bit, RGBA4 color spanline and pixel functions
@@ -290,7 +437,11 @@ s8z24_to_z24s8(uint32_t val)
 
 #define TAG(x)    radeon##x##_ARGB4444
 #define TAG2(x,y) radeon##x##_ARGB4444##y
+#if defined(RADEON_R600)
+#define GET_PTR(X,Y) r600_ptr_color(rrb, (X) + x_off, (Y) + y_off)
+#else
 #define GET_PTR(X,Y) radeon_ptr_2byte_8x2(rrb, (X) + x_off, (Y) + y_off)
+#endif
 #include "spantmp2.h"
 
 /* 32 bit, xRGB8888 color spanline and pixel functions
@@ -300,11 +451,19 @@ s8z24_to_z24s8(uint32_t val)
 
 #define TAG(x)    radeon##x##_xRGB8888
 #define TAG2(x,y) radeon##x##_xRGB8888##y
+#if defined(RADEON_R600)
+#define GET_VALUE(_x, _y) ((*(GLuint*)(r600_ptr_color(rrb, _x + x_off, _y + y_off)) | 0xff000000))
+#define PUT_VALUE(_x, _y, d) { \
+   GLuint *_ptr = (GLuint*)r600_ptr_color( rrb, _x + x_off, _y + y_off );		\
+   *_ptr = d;								\
+} while (0)
+#else
 #define GET_VALUE(_x, _y) ((*(GLuint*)(radeon_ptr_4byte(rrb, _x + x_off, _y + y_off)) | 0xff000000))
 #define PUT_VALUE(_x, _y, d) { \
    GLuint *_ptr = (GLuint*)radeon_ptr_4byte( rrb, _x + x_off, _y + y_off );		\
    *_ptr = d;								\
 } while (0)
+#endif
 #include "spantmp2.h"
 
 /* 32 bit, ARGB8888 color spanline and pixel functions
@@ -314,11 +473,19 @@ s8z24_to_z24s8(uint32_t val)
 
 #define TAG(x)    radeon##x##_ARGB8888
 #define TAG2(x,y) radeon##x##_ARGB8888##y
+#if defined(RADEON_R600)
+#define GET_VALUE(_x, _y) (*(GLuint*)(r600_ptr_color(rrb, _x + x_off, _y + y_off)))
+#define PUT_VALUE(_x, _y, d) { \
+   GLuint *_ptr = (GLuint*)r600_ptr_color( rrb, _x + x_off, _y + y_off );		\
+   *_ptr = d;								\
+} while (0)
+#else
 #define GET_VALUE(_x, _y) (*(GLuint*)(radeon_ptr_4byte(rrb, _x + x_off, _y + y_off)))
 #define PUT_VALUE(_x, _y, d) { \
    GLuint *_ptr = (GLuint*)radeon_ptr_4byte( rrb, _x + x_off, _y + y_off );		\
    *_ptr = d;								\
 } while (0)
+#endif
 #include "spantmp2.h"
 
 /* ================================================================
@@ -339,17 +506,23 @@ s8z24_to_z24s8(uint32_t val)
  */
 #define VALUE_TYPE GLushort
 
-#if defined(RADEON_COMMON_FOR_R200)
+#if defined(RADEON_R200)
 #define WRITE_DEPTH( _x, _y, d )					\
    *(GLushort *)r200_depth_2byte(rrb, _x + x_off, _y + y_off) = d
+#elif defined(RADEON_R600)
+#define WRITE_DEPTH( _x, _y, d )					\
+   *(GLushort *)r600_ptr_depth(rrb, _x + x_off, _y + y_off) = d
 #else
 #define WRITE_DEPTH( _x, _y, d )					\
    *(GLushort *)radeon_ptr_2byte_8x2(rrb, _x + x_off, _y + y_off) = d
 #endif
 
-#if defined(RADEON_COMMON_FOR_R200)
+#if defined(RADEON_R200)
 #define READ_DEPTH( d, _x, _y )						\
    d = *(GLushort *)r200_depth_2byte(rrb, _x + x_off, _y + y_off)
+#elif defined(RADEON_R600)
+#define READ_DEPTH( d, _x, _y )						\
+   d = *(GLushort *)r600_ptr_depth(rrb, _x + x_off, _y + y_off)
 #else
 #define READ_DEPTH( d, _x, _y )						\
    d = *(GLushort *)radeon_ptr_2byte_8x2(rrb, _x + x_off, _y + y_off)
@@ -365,7 +538,7 @@ s8z24_to_z24s8(uint32_t val)
  */
 #define VALUE_TYPE GLuint
 
-#if defined(COMPILE_R300)
+#if defined(RADEON_R300)
 #define WRITE_DEPTH( _x, _y, d )					\
 do {									\
    GLuint *_ptr = (GLuint*)radeon_ptr_4byte( rrb, _x + x_off, _y + y_off );		\
@@ -374,7 +547,16 @@ do {									\
    tmp |= ((d << 8) & 0xffffff00);					\
    *_ptr = tmp;					\
 } while (0)
-#elif defined(RADEON_COMMON_FOR_R200)
+#elif defined(RADEON_R600)
+#define WRITE_DEPTH( _x, _y, d )					\
+do {									\
+   GLuint *_ptr = (GLuint*)r600_ptr_depth( rrb, _x + x_off, _y + y_off );		\
+   GLuint tmp = *_ptr;				\
+   tmp &= 0xff000000;							\
+   tmp |= ((d) & 0x00ffffff);					\
+   *_ptr = tmp;					\
+} while (0)
+#elif defined(RADEON_R200)
 #define WRITE_DEPTH( _x, _y, d )					\
 do {									\
    GLuint *_ptr = (GLuint*)r200_depth_4byte( rrb, _x + x_off, _y + y_off );		\
@@ -394,12 +576,17 @@ do {									\
 } while (0)
 #endif
 
-#if defined(COMPILE_R300)
+#if defined(RADEON_R300)
 #define READ_DEPTH( d, _x, _y )						\
   do {									\
     d = (*(GLuint*)(radeon_ptr_4byte(rrb, _x + x_off, _y + y_off)) & 0xffffff00) >> 8; \
   }while(0)
-#elif defined(RADEON_COMMON_FOR_R200)
+#elif defined(RADEON_R600)
+#define READ_DEPTH( d, _x, _y )						\
+  do {									\
+    d = (*(GLuint*)(r600_ptr_depth(rrb, _x + x_off, _y + y_off)) & 0x00ffffff); \
+  }while(0)
+#elif defined(RADEON_R200)
 #define READ_DEPTH( d, _x, _y )						\
   do {									\
     d = *(GLuint*)(r200_depth_4byte(rrb, _x + x_off, _y + y_off)) & 0x00ffffff; \
@@ -420,13 +607,27 @@ do {									\
  */
 #define VALUE_TYPE GLuint
 
-#if defined(COMPILE_R300)
+#if defined(RADEON_R300)
 #define WRITE_DEPTH( _x, _y, d )					\
 do {									\
    GLuint *_ptr = (GLuint*)radeon_ptr_4byte( rrb, _x + x_off, _y + y_off );		\
    *_ptr = d;								\
 } while (0)
-#elif defined(RADEON_COMMON_FOR_R200)
+#elif defined(RADEON_R600)
+#define WRITE_DEPTH( _x, _y, d )					\
+do {									\
+   GLuint *_ptr = (GLuint*)r600_ptr_depth( rrb, _x + x_off, _y + y_off );		\
+   GLuint tmp = *_ptr;				\
+   tmp &= 0xff000000;							\
+   tmp |= (((d) >> 8) & 0x00ffffff);					\
+   *_ptr = tmp;					\
+   _ptr = (GLuint*)r600_ptr_stencil(rrb, _x + x_off, _y + y_off);		\
+   tmp = *_ptr;				\
+   tmp &= 0xffffff00;							\
+   tmp |= (d) & 0xff;							\
+   *_ptr = tmp;					\
+} while (0)
+#elif defined(RADEON_R200)
 #define WRITE_DEPTH( _x, _y, d )					\
 do {									\
    GLuint *_ptr = (GLuint*)r200_depth_4byte( rrb, _x + x_off, _y + y_off );		\
@@ -442,12 +643,18 @@ do {									\
 } while (0)
 #endif
 
-#if defined(COMPILE_R300)
+#if defined(RADEON_R300)
 #define READ_DEPTH( d, _x, _y )						\
   do { \
     d = (*(GLuint*)(radeon_ptr_4byte(rrb, _x + x_off, _y + y_off)));	\
   }while(0)
-#elif defined(RADEON_COMMON_FOR_R200)
+#elif defined(RADEON_R600)
+#define READ_DEPTH( d, _x, _y )						\
+  do { \
+    d = ((*(GLuint*)(r600_ptr_depth(rrb, _x + x_off, _y + y_off))) << 8) & 0xffffff00; \
+    d |= (*(GLuint*)(r600_ptr_stencil(rrb, _x + x_off, _y + y_off))) & 0x000000ff;	\
+  }while(0)
+#elif defined(RADEON_R200)
 #define READ_DEPTH( d, _x, _y )						\
   do { \
     d = s8z24_to_z24s8(*(GLuint*)(r200_depth_4byte(rrb, _x + x_off, _y + y_off)));	\
@@ -467,7 +674,7 @@ do {									\
 
 /* 24 bit depth, 8 bit stencil depthbuffer functions
  */
-#ifdef COMPILE_R300
+#ifdef RADEON_R300
 #define WRITE_STENCIL( _x, _y, d )					\
 do {									\
    GLuint *_ptr = (GLuint*)radeon_ptr_4byte(rrb, _x + x_off, _y + y_off);		\
@@ -476,7 +683,16 @@ do {									\
    tmp |= (d) & 0xff;							\
    *_ptr = tmp;					\
 } while (0)
-#elif defined(RADEON_COMMON_FOR_R200)
+#elif defined(RADEON_R600)
+#define WRITE_STENCIL( _x, _y, d )					\
+do {									\
+   GLuint *_ptr = (GLuint*)r600_ptr_stencil(rrb, _x + x_off, _y + y_off);		\
+   GLuint tmp = *_ptr;				\
+   tmp &= 0xffffff00;							\
+   tmp |= (d) & 0xff;							\
+   *_ptr = tmp;					\
+} while (0)
+#elif defined(RADEON_R200)
 #define WRITE_STENCIL( _x, _y, d )					\
 do {									\
    GLuint *_ptr = (GLuint*)r200_depth_4byte(rrb, _x + x_off, _y + y_off);		\
@@ -496,14 +712,21 @@ do {									\
 } while (0)
 #endif
 
-#ifdef COMPILE_R300
+#ifdef RADEON_R300
 #define READ_STENCIL( d, _x, _y )					\
 do {									\
    GLuint *_ptr = (GLuint*)radeon_ptr_4byte( rrb, _x + x_off, _y + y_off );		\
    GLuint tmp = *_ptr;				\
    d = tmp & 0x000000ff;						\
 } while (0)
-#elif defined(RADEON_COMMON_FOR_R200)
+#elif defined(RADEON_R600)
+#define READ_STENCIL( d, _x, _y )					\
+do {									\
+   GLuint *_ptr = (GLuint*)r600_ptr_stencil( rrb, _x + x_off, _y + y_off );		\
+   GLuint tmp = *_ptr;				\
+   d = tmp & 0x000000ff;						\
+} while (0)
+#elif defined(RADEON_R200)
 #define READ_STENCIL( d, _x, _y )					\
 do {									\
    GLuint *_ptr = (GLuint*)r200_depth_4byte( rrb, _x + x_off, _y + y_off );		\
diff --git a/src/mesa/drivers/dri/radeon/radeon_texstate.c b/src/mesa/drivers/dri/radeon/radeon_texstate.c
index 9d252aa74c..ae41b90efe 100644
--- a/src/mesa/drivers/dri/radeon/radeon_texstate.c
+++ b/src/mesa/drivers/dri/radeon/radeon_texstate.c
@@ -833,11 +833,14 @@ static void import_tex_obj_state( r100ContextPtr rmesa,
    cmd[TEX_PP_TXFORMAT] |= texobj->pp_txformat & TEXOBJ_TXFORMAT_MASK;
    cmd[TEX_PP_BORDER_COLOR] = texobj->pp_border_color;
 
-   if (texobj->base.Target == GL_TEXTURE_RECTANGLE_NV) {
-      GLuint *txr_cmd = RADEON_DB_STATE( txr[unit] );
+   if (texobj->pp_txformat & RADEON_TXFORMAT_NON_POWER2) {
+      uint32_t *txr_cmd = &rmesa->hw.txr[unit].cmd[TXR_CMD_0];
       txr_cmd[TXR_PP_TEX_SIZE] = texobj->pp_txsize; /* NPOT only! */
       txr_cmd[TXR_PP_TEX_PITCH] = texobj->pp_txpitch; /* NPOT only! */
-      RADEON_DB_STATECHANGE( rmesa, &rmesa->hw.txr[unit] );
+      RADEON_STATECHANGE( rmesa, txr[unit] );
+   }
+
+   if (texobj->base.Target == GL_TEXTURE_RECTANGLE_NV) {
       se_coord_fmt |= RADEON_VTX_ST0_NONPARAMETRIC << unit;
    }
    else {
@@ -1114,7 +1117,6 @@ static GLboolean radeon_validate_texture(GLcontext *ctx, struct gl_texture_objec
    RADEON_STATECHANGE( rmesa, ctx );
    rmesa->hw.ctx.cmd[CTX_PP_CNTL] |= 
      (RADEON_TEX_0_ENABLE | RADEON_TEX_BLEND_0_ENABLE) << unit;
-
    RADEON_STATECHANGE( rmesa, tcl );
    rmesa->hw.tcl.cmd[TCL_OUTPUT_VTXFMT] |= RADEON_ST_BIT(unit);
 
diff --git a/src/mesa/drivers/dri/radeon/radeon_texture.c b/src/mesa/drivers/dri/radeon/radeon_texture.c
index fad3d1ceda..049284ef8c 100644
--- a/src/mesa/drivers/dri/radeon/radeon_texture.c
+++ b/src/mesa/drivers/dri/radeon/radeon_texture.c
@@ -659,11 +659,6 @@ static void radeon_teximage(
 			if (dims == 3)
 				_mesa_free(dstImageOffsets);
 		}
-
-		/* SGIS_generate_mipmap */
-		if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-			radeon_generate_mipmap(ctx, target, texObj);
-		}
 	}
 
 	_mesa_unmap_teximage_pbo(ctx, packing);
@@ -792,11 +787,6 @@ static void radeon_texsubimage(GLcontext* ctx, int dims, GLenum target, int leve
 							     format, type, pixels, packing))
 				_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
 		}
-
-		/* GL_SGIS_generate_mipmap */
-		if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-			radeon_generate_mipmap(ctx, target, texObj);
-		}
 	}
 
 	radeon_teximage_unmap(image);
diff --git a/src/mesa/drivers/dri/s3v/s3v_tex.c b/src/mesa/drivers/dri/s3v/s3v_tex.c
index 9b92519862..ec1182f34f 100644
--- a/src/mesa/drivers/dri/s3v/s3v_tex.c
+++ b/src/mesa/drivers/dri/s3v/s3v_tex.c
@@ -536,24 +536,13 @@ void s3vInitTextureFuncs( GLcontext *ctx )
 #endif
 
 	ctx->Driver.TexEnv = s3vTexEnv;
-	ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
-	ctx->Driver.TexImage1D = _mesa_store_teximage1d;
 	ctx->Driver.TexImage2D = s3vTexImage2D;
-	ctx->Driver.TexImage3D = _mesa_store_teximage3d;
-	ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
 	ctx->Driver.TexSubImage2D = s3vTexSubImage2D;
-	ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
-	ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
-	ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
-	ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
-	ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
-	ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
 	ctx->Driver.BindTexture = s3vBindTexture;
 	ctx->Driver.DeleteTexture = s3vDeleteTexture;
 	ctx->Driver.TexParameter = s3vTexParameter;
 	ctx->Driver.UpdateTexturePalette = 0;
 	ctx->Driver.IsTextureResident = s3vIsTextureResident;
-	ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
 
 	s3vInitTextureObjects( ctx );
 }
diff --git a/src/mesa/drivers/dri/swrast/swrast.c b/src/mesa/drivers/dri/swrast/swrast.c
index a858af30c1..cd499cd5d2 100644
--- a/src/mesa/drivers/dri/swrast/swrast.c
+++ b/src/mesa/drivers/dri/swrast/swrast.c
@@ -43,6 +43,7 @@
 #include "tnl/t_pipeline.h"
 #include "vbo/vbo.h"
 #include "drivers/common/driverfuncs.h"
+#include "drivers/common/meta.h"
 #include "utils.h"
 
 #include "swrast_priv.h"
@@ -62,6 +63,7 @@
 #define need_GL_SGI_color_table
 
 /* sw extensions not associated with some GL version */
+#define need_GL_ARB_draw_elements_base_vertex
 #define need_GL_ARB_shader_objects
 #define need_GL_ARB_vertex_array_object
 #define need_GL_ARB_vertex_program
@@ -95,6 +97,8 @@ const struct dri_extension card_extensions[] =
     { "GL_EXT_histogram",		GL_EXT_histogram_functions },
     { "GL_SGI_color_table",		GL_SGI_color_table_functions },
 
+    { "GL_ARB_depth_clamp",		NULL },
+    { "GL_ARB_draw_elements_base_vertex", GL_ARB_draw_elements_base_vertex_functions },
     { "GL_ARB_shader_objects",		GL_ARB_shader_objects_functions },
     { "GL_ARB_vertex_array_object",	GL_ARB_vertex_array_object_functions },
     { "GL_ARB_vertex_program",		GL_ARB_vertex_program_functions },
@@ -109,6 +113,7 @@ const struct dri_extension card_extensions[] =
     { "GL_EXT_paletted_texture",	GL_EXT_paletted_texture_functions },
     { "GL_EXT_stencil_two_side",	GL_EXT_stencil_two_side_functions },
     { "GL_MESA_resize_buffers",		GL_MESA_resize_buffers_functions },
+    { "GL_NV_depth_clamp",		NULL },
     { "GL_NV_vertex_program",		GL_NV_vertex_program_functions },
     { "GL_NV_fragment_program",		GL_NV_fragment_program_functions },
     { NULL,				NULL }
@@ -645,6 +650,8 @@ driCreateNewContext(__DRIscreen *screen, const __DRIconfig *config,
     _mesa_enable_2_0_extensions(mesaCtx);
     _mesa_enable_2_1_extensions(mesaCtx);
 
+    _mesa_meta_init(mesaCtx);
+
     return ctx;
 }
 
@@ -656,6 +663,7 @@ driDestroyContext(__DRIcontext *ctx)
 
     if (ctx) {
 	mesaCtx = &ctx->Base;
+        _mesa_meta_free(mesaCtx);
 	_swsetup_DestroyContext( mesaCtx );
 	_swrast_DestroyContext( mesaCtx );
 	_tnl_DestroyContext( mesaCtx );
diff --git a/src/mesa/drivers/dri/tdfx/tdfx_tex.c b/src/mesa/drivers/dri/tdfx/tdfx_tex.c
index 1f7257eaea..f6a48b3ae1 100644
--- a/src/mesa/drivers/dri/tdfx/tdfx_tex.c
+++ b/src/mesa/drivers/dri/tdfx/tdfx_tex.c
@@ -176,6 +176,54 @@ logbase2(int n)
 }
 
 
+static void
+tdfxGenerateMipmap(GLcontext *ctx, GLenum target,
+                   struct gl_texture_object *texObj)
+{
+   GLint mipWidth, mipHeight;
+   tdfxMipMapLevel *mip;
+   struct gl_texture_image *mipImage; /* the new/next image */
+   struct gl_texture_image *texImage;
+   const GLint maxLevels = _mesa_max_texture_levels(ctx, texObj->Target);
+   GLint level = texObj->BaseLevel;
+   GLsizei width, height, texelBytes;
+   const tdfxMipMapLevel *mml;
+
+   texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+   assert(!texImage->IsCompressed);
+
+   mml = TDFX_TEXIMAGE_DATA(texImage);
+
+   width = texImage->Width;
+   height = texImage->Height;
+   while (level < texObj->MaxLevel && level < maxLevels - 1) {
+      mipWidth = width / 2;
+      if (!mipWidth) {
+         mipWidth = 1;
+      }
+      mipHeight = height / 2;
+      if (!mipHeight) {
+         mipHeight = 1;
+      }
+      if ((mipWidth == width) && (mipHeight == height)) {
+         break;
+      }
+      ++level;
+      mipImage = _mesa_select_tex_image(ctx, texObj, target, level);
+      mip = TDFX_TEXIMAGE_DATA(mipImage);
+      _mesa_halve2x2_teximage2d(ctx,
+                                texImage,
+                                texelBytes,
+                                mml->width, mml->height,
+                                texImage->Data, mipImage->Data);
+      texImage = mipImage;
+      mml = mip;
+      width = mipWidth;
+      height = mipHeight;
+   }
+}
+
+
 /*
  * Compute various texture image parameters.
  * Input:  w, h - source texture width and height
@@ -1397,45 +1445,6 @@ tdfxTexImage2D(GLcontext *ctx, GLenum target, GLint level,
                                           width, height, 1,
                                           format, type, pixels, packing);
        }
-
-      /* GL_SGIS_generate_mipmap */
-      if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-         GLint mipWidth, mipHeight;
-         tdfxMipMapLevel *mip;
-         struct gl_texture_image *mipImage;
-         const GLint maxLevels = _mesa_max_texture_levels(ctx, texObj->Target);
-   
-         assert(!texImage->IsCompressed);
-   
-         while (level < texObj->MaxLevel && level < maxLevels - 1) {
-            mipWidth = width / 2;
-            if (!mipWidth) {
-               mipWidth = 1;
-            }
-            mipHeight = height / 2;
-            if (!mipHeight) {
-               mipHeight = 1;
-            }
-            if ((mipWidth == width) && (mipHeight == height)) {
-               break;
-            }
-            _mesa_TexImage2D(target, ++level, internalFormat,
-                             mipWidth, mipHeight, border,
-                             format, type,
-                             NULL);
-            mipImage = _mesa_select_tex_image(ctx, texObj, target, level);
-            mip = TDFX_TEXIMAGE_DATA(mipImage);
-            _mesa_halve2x2_teximage2d(ctx,
-                                      texImage,
-                                      texelBytes,
-                                      mml->width, mml->height,
-                                      texImage->Data, mipImage->Data);
-            texImage = mipImage;
-            mml = mip;
-            width = mipWidth;
-            height = mipHeight;
-         }
-      }
     }
 
     RevalidateTexture(ctx, texObj);
@@ -1507,44 +1516,6 @@ tdfxTexSubImage2D(GLcontext *ctx, GLenum target, GLint level,
                                         format, type, pixels, packing);
     }
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      GLint mipWidth, mipHeight;
-      tdfxMipMapLevel *mip;
-      struct gl_texture_image *mipImage;
-      const GLint maxLevels = _mesa_max_texture_levels(ctx, texObj->Target);
-
-      assert(!texImage->IsCompressed);
-
-      width = texImage->Width;
-      height = texImage->Height;
-      while (level < texObj->MaxLevel && level < maxLevels - 1) {
-         mipWidth = width / 2;
-         if (!mipWidth) {
-            mipWidth = 1;
-         }
-         mipHeight = height / 2;
-         if (!mipHeight) {
-            mipHeight = 1;
-         }
-         if ((mipWidth == width) && (mipHeight == height)) {
-            break;
-         }
-         ++level;
-         mipImage = _mesa_select_tex_image(ctx, texObj, target, level);
-         mip = TDFX_TEXIMAGE_DATA(mipImage);
-         _mesa_halve2x2_teximage2d(ctx,
-                                   texImage,
-                                   texelBytes,
-                                   mml->width, mml->height,
-                                   texImage->Data, mipImage->Data);
-         texImage = mipImage;
-         mml = mip;
-         width = mipWidth;
-         height = mipHeight;
-      }
-   }
-
     ti->reloadImages = GL_TRUE; /* signal the image needs to be reloaded */
     fxMesa->new_state |= TDFX_NEW_TEXTURE;  /* XXX this might be a bit much */
 }
@@ -1703,11 +1674,6 @@ tdfxCompressedTexImage2D (GLcontext *ctx, GLenum target,
        MEMCPY(texImage->Data, data, texImage->CompressedSize);
     }
 
-    /* GL_SGIS_generate_mipmap */
-    if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-       assert(!texImage->IsCompressed);
-    }
-
     RevalidateTexture(ctx, texObj);
 
     ti->reloadImages = GL_TRUE;
@@ -1770,11 +1736,6 @@ tdfxCompressedTexSubImage2D( GLcontext *ctx, GLenum target,
                                 texImage->Data);
     }
 
-    /* GL_SGIS_generate_mipmap */
-    if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-       assert(!texImage->IsCompressed);
-    }
-
     RevalidateTexture(ctx, texObj);
 
     ti->reloadImages = GL_TRUE;
@@ -1914,4 +1875,5 @@ void tdfxInitTextureFuncs( struct dd_function_table *functions )
    functions->CompressedTexImage2D	= tdfxCompressedTexImage2D;
    functions->CompressedTexSubImage2D	= tdfxCompressedTexSubImage2D;
    functions->UpdateTexturePalette      = tdfxUpdateTexturePalette;
+   functions->GenerateMipmap            = tdfxGenerateMipmap;
 }
diff --git a/src/mesa/drivers/dri/unichrome/via_tex.c b/src/mesa/drivers/dri/unichrome/via_tex.c
index d2010f0907..54073e7691 100644
--- a/src/mesa/drivers/dri/unichrome/via_tex.c
+++ b/src/mesa/drivers/dri/unichrome/via_tex.c
@@ -818,11 +818,6 @@ static void viaTexImage(GLcontext *ctx,
       }
    }
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      _mesa_generate_mipmap(ctx, target, texObj);
-   }
-
    _mesa_unmap_teximage_pbo(ctx, packing);
 }
 
diff --git a/src/mesa/drivers/osmesa/osmesa.c b/src/mesa/drivers/osmesa/osmesa.c
index 904659e345..692657a5df 100644
--- a/src/mesa/drivers/osmesa/osmesa.c
+++ b/src/mesa/drivers/osmesa/osmesa.c
@@ -50,6 +50,7 @@
 #include "tnl/t_context.h"
 #include "tnl/t_pipeline.h"
 #include "drivers/common/driverfuncs.h"
+#include "drivers/common/meta.h"
 #include "vbo/vbo.h"
 
 
@@ -1258,6 +1259,8 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
       osmesa->bInd = bind;
       osmesa->aInd = aind;
 
+      _mesa_meta_init(&osmesa->mesa);
+
       /* Initialize the software rasterizer and helper modules. */
       {
 	 GLcontext *ctx = &osmesa->mesa;
@@ -1304,6 +1307,8 @@ OSMesaDestroyContext( OSMesaContext osmesa )
       if (osmesa->rb)
          _mesa_reference_renderbuffer(&osmesa->rb, NULL);
 
+      _mesa_meta_free( &osmesa->mesa );
+
       _swsetup_DestroyContext( &osmesa->mesa );
       _tnl_DestroyContext( &osmesa->mesa );
       _vbo_DestroyContext( &osmesa->mesa );
diff --git a/src/mesa/drivers/windows/gdi/mesa.def b/src/mesa/drivers/windows/gdi/mesa.def
index bd3e5b2137..5abcd1d927 100644
--- a/src/mesa/drivers/windows/gdi/mesa.def
+++ b/src/mesa/drivers/windows/gdi/mesa.def
@@ -943,6 +943,15 @@ EXPORTS
 	_mesa_update_framebuffer_visual
 	_mesa_use_program
 	_mesa_Viewport
+	_mesa_meta_CopyColorSubTable
+	_mesa_meta_CopyColorTable
+	_mesa_meta_CopyConvolutionFilter1D
+	_mesa_meta_CopyConvolutionFilter2D
+	_mesa_meta_CopyTexImage1D
+	_mesa_meta_CopyTexImage2D
+	_mesa_meta_CopyTexSubImage1D
+	_mesa_meta_CopyTexSubImage2D
+	_mesa_meta_CopyTexSubImage3D
 	_mesa_wait_query
 	_swrast_Accum
 	_swrast_Bitmap
@@ -953,15 +962,6 @@ EXPORTS
 	_swrast_Clear
 	_swrast_choose_line
 	_swrast_choose_triangle
-	_swrast_CopyColorSubTable
-	_swrast_CopyColorTable
-	_swrast_CopyConvolutionFilter1D
-	_swrast_CopyConvolutionFilter2D
-	_swrast_copy_teximage1d
-	_swrast_copy_teximage2d
-	_swrast_copy_texsubimage1d
-	_swrast_copy_texsubimage2d
-	_swrast_copy_texsubimage3d
 	_swrast_CreateContext
 	_swrast_DestroyContext
 	_swrast_exec_fragment_program
diff --git a/src/mesa/drivers/windows/gdi/wmesa.c b/src/mesa/drivers/windows/gdi/wmesa.c
index e1971db693..8929b22af1 100644
--- a/src/mesa/drivers/windows/gdi/wmesa.c
+++ b/src/mesa/drivers/windows/gdi/wmesa.c
@@ -12,6 +12,7 @@
 #include "framebuffer.h"
 #include "renderbuffer.h"
 #include "drivers/common/driverfuncs.h"
+#include "drivers/common/meta.h"
 #include "vbo/vbo.h"
 #include "swrast/swrast.h"
 #include "swrast_setup/swrast_setup.h"
@@ -1515,6 +1516,8 @@ WMesaContext WMesaCreateContext(HDC hDC,
     _mesa_enable_2_0_extensions(ctx);
     _mesa_enable_2_1_extensions(ctx);
   
+    _mesa_meta_init(ctx);
+
     /* Initialize the software rasterizer and helper modules. */
     if (!_swrast_CreateContext(ctx) ||
         !_vbo_CreateContext(ctx) ||
@@ -1558,6 +1561,8 @@ void WMesaDestroyContext( WMesaContext pwc )
     DeleteObject(pwc->clearPen); 
     DeleteObject(pwc->clearBrush); 
     
+    _mesa_meta_free(ctx);
+
     _swsetup_DestroyContext(ctx);
     _tnl_DestroyContext(ctx);
     _vbo_DestroyContext(ctx);
diff --git a/src/mesa/drivers/windows/gldirect/mesasw/gld_wgl_mesasw.c b/src/mesa/drivers/windows/gldirect/mesasw/gld_wgl_mesasw.c
index 342a742867..7ac425a109 100644
--- a/src/mesa/drivers/windows/gldirect/mesasw/gld_wgl_mesasw.c
+++ b/src/mesa/drivers/windows/gldirect/mesasw/gld_wgl_mesasw.c
@@ -1346,6 +1346,8 @@ static void wmesa_update_state_first_time(
 	struct swrast_device_driver	*swdd = _swrast_GetDeviceDriverReference( ctx );
 	TNLcontext					*tnl = TNL_CONTEXT(ctx);
 	
+        _mesa_init_driver_functions(&ctx->Driver);
+
 	/*
 	* XXX these function pointers could be initialized just once during
 	* context creation since they don't depend on any state changes.
@@ -1362,8 +1364,6 @@ static void wmesa_update_state_first_time(
 
 	ctx->Driver.Viewport				= wmesa_viewport;
 	
-	ctx->Driver.Accum					= _swrast_Accum;
-	ctx->Driver.Bitmap					= _swrast_Bitmap;
 	ctx->Driver.Clear					= clear;
 	
 	ctx->Driver.Flush					= flush;
@@ -1371,28 +1371,6 @@ static void wmesa_update_state_first_time(
 	ctx->Driver.ClearColor				= clear_color;
 	ctx->Driver.Enable					= enable;
 	
-	ctx->Driver.CopyPixels				= _swrast_CopyPixels;
-	ctx->Driver.DrawPixels				= _swrast_DrawPixels;
-	ctx->Driver.ReadPixels				= _swrast_ReadPixels;
-	
-	ctx->Driver.ChooseTextureFormat		= _mesa_choose_tex_format;
-	ctx->Driver.TexImage1D				= _mesa_store_teximage1d;
-	ctx->Driver.TexImage2D				= _mesa_store_teximage2d;
-	ctx->Driver.TexImage3D				= _mesa_store_teximage3d;
-	ctx->Driver.TexSubImage1D			= _mesa_store_texsubimage1d;
-	ctx->Driver.TexSubImage2D			= _mesa_store_texsubimage2d;
-	ctx->Driver.TexSubImage3D			= _mesa_store_texsubimage3d;
-	ctx->Driver.TestProxyTexImage		= _mesa_test_proxy_teximage;
-	
-	ctx->Driver.CopyTexImage1D			= _swrast_copy_teximage1d;
-	ctx->Driver.CopyTexImage2D			= _swrast_copy_teximage2d;
-	ctx->Driver.CopyTexSubImage1D		= _swrast_copy_texsubimage1d;
-	ctx->Driver.CopyTexSubImage2D		= _swrast_copy_texsubimage2d;
-	ctx->Driver.CopyTexSubImage3D		= _swrast_copy_texsubimage3d;
-	ctx->Driver.CopyColorTable			= _swrast_CopyColorTable;
-	ctx->Driver.CopyColorSubTable		= _swrast_CopyColorSubTable;
-	ctx->Driver.CopyConvolutionFilter1D	= _swrast_CopyConvolutionFilter1D;
-	ctx->Driver.CopyConvolutionFilter2D	= _swrast_CopyConvolutionFilter2D;
 	
 	// Does not apply for Mesa 5.x
 	//ctx->Driver.BaseCompressedTexFormat	= _mesa_base_compressed_texformat;
diff --git a/src/mesa/drivers/windows/icd/mesa.def b/src/mesa/drivers/windows/icd/mesa.def
index 465b380a0c..25ac08a2f0 100644
--- a/src/mesa/drivers/windows/icd/mesa.def
+++ b/src/mesa/drivers/windows/icd/mesa.def
@@ -75,6 +75,15 @@ EXPORTS
 	_mesa_strcmp
 	_mesa_test_proxy_teximage
 	_mesa_Viewport
+	_mesa_meta_CopyColorSubTable
+	_mesa_meta_CopyColorTable
+	_mesa_meta_CopyConvolutionFilter1D
+	_mesa_meta_CopyConvolutionFilter2D
+	_mesa_meta_CopyTexImage1D
+	_mesa_meta_CopyTexImage2D
+	_mesa_meta_CopyTexSubImage1D
+	_mesa_meta_CopyTexSubImage2D
+	_mesa_meta_CopyTexSubImage3D
 	_swrast_Accum
 	_swrast_Bitmap
 	_swrast_CopyPixels
@@ -84,15 +93,6 @@ EXPORTS
 	_swrast_Clear
 	_swrast_choose_line
 	_swrast_choose_triangle
-	_swrast_CopyColorSubTable
-	_swrast_CopyColorTable
-	_swrast_CopyConvolutionFilter1D
-	_swrast_CopyConvolutionFilter2D
-	_swrast_copy_teximage1d
-	_swrast_copy_teximage2d
-	_swrast_copy_texsubimage1d
-	_swrast_copy_texsubimage2d
-	_swrast_copy_texsubimage3d
 	_swrast_CreateContext
 	_swrast_DestroyContext
 	_swrast_InvalidateState
diff --git a/src/mesa/drivers/x11/xm_api.c b/src/mesa/drivers/x11/xm_api.c
index 2c7be9f182..79b058634c 100644
--- a/src/mesa/drivers/x11/xm_api.c
+++ b/src/mesa/drivers/x11/xm_api.c
@@ -1317,6 +1317,7 @@ xmesa_convert_from_x_visual_type( int visualType )
 #define need_GL_SGI_color_table
 
 /* sw extensions not associated with some GL version */
+#define need_GL_ARB_draw_elements_base_vertex
 #define need_GL_ARB_shader_objects
 #define need_GL_ARB_sync
 #define need_GL_ARB_vertex_program
@@ -1347,6 +1348,8 @@ const struct dri_extension card_extensions[] =
    { "GL_EXT_histogram",		GL_EXT_histogram_functions },
    { "GL_SGI_color_table",		GL_SGI_color_table_functions },
 
+   { "GL_ARB_depth_clamp",		NULL },
+   { "GL_ARB_draw_elements_base_vertex", GL_ARB_draw_elements_base_vertex_functions },
    { "GL_ARB_shader_objects",		GL_ARB_shader_objects_functions },
    { "GL_ARB_sync",			GL_ARB_sync_functions },
    { "GL_ARB_vertex_program",		GL_ARB_vertex_program_functions },
@@ -1358,6 +1361,7 @@ const struct dri_extension card_extensions[] =
    { "GL_EXT_gpu_program_parameters",	GL_EXT_gpu_program_parameters_functions },
    { "GL_EXT_paletted_texture",		GL_EXT_paletted_texture_functions },
    { "GL_MESA_resize_buffers",		GL_MESA_resize_buffers_functions },
+   { "GL_NV_depth_clamp",		NULL },
    { "GL_NV_vertex_program",		GL_NV_vertex_program_functions },
    { "GL_NV_fragment_program",		GL_NV_fragment_program_functions },
    { NULL,				NULL }
@@ -1644,8 +1648,7 @@ XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
    xmesa_register_swrast_functions( mesaCtx );
    _swsetup_Wakeup(mesaCtx);
 
-   if (TEST_META_FUNCS)
-      _mesa_meta_init(mesaCtx);
+   _mesa_meta_init(mesaCtx);
 
    return c;
 }
@@ -1661,8 +1664,7 @@ void XMesaDestroyContext( XMesaContext c )
    FXdestroyContext( XMESA_BUFFER(mesaCtx->DrawBuffer) );
 #endif
 
-   if (TEST_META_FUNCS)
-      _mesa_meta_free( mesaCtx );
+   _mesa_meta_free( mesaCtx );
 
    _swsetup_DestroyContext( mesaCtx );
    _swrast_DestroyContext( mesaCtx );
diff --git a/src/mesa/drivers/x11/xm_dd.c b/src/mesa/drivers/x11/xm_dd.c
index 465a40ac8d..e2d4aa9b2d 100644
--- a/src/mesa/drivers/x11/xm_dd.c
+++ b/src/mesa/drivers/x11/xm_dd.c
@@ -1150,10 +1150,11 @@ xmesa_init_driver_functions( XMesaVisual xmvisual,
    driver->Enable = enable;
    driver->Viewport = xmesa_viewport;
    if (TEST_META_FUNCS) {
-      driver->Clear = _mesa_meta_clear;
-      driver->CopyPixels = _mesa_meta_copy_pixels;
-      driver->BlitFramebuffer = _mesa_meta_blit_framebuffer;
-      driver->DrawPixels = _mesa_meta_draw_pixels;
+      driver->Clear = _mesa_meta_Clear;
+      driver->CopyPixels = _mesa_meta_CopyPixels;
+      driver->BlitFramebuffer = _mesa_meta_BlitFramebuffer;
+      driver->DrawPixels = _mesa_meta_DrawPixels;
+      driver->Bitmap = _mesa_meta_Bitmap;
    }
    else {
       driver->Clear = clear_buffers;
@@ -1167,8 +1168,8 @@ xmesa_init_driver_functions( XMesaVisual xmvisual,
       else if (xmvisual->undithered_pf == PF_5R6G5B) {
          driver->DrawPixels = xmesa_DrawPixels_5R6G5B;
       }
-   }
 #endif
+   }
    driver->TestProxyTexImage = test_proxy_teximage;
 #if ENABLE_EXT_texure_compression_s3tc
    driver->ChooseTextureFormat = choose_tex_format;
diff --git a/src/mesa/glapi/ARB_depth_clamp.xml b/src/mesa/glapi/ARB_depth_clamp.xml
new file mode 100644
index 0000000000..157c9a86b1
--- /dev/null
+++ b/src/mesa/glapi/ARB_depth_clamp.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<!DOCTYPE OpenGLAPI SYSTEM "gl_API.dtd">
+
+<OpenGLAPI>
+
+<category name="GL_ARB_depth_clamp" number="61">
+    <enum name="DEPTH_CLAMP" count="1"  value="0x864F">
+        <size name="Get" mode="get"/>
+    </enum>
+</category>
+
+</OpenGLAPI>
diff --git a/src/mesa/glapi/ARB_draw_elements_base_vertex.xml b/src/mesa/glapi/ARB_draw_elements_base_vertex.xml
new file mode 100644
index 0000000000..f4067f4c8d
--- /dev/null
+++ b/src/mesa/glapi/ARB_draw_elements_base_vertex.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0"?>
+<!DOCTYPE OpenGLAPI SYSTEM "gl_API.dtd">
+
+<!-- Note: no GLX protocol info yet. -->
+
+
+<OpenGLAPI>
+
+<category name="GL_ARB_draw_elements_base_vertex" number="62">
+
+    <function name="DrawElementsBaseVertex" offset="assign">
+        <param name="mode" type="GLenum"/>
+        <param name="count" type="GLsizei"/>
+        <param name="type" type="GLenum"/>
+        <param name="indices" type="const GLvoid *"/>
+        <param name="basevertex" type="GLint"/>
+    </function>
+
+    <function name="DrawRangeElementsBaseVertex" offset="assign">
+        <param name="mode" type="GLenum"/>
+        <param name="start" type="GLuint"/>
+        <param name="end" type="GLuint"/>
+        <param name="count" type="GLsizei"/>
+        <param name="type" type="GLenum"/>
+        <param name="indices" type="const GLvoid *"/>
+        <param name="basevertex" type="GLint"/>
+    </function>
+
+    <function name="MultiDrawElementsBaseVertex" offset="assign">
+        <param name="mode" type="GLenum"/>
+        <param name="count" type="const GLsizei *"/>
+        <param name="type" type="GLenum"/>
+        <param name="indices" type="const GLvoid **"/>
+        <param name="primcount" type="GLsizei"/>
+        <param name="basevertex" type="const GLint *"/>
+    </function>
+
+</category>
+
+</OpenGLAPI>
diff --git a/src/mesa/glapi/EXT_provoking_vertex.xml b/src/mesa/glapi/EXT_provoking_vertex.xml
index f528a2c7d3..71d2c72909 100644
--- a/src/mesa/glapi/EXT_provoking_vertex.xml
+++ b/src/mesa/glapi/EXT_provoking_vertex.xml
@@ -19,4 +19,17 @@
 
 </category>
 
+<category name="GL_ARB_provoking_vertex" number="64">
+
+    <enum name="FIRST_VERTEX_CONVENTION"                  value="0x8E4D"/>
+    <enum name="LAST_VERTEX_CONVENTION"                   value="0x8E4E"/>
+    <enum name="PROVOKING_VERTEX"                         value="0x8E4F"/>
+    <enum name="QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION" value="0x8E4C"/>
+
+    <function name="ProvokingVertex" alias="ProvokingVertexEXT">
+        <param name="mode" type="GLenum"/>
+    </function>
+
+</category>
+
 </OpenGLAPI>
diff --git a/src/mesa/glapi/Makefile b/src/mesa/glapi/Makefile
index 65edab7cec..22f65b74c2 100644
--- a/src/mesa/glapi/Makefile
+++ b/src/mesa/glapi/Makefile
@@ -48,6 +48,7 @@ SERVER_OUTPUTS = \
 API_XML = gl_API.xml \
 	EXT_framebuffer_object.xml \
 	ARB_copy_buffer.xml \
+	ARB_depth_clamp.xml \
 	ARB_framebuffer_object.xml \
 	ARB_map_buffer_range.xml \
 	ARB_seamless_cube_map.xml \
diff --git a/src/mesa/glapi/dispatch.h b/src/mesa/glapi/dispatch.h
index 0d32045916..efbd56fa71 100644
--- a/src/mesa/glapi/dispatch.h
+++ b/src/mesa/glapi/dispatch.h
@@ -1782,6 +1782,15 @@
 #define CALL_WaitSync(disp, parameters) (*((disp)->WaitSync)) parameters
 #define GET_WaitSync(disp) ((disp)->WaitSync)
 #define SET_WaitSync(disp, fn) ((disp)->WaitSync = fn)
+#define CALL_DrawElementsBaseVertex(disp, parameters) (*((disp)->DrawElementsBaseVertex)) parameters
+#define GET_DrawElementsBaseVertex(disp) ((disp)->DrawElementsBaseVertex)
+#define SET_DrawElementsBaseVertex(disp, fn) ((disp)->DrawElementsBaseVertex = fn)
+#define CALL_DrawRangeElementsBaseVertex(disp, parameters) (*((disp)->DrawRangeElementsBaseVertex)) parameters
+#define GET_DrawRangeElementsBaseVertex(disp) ((disp)->DrawRangeElementsBaseVertex)
+#define SET_DrawRangeElementsBaseVertex(disp, fn) ((disp)->DrawRangeElementsBaseVertex = fn)
+#define CALL_MultiDrawElementsBaseVertex(disp, parameters) (*((disp)->MultiDrawElementsBaseVertex)) parameters
+#define GET_MultiDrawElementsBaseVertex(disp) ((disp)->MultiDrawElementsBaseVertex)
+#define SET_MultiDrawElementsBaseVertex(disp, fn) ((disp)->MultiDrawElementsBaseVertex = fn)
 #define CALL_PolygonOffsetEXT(disp, parameters) (*((disp)->PolygonOffsetEXT)) parameters
 #define GET_PolygonOffsetEXT(disp) ((disp)->PolygonOffsetEXT)
 #define SET_PolygonOffsetEXT(disp, fn) ((disp)->PolygonOffsetEXT = fn)
@@ -2439,7 +2448,7 @@
 
 #else
 
-#define driDispatchRemapTable_size 384
+#define driDispatchRemapTable_size 387
 extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 
 #define AttachShader_remap_index 0
@@ -2608,224 +2617,227 @@ extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 #define GetSynciv_remap_index 163
 #define IsSync_remap_index 164
 #define WaitSync_remap_index 165
-#define PolygonOffsetEXT_remap_index 166
-#define GetPixelTexGenParameterfvSGIS_remap_index 167
-#define GetPixelTexGenParameterivSGIS_remap_index 168
-#define PixelTexGenParameterfSGIS_remap_index 169
-#define PixelTexGenParameterfvSGIS_remap_index 170
-#define PixelTexGenParameteriSGIS_remap_index 171
-#define PixelTexGenParameterivSGIS_remap_index 172
-#define SampleMaskSGIS_remap_index 173
-#define SamplePatternSGIS_remap_index 174
-#define ColorPointerEXT_remap_index 175
-#define EdgeFlagPointerEXT_remap_index 176
-#define IndexPointerEXT_remap_index 177
-#define NormalPointerEXT_remap_index 178
-#define TexCoordPointerEXT_remap_index 179
-#define VertexPointerEXT_remap_index 180
-#define PointParameterfEXT_remap_index 181
-#define PointParameterfvEXT_remap_index 182
-#define LockArraysEXT_remap_index 183
-#define UnlockArraysEXT_remap_index 184
-#define CullParameterdvEXT_remap_index 185
-#define CullParameterfvEXT_remap_index 186
-#define SecondaryColor3bEXT_remap_index 187
-#define SecondaryColor3bvEXT_remap_index 188
-#define SecondaryColor3dEXT_remap_index 189
-#define SecondaryColor3dvEXT_remap_index 190
-#define SecondaryColor3fEXT_remap_index 191
-#define SecondaryColor3fvEXT_remap_index 192
-#define SecondaryColor3iEXT_remap_index 193
-#define SecondaryColor3ivEXT_remap_index 194
-#define SecondaryColor3sEXT_remap_index 195
-#define SecondaryColor3svEXT_remap_index 196
-#define SecondaryColor3ubEXT_remap_index 197
-#define SecondaryColor3ubvEXT_remap_index 198
-#define SecondaryColor3uiEXT_remap_index 199
-#define SecondaryColor3uivEXT_remap_index 200
-#define SecondaryColor3usEXT_remap_index 201
-#define SecondaryColor3usvEXT_remap_index 202
-#define SecondaryColorPointerEXT_remap_index 203
-#define MultiDrawArraysEXT_remap_index 204
-#define MultiDrawElementsEXT_remap_index 205
-#define FogCoordPointerEXT_remap_index 206
-#define FogCoorddEXT_remap_index 207
-#define FogCoorddvEXT_remap_index 208
-#define FogCoordfEXT_remap_index 209
-#define FogCoordfvEXT_remap_index 210
-#define PixelTexGenSGIX_remap_index 211
-#define BlendFuncSeparateEXT_remap_index 212
-#define FlushVertexArrayRangeNV_remap_index 213
-#define VertexArrayRangeNV_remap_index 214
-#define CombinerInputNV_remap_index 215
-#define CombinerOutputNV_remap_index 216
-#define CombinerParameterfNV_remap_index 217
-#define CombinerParameterfvNV_remap_index 218
-#define CombinerParameteriNV_remap_index 219
-#define CombinerParameterivNV_remap_index 220
-#define FinalCombinerInputNV_remap_index 221
-#define GetCombinerInputParameterfvNV_remap_index 222
-#define GetCombinerInputParameterivNV_remap_index 223
-#define GetCombinerOutputParameterfvNV_remap_index 224
-#define GetCombinerOutputParameterivNV_remap_index 225
-#define GetFinalCombinerInputParameterfvNV_remap_index 226
-#define GetFinalCombinerInputParameterivNV_remap_index 227
-#define ResizeBuffersMESA_remap_index 228
-#define WindowPos2dMESA_remap_index 229
-#define WindowPos2dvMESA_remap_index 230
-#define WindowPos2fMESA_remap_index 231
-#define WindowPos2fvMESA_remap_index 232
-#define WindowPos2iMESA_remap_index 233
-#define WindowPos2ivMESA_remap_index 234
-#define WindowPos2sMESA_remap_index 235
-#define WindowPos2svMESA_remap_index 236
-#define WindowPos3dMESA_remap_index 237
-#define WindowPos3dvMESA_remap_index 238
-#define WindowPos3fMESA_remap_index 239
-#define WindowPos3fvMESA_remap_index 240
-#define WindowPos3iMESA_remap_index 241
-#define WindowPos3ivMESA_remap_index 242
-#define WindowPos3sMESA_remap_index 243
-#define WindowPos3svMESA_remap_index 244
-#define WindowPos4dMESA_remap_index 245
-#define WindowPos4dvMESA_remap_index 246
-#define WindowPos4fMESA_remap_index 247
-#define WindowPos4fvMESA_remap_index 248
-#define WindowPos4iMESA_remap_index 249
-#define WindowPos4ivMESA_remap_index 250
-#define WindowPos4sMESA_remap_index 251
-#define WindowPos4svMESA_remap_index 252
-#define MultiModeDrawArraysIBM_remap_index 253
-#define MultiModeDrawElementsIBM_remap_index 254
-#define DeleteFencesNV_remap_index 255
-#define FinishFenceNV_remap_index 256
-#define GenFencesNV_remap_index 257
-#define GetFenceivNV_remap_index 258
-#define IsFenceNV_remap_index 259
-#define SetFenceNV_remap_index 260
-#define TestFenceNV_remap_index 261
-#define AreProgramsResidentNV_remap_index 262
-#define BindProgramNV_remap_index 263
-#define DeleteProgramsNV_remap_index 264
-#define ExecuteProgramNV_remap_index 265
-#define GenProgramsNV_remap_index 266
-#define GetProgramParameterdvNV_remap_index 267
-#define GetProgramParameterfvNV_remap_index 268
-#define GetProgramStringNV_remap_index 269
-#define GetProgramivNV_remap_index 270
-#define GetTrackMatrixivNV_remap_index 271
-#define GetVertexAttribPointervNV_remap_index 272
-#define GetVertexAttribdvNV_remap_index 273
-#define GetVertexAttribfvNV_remap_index 274
-#define GetVertexAttribivNV_remap_index 275
-#define IsProgramNV_remap_index 276
-#define LoadProgramNV_remap_index 277
-#define ProgramParameters4dvNV_remap_index 278
-#define ProgramParameters4fvNV_remap_index 279
-#define RequestResidentProgramsNV_remap_index 280
-#define TrackMatrixNV_remap_index 281
-#define VertexAttrib1dNV_remap_index 282
-#define VertexAttrib1dvNV_remap_index 283
-#define VertexAttrib1fNV_remap_index 284
-#define VertexAttrib1fvNV_remap_index 285
-#define VertexAttrib1sNV_remap_index 286
-#define VertexAttrib1svNV_remap_index 287
-#define VertexAttrib2dNV_remap_index 288
-#define VertexAttrib2dvNV_remap_index 289
-#define VertexAttrib2fNV_remap_index 290
-#define VertexAttrib2fvNV_remap_index 291
-#define VertexAttrib2sNV_remap_index 292
-#define VertexAttrib2svNV_remap_index 293
-#define VertexAttrib3dNV_remap_index 294
-#define VertexAttrib3dvNV_remap_index 295
-#define VertexAttrib3fNV_remap_index 296
-#define VertexAttrib3fvNV_remap_index 297
-#define VertexAttrib3sNV_remap_index 298
-#define VertexAttrib3svNV_remap_index 299
-#define VertexAttrib4dNV_remap_index 300
-#define VertexAttrib4dvNV_remap_index 301
-#define VertexAttrib4fNV_remap_index 302
-#define VertexAttrib4fvNV_remap_index 303
-#define VertexAttrib4sNV_remap_index 304
-#define VertexAttrib4svNV_remap_index 305
-#define VertexAttrib4ubNV_remap_index 306
-#define VertexAttrib4ubvNV_remap_index 307
-#define VertexAttribPointerNV_remap_index 308
-#define VertexAttribs1dvNV_remap_index 309
-#define VertexAttribs1fvNV_remap_index 310
-#define VertexAttribs1svNV_remap_index 311
-#define VertexAttribs2dvNV_remap_index 312
-#define VertexAttribs2fvNV_remap_index 313
-#define VertexAttribs2svNV_remap_index 314
-#define VertexAttribs3dvNV_remap_index 315
-#define VertexAttribs3fvNV_remap_index 316
-#define VertexAttribs3svNV_remap_index 317
-#define VertexAttribs4dvNV_remap_index 318
-#define VertexAttribs4fvNV_remap_index 319
-#define VertexAttribs4svNV_remap_index 320
-#define VertexAttribs4ubvNV_remap_index 321
-#define GetTexBumpParameterfvATI_remap_index 322
-#define GetTexBumpParameterivATI_remap_index 323
-#define TexBumpParameterfvATI_remap_index 324
-#define TexBumpParameterivATI_remap_index 325
-#define AlphaFragmentOp1ATI_remap_index 326
-#define AlphaFragmentOp2ATI_remap_index 327
-#define AlphaFragmentOp3ATI_remap_index 328
-#define BeginFragmentShaderATI_remap_index 329
-#define BindFragmentShaderATI_remap_index 330
-#define ColorFragmentOp1ATI_remap_index 331
-#define ColorFragmentOp2ATI_remap_index 332
-#define ColorFragmentOp3ATI_remap_index 333
-#define DeleteFragmentShaderATI_remap_index 334
-#define EndFragmentShaderATI_remap_index 335
-#define GenFragmentShadersATI_remap_index 336
-#define PassTexCoordATI_remap_index 337
-#define SampleMapATI_remap_index 338
-#define SetFragmentShaderConstantATI_remap_index 339
-#define PointParameteriNV_remap_index 340
-#define PointParameterivNV_remap_index 341
-#define ActiveStencilFaceEXT_remap_index 342
-#define BindVertexArrayAPPLE_remap_index 343
-#define DeleteVertexArraysAPPLE_remap_index 344
-#define GenVertexArraysAPPLE_remap_index 345
-#define IsVertexArrayAPPLE_remap_index 346
-#define GetProgramNamedParameterdvNV_remap_index 347
-#define GetProgramNamedParameterfvNV_remap_index 348
-#define ProgramNamedParameter4dNV_remap_index 349
-#define ProgramNamedParameter4dvNV_remap_index 350
-#define ProgramNamedParameter4fNV_remap_index 351
-#define ProgramNamedParameter4fvNV_remap_index 352
-#define DepthBoundsEXT_remap_index 353
-#define BlendEquationSeparateEXT_remap_index 354
-#define BindFramebufferEXT_remap_index 355
-#define BindRenderbufferEXT_remap_index 356
-#define CheckFramebufferStatusEXT_remap_index 357
-#define DeleteFramebuffersEXT_remap_index 358
-#define DeleteRenderbuffersEXT_remap_index 359
-#define FramebufferRenderbufferEXT_remap_index 360
-#define FramebufferTexture1DEXT_remap_index 361
-#define FramebufferTexture2DEXT_remap_index 362
-#define FramebufferTexture3DEXT_remap_index 363
-#define GenFramebuffersEXT_remap_index 364
-#define GenRenderbuffersEXT_remap_index 365
-#define GenerateMipmapEXT_remap_index 366
-#define GetFramebufferAttachmentParameterivEXT_remap_index 367
-#define GetRenderbufferParameterivEXT_remap_index 368
-#define IsFramebufferEXT_remap_index 369
-#define IsRenderbufferEXT_remap_index 370
-#define RenderbufferStorageEXT_remap_index 371
-#define BlitFramebufferEXT_remap_index 372
-#define BufferParameteriAPPLE_remap_index 373
-#define FlushMappedBufferRangeAPPLE_remap_index 374
-#define FramebufferTextureLayerEXT_remap_index 375
-#define ProvokingVertexEXT_remap_index 376
-#define GetTexParameterPointervAPPLE_remap_index 377
-#define TextureRangeAPPLE_remap_index 378
-#define StencilFuncSeparateATI_remap_index 379
-#define ProgramEnvParameters4fvEXT_remap_index 380
-#define ProgramLocalParameters4fvEXT_remap_index 381
-#define GetQueryObjecti64vEXT_remap_index 382
-#define GetQueryObjectui64vEXT_remap_index 383
+#define DrawElementsBaseVertex_remap_index 166
+#define DrawRangeElementsBaseVertex_remap_index 167
+#define MultiDrawElementsBaseVertex_remap_index 168
+#define PolygonOffsetEXT_remap_index 169
+#define GetPixelTexGenParameterfvSGIS_remap_index 170
+#define GetPixelTexGenParameterivSGIS_remap_index 171
+#define PixelTexGenParameterfSGIS_remap_index 172
+#define PixelTexGenParameterfvSGIS_remap_index 173
+#define PixelTexGenParameteriSGIS_remap_index 174
+#define PixelTexGenParameterivSGIS_remap_index 175
+#define SampleMaskSGIS_remap_index 176
+#define SamplePatternSGIS_remap_index 177
+#define ColorPointerEXT_remap_index 178
+#define EdgeFlagPointerEXT_remap_index 179
+#define IndexPointerEXT_remap_index 180
+#define NormalPointerEXT_remap_index 181
+#define TexCoordPointerEXT_remap_index 182
+#define VertexPointerEXT_remap_index 183
+#define PointParameterfEXT_remap_index 184
+#define PointParameterfvEXT_remap_index 185
+#define LockArraysEXT_remap_index 186
+#define UnlockArraysEXT_remap_index 187
+#define CullParameterdvEXT_remap_index 188
+#define CullParameterfvEXT_remap_index 189
+#define SecondaryColor3bEXT_remap_index 190
+#define SecondaryColor3bvEXT_remap_index 191
+#define SecondaryColor3dEXT_remap_index 192
+#define SecondaryColor3dvEXT_remap_index 193
+#define SecondaryColor3fEXT_remap_index 194
+#define SecondaryColor3fvEXT_remap_index 195
+#define SecondaryColor3iEXT_remap_index 196
+#define SecondaryColor3ivEXT_remap_index 197
+#define SecondaryColor3sEXT_remap_index 198
+#define SecondaryColor3svEXT_remap_index 199
+#define SecondaryColor3ubEXT_remap_index 200
+#define SecondaryColor3ubvEXT_remap_index 201
+#define SecondaryColor3uiEXT_remap_index 202
+#define SecondaryColor3uivEXT_remap_index 203
+#define SecondaryColor3usEXT_remap_index 204
+#define SecondaryColor3usvEXT_remap_index 205
+#define SecondaryColorPointerEXT_remap_index 206
+#define MultiDrawArraysEXT_remap_index 207
+#define MultiDrawElementsEXT_remap_index 208
+#define FogCoordPointerEXT_remap_index 209
+#define FogCoorddEXT_remap_index 210
+#define FogCoorddvEXT_remap_index 211
+#define FogCoordfEXT_remap_index 212
+#define FogCoordfvEXT_remap_index 213
+#define PixelTexGenSGIX_remap_index 214
+#define BlendFuncSeparateEXT_remap_index 215
+#define FlushVertexArrayRangeNV_remap_index 216
+#define VertexArrayRangeNV_remap_index 217
+#define CombinerInputNV_remap_index 218
+#define CombinerOutputNV_remap_index 219
+#define CombinerParameterfNV_remap_index 220
+#define CombinerParameterfvNV_remap_index 221
+#define CombinerParameteriNV_remap_index 222
+#define CombinerParameterivNV_remap_index 223
+#define FinalCombinerInputNV_remap_index 224
+#define GetCombinerInputParameterfvNV_remap_index 225
+#define GetCombinerInputParameterivNV_remap_index 226
+#define GetCombinerOutputParameterfvNV_remap_index 227
+#define GetCombinerOutputParameterivNV_remap_index 228
+#define GetFinalCombinerInputParameterfvNV_remap_index 229
+#define GetFinalCombinerInputParameterivNV_remap_index 230
+#define ResizeBuffersMESA_remap_index 231
+#define WindowPos2dMESA_remap_index 232
+#define WindowPos2dvMESA_remap_index 233
+#define WindowPos2fMESA_remap_index 234
+#define WindowPos2fvMESA_remap_index 235
+#define WindowPos2iMESA_remap_index 236
+#define WindowPos2ivMESA_remap_index 237
+#define WindowPos2sMESA_remap_index 238
+#define WindowPos2svMESA_remap_index 239
+#define WindowPos3dMESA_remap_index 240
+#define WindowPos3dvMESA_remap_index 241
+#define WindowPos3fMESA_remap_index 242
+#define WindowPos3fvMESA_remap_index 243
+#define WindowPos3iMESA_remap_index 244
+#define WindowPos3ivMESA_remap_index 245
+#define WindowPos3sMESA_remap_index 246
+#define WindowPos3svMESA_remap_index 247
+#define WindowPos4dMESA_remap_index 248
+#define WindowPos4dvMESA_remap_index 249
+#define WindowPos4fMESA_remap_index 250
+#define WindowPos4fvMESA_remap_index 251
+#define WindowPos4iMESA_remap_index 252
+#define WindowPos4ivMESA_remap_index 253
+#define WindowPos4sMESA_remap_index 254
+#define WindowPos4svMESA_remap_index 255
+#define MultiModeDrawArraysIBM_remap_index 256
+#define MultiModeDrawElementsIBM_remap_index 257
+#define DeleteFencesNV_remap_index 258
+#define FinishFenceNV_remap_index 259
+#define GenFencesNV_remap_index 260
+#define GetFenceivNV_remap_index 261
+#define IsFenceNV_remap_index 262
+#define SetFenceNV_remap_index 263
+#define TestFenceNV_remap_index 264
+#define AreProgramsResidentNV_remap_index 265
+#define BindProgramNV_remap_index 266
+#define DeleteProgramsNV_remap_index 267
+#define ExecuteProgramNV_remap_index 268
+#define GenProgramsNV_remap_index 269
+#define GetProgramParameterdvNV_remap_index 270
+#define GetProgramParameterfvNV_remap_index 271
+#define GetProgramStringNV_remap_index 272
+#define GetProgramivNV_remap_index 273
+#define GetTrackMatrixivNV_remap_index 274
+#define GetVertexAttribPointervNV_remap_index 275
+#define GetVertexAttribdvNV_remap_index 276
+#define GetVertexAttribfvNV_remap_index 277
+#define GetVertexAttribivNV_remap_index 278
+#define IsProgramNV_remap_index 279
+#define LoadProgramNV_remap_index 280
+#define ProgramParameters4dvNV_remap_index 281
+#define ProgramParameters4fvNV_remap_index 282
+#define RequestResidentProgramsNV_remap_index 283
+#define TrackMatrixNV_remap_index 284
+#define VertexAttrib1dNV_remap_index 285
+#define VertexAttrib1dvNV_remap_index 286
+#define VertexAttrib1fNV_remap_index 287
+#define VertexAttrib1fvNV_remap_index 288
+#define VertexAttrib1sNV_remap_index 289
+#define VertexAttrib1svNV_remap_index 290
+#define VertexAttrib2dNV_remap_index 291
+#define VertexAttrib2dvNV_remap_index 292
+#define VertexAttrib2fNV_remap_index 293
+#define VertexAttrib2fvNV_remap_index 294
+#define VertexAttrib2sNV_remap_index 295
+#define VertexAttrib2svNV_remap_index 296
+#define VertexAttrib3dNV_remap_index 297
+#define VertexAttrib3dvNV_remap_index 298
+#define VertexAttrib3fNV_remap_index 299
+#define VertexAttrib3fvNV_remap_index 300
+#define VertexAttrib3sNV_remap_index 301
+#define VertexAttrib3svNV_remap_index 302
+#define VertexAttrib4dNV_remap_index 303
+#define VertexAttrib4dvNV_remap_index 304
+#define VertexAttrib4fNV_remap_index 305
+#define VertexAttrib4fvNV_remap_index 306
+#define VertexAttrib4sNV_remap_index 307
+#define VertexAttrib4svNV_remap_index 308
+#define VertexAttrib4ubNV_remap_index 309
+#define VertexAttrib4ubvNV_remap_index 310
+#define VertexAttribPointerNV_remap_index 311
+#define VertexAttribs1dvNV_remap_index 312
+#define VertexAttribs1fvNV_remap_index 313
+#define VertexAttribs1svNV_remap_index 314
+#define VertexAttribs2dvNV_remap_index 315
+#define VertexAttribs2fvNV_remap_index 316
+#define VertexAttribs2svNV_remap_index 317
+#define VertexAttribs3dvNV_remap_index 318
+#define VertexAttribs3fvNV_remap_index 319
+#define VertexAttribs3svNV_remap_index 320
+#define VertexAttribs4dvNV_remap_index 321
+#define VertexAttribs4fvNV_remap_index 322
+#define VertexAttribs4svNV_remap_index 323
+#define VertexAttribs4ubvNV_remap_index 324
+#define GetTexBumpParameterfvATI_remap_index 325
+#define GetTexBumpParameterivATI_remap_index 326
+#define TexBumpParameterfvATI_remap_index 327
+#define TexBumpParameterivATI_remap_index 328
+#define AlphaFragmentOp1ATI_remap_index 329
+#define AlphaFragmentOp2ATI_remap_index 330
+#define AlphaFragmentOp3ATI_remap_index 331
+#define BeginFragmentShaderATI_remap_index 332
+#define BindFragmentShaderATI_remap_index 333
+#define ColorFragmentOp1ATI_remap_index 334
+#define ColorFragmentOp2ATI_remap_index 335
+#define ColorFragmentOp3ATI_remap_index 336
+#define DeleteFragmentShaderATI_remap_index 337
+#define EndFragmentShaderATI_remap_index 338
+#define GenFragmentShadersATI_remap_index 339
+#define PassTexCoordATI_remap_index 340
+#define SampleMapATI_remap_index 341
+#define SetFragmentShaderConstantATI_remap_index 342
+#define PointParameteriNV_remap_index 343
+#define PointParameterivNV_remap_index 344
+#define ActiveStencilFaceEXT_remap_index 345
+#define BindVertexArrayAPPLE_remap_index 346
+#define DeleteVertexArraysAPPLE_remap_index 347
+#define GenVertexArraysAPPLE_remap_index 348
+#define IsVertexArrayAPPLE_remap_index 349
+#define GetProgramNamedParameterdvNV_remap_index 350
+#define GetProgramNamedParameterfvNV_remap_index 351
+#define ProgramNamedParameter4dNV_remap_index 352
+#define ProgramNamedParameter4dvNV_remap_index 353
+#define ProgramNamedParameter4fNV_remap_index 354
+#define ProgramNamedParameter4fvNV_remap_index 355
+#define DepthBoundsEXT_remap_index 356
+#define BlendEquationSeparateEXT_remap_index 357
+#define BindFramebufferEXT_remap_index 358
+#define BindRenderbufferEXT_remap_index 359
+#define CheckFramebufferStatusEXT_remap_index 360
+#define DeleteFramebuffersEXT_remap_index 361
+#define DeleteRenderbuffersEXT_remap_index 362
+#define FramebufferRenderbufferEXT_remap_index 363
+#define FramebufferTexture1DEXT_remap_index 364
+#define FramebufferTexture2DEXT_remap_index 365
+#define FramebufferTexture3DEXT_remap_index 366
+#define GenFramebuffersEXT_remap_index 367
+#define GenRenderbuffersEXT_remap_index 368
+#define GenerateMipmapEXT_remap_index 369
+#define GetFramebufferAttachmentParameterivEXT_remap_index 370
+#define GetRenderbufferParameterivEXT_remap_index 371
+#define IsFramebufferEXT_remap_index 372
+#define IsRenderbufferEXT_remap_index 373
+#define RenderbufferStorageEXT_remap_index 374
+#define BlitFramebufferEXT_remap_index 375
+#define BufferParameteriAPPLE_remap_index 376
+#define FlushMappedBufferRangeAPPLE_remap_index 377
+#define FramebufferTextureLayerEXT_remap_index 378
+#define ProvokingVertexEXT_remap_index 379
+#define GetTexParameterPointervAPPLE_remap_index 380
+#define TextureRangeAPPLE_remap_index 381
+#define StencilFuncSeparateATI_remap_index 382
+#define ProgramEnvParameters4fvEXT_remap_index 383
+#define ProgramLocalParameters4fvEXT_remap_index 384
+#define GetQueryObjecti64vEXT_remap_index 385
+#define GetQueryObjectui64vEXT_remap_index 386
 
 #define CALL_AttachShader(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint)), driDispatchRemapTable[AttachShader_remap_index], parameters)
 #define GET_AttachShader(disp) GET_by_offset(disp, driDispatchRemapTable[AttachShader_remap_index])
@@ -3325,6 +3337,15 @@ extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 #define CALL_WaitSync(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsync, GLbitfield, GLuint64)), driDispatchRemapTable[WaitSync_remap_index], parameters)
 #define GET_WaitSync(disp) GET_by_offset(disp, driDispatchRemapTable[WaitSync_remap_index])
 #define SET_WaitSync(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WaitSync_remap_index], fn)
+#define CALL_DrawElementsBaseVertex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLenum, const GLvoid *, GLint)), driDispatchRemapTable[DrawElementsBaseVertex_remap_index], parameters)
+#define GET_DrawElementsBaseVertex(disp) GET_by_offset(disp, driDispatchRemapTable[DrawElementsBaseVertex_remap_index])
+#define SET_DrawElementsBaseVertex(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DrawElementsBaseVertex_remap_index], fn)
+#define CALL_DrawRangeElementsBaseVertex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *, GLint)), driDispatchRemapTable[DrawRangeElementsBaseVertex_remap_index], parameters)
+#define GET_DrawRangeElementsBaseVertex(disp) GET_by_offset(disp, driDispatchRemapTable[DrawRangeElementsBaseVertex_remap_index])
+#define SET_DrawRangeElementsBaseVertex(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DrawRangeElementsBaseVertex_remap_index], fn)
+#define CALL_MultiDrawElementsBaseVertex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLsizei *, GLenum, const GLvoid **, GLsizei, const GLint *)), driDispatchRemapTable[MultiDrawElementsBaseVertex_remap_index], parameters)
+#define GET_MultiDrawElementsBaseVertex(disp) GET_by_offset(disp, driDispatchRemapTable[MultiDrawElementsBaseVertex_remap_index])
+#define SET_MultiDrawElementsBaseVertex(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiDrawElementsBaseVertex_remap_index], fn)
 #define CALL_PolygonOffsetEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), driDispatchRemapTable[PolygonOffsetEXT_remap_index], parameters)
 #define GET_PolygonOffsetEXT(disp) GET_by_offset(disp, driDispatchRemapTable[PolygonOffsetEXT_remap_index])
 #define SET_PolygonOffsetEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PolygonOffsetEXT_remap_index], fn)
diff --git a/src/mesa/glapi/gl_API.xml b/src/mesa/glapi/gl_API.xml
index 1dfd92be08..da4be14707 100644
--- a/src/mesa/glapi/gl_API.xml
+++ b/src/mesa/glapi/gl_API.xml
@@ -7950,6 +7950,8 @@
 
 <xi:include href="ARB_copy_buffer.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
 
+<xi:include href="ARB_depth_clamp.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+
 <xi:include href="ARB_map_buffer_range.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
 
 <xi:include href="ARB_vertex_array_object.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
@@ -7958,6 +7960,8 @@
 
 <xi:include href="ARB_seamless_cube_map.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
 
+<xi:include href="ARB_draw_elements_base_vertex.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+
 
 <!-- Non-ARB extensions sorted by extension number. -->
 
diff --git a/src/mesa/glapi/glapioffsets.h b/src/mesa/glapi/glapioffsets.h
index 6d4ab09b07..a3807744ff 100644
--- a/src/mesa/glapi/glapioffsets.h
+++ b/src/mesa/glapi/glapioffsets.h
@@ -606,225 +606,228 @@
 #define _gloffset_GetSynciv 571
 #define _gloffset_IsSync 572
 #define _gloffset_WaitSync 573
-#define _gloffset_PolygonOffsetEXT 574
-#define _gloffset_GetPixelTexGenParameterfvSGIS 575
-#define _gloffset_GetPixelTexGenParameterivSGIS 576
-#define _gloffset_PixelTexGenParameterfSGIS 577
-#define _gloffset_PixelTexGenParameterfvSGIS 578
-#define _gloffset_PixelTexGenParameteriSGIS 579
-#define _gloffset_PixelTexGenParameterivSGIS 580
-#define _gloffset_SampleMaskSGIS 581
-#define _gloffset_SamplePatternSGIS 582
-#define _gloffset_ColorPointerEXT 583
-#define _gloffset_EdgeFlagPointerEXT 584
-#define _gloffset_IndexPointerEXT 585
-#define _gloffset_NormalPointerEXT 586
-#define _gloffset_TexCoordPointerEXT 587
-#define _gloffset_VertexPointerEXT 588
-#define _gloffset_PointParameterfEXT 589
-#define _gloffset_PointParameterfvEXT 590
-#define _gloffset_LockArraysEXT 591
-#define _gloffset_UnlockArraysEXT 592
-#define _gloffset_CullParameterdvEXT 593
-#define _gloffset_CullParameterfvEXT 594
-#define _gloffset_SecondaryColor3bEXT 595
-#define _gloffset_SecondaryColor3bvEXT 596
-#define _gloffset_SecondaryColor3dEXT 597
-#define _gloffset_SecondaryColor3dvEXT 598
-#define _gloffset_SecondaryColor3fEXT 599
-#define _gloffset_SecondaryColor3fvEXT 600
-#define _gloffset_SecondaryColor3iEXT 601
-#define _gloffset_SecondaryColor3ivEXT 602
-#define _gloffset_SecondaryColor3sEXT 603
-#define _gloffset_SecondaryColor3svEXT 604
-#define _gloffset_SecondaryColor3ubEXT 605
-#define _gloffset_SecondaryColor3ubvEXT 606
-#define _gloffset_SecondaryColor3uiEXT 607
-#define _gloffset_SecondaryColor3uivEXT 608
-#define _gloffset_SecondaryColor3usEXT 609
-#define _gloffset_SecondaryColor3usvEXT 610
-#define _gloffset_SecondaryColorPointerEXT 611
-#define _gloffset_MultiDrawArraysEXT 612
-#define _gloffset_MultiDrawElementsEXT 613
-#define _gloffset_FogCoordPointerEXT 614
-#define _gloffset_FogCoorddEXT 615
-#define _gloffset_FogCoorddvEXT 616
-#define _gloffset_FogCoordfEXT 617
-#define _gloffset_FogCoordfvEXT 618
-#define _gloffset_PixelTexGenSGIX 619
-#define _gloffset_BlendFuncSeparateEXT 620
-#define _gloffset_FlushVertexArrayRangeNV 621
-#define _gloffset_VertexArrayRangeNV 622
-#define _gloffset_CombinerInputNV 623
-#define _gloffset_CombinerOutputNV 624
-#define _gloffset_CombinerParameterfNV 625
-#define _gloffset_CombinerParameterfvNV 626
-#define _gloffset_CombinerParameteriNV 627
-#define _gloffset_CombinerParameterivNV 628
-#define _gloffset_FinalCombinerInputNV 629
-#define _gloffset_GetCombinerInputParameterfvNV 630
-#define _gloffset_GetCombinerInputParameterivNV 631
-#define _gloffset_GetCombinerOutputParameterfvNV 632
-#define _gloffset_GetCombinerOutputParameterivNV 633
-#define _gloffset_GetFinalCombinerInputParameterfvNV 634
-#define _gloffset_GetFinalCombinerInputParameterivNV 635
-#define _gloffset_ResizeBuffersMESA 636
-#define _gloffset_WindowPos2dMESA 637
-#define _gloffset_WindowPos2dvMESA 638
-#define _gloffset_WindowPos2fMESA 639
-#define _gloffset_WindowPos2fvMESA 640
-#define _gloffset_WindowPos2iMESA 641
-#define _gloffset_WindowPos2ivMESA 642
-#define _gloffset_WindowPos2sMESA 643
-#define _gloffset_WindowPos2svMESA 644
-#define _gloffset_WindowPos3dMESA 645
-#define _gloffset_WindowPos3dvMESA 646
-#define _gloffset_WindowPos3fMESA 647
-#define _gloffset_WindowPos3fvMESA 648
-#define _gloffset_WindowPos3iMESA 649
-#define _gloffset_WindowPos3ivMESA 650
-#define _gloffset_WindowPos3sMESA 651
-#define _gloffset_WindowPos3svMESA 652
-#define _gloffset_WindowPos4dMESA 653
-#define _gloffset_WindowPos4dvMESA 654
-#define _gloffset_WindowPos4fMESA 655
-#define _gloffset_WindowPos4fvMESA 656
-#define _gloffset_WindowPos4iMESA 657
-#define _gloffset_WindowPos4ivMESA 658
-#define _gloffset_WindowPos4sMESA 659
-#define _gloffset_WindowPos4svMESA 660
-#define _gloffset_MultiModeDrawArraysIBM 661
-#define _gloffset_MultiModeDrawElementsIBM 662
-#define _gloffset_DeleteFencesNV 663
-#define _gloffset_FinishFenceNV 664
-#define _gloffset_GenFencesNV 665
-#define _gloffset_GetFenceivNV 666
-#define _gloffset_IsFenceNV 667
-#define _gloffset_SetFenceNV 668
-#define _gloffset_TestFenceNV 669
-#define _gloffset_AreProgramsResidentNV 670
-#define _gloffset_BindProgramNV 671
-#define _gloffset_DeleteProgramsNV 672
-#define _gloffset_ExecuteProgramNV 673
-#define _gloffset_GenProgramsNV 674
-#define _gloffset_GetProgramParameterdvNV 675
-#define _gloffset_GetProgramParameterfvNV 676
-#define _gloffset_GetProgramStringNV 677
-#define _gloffset_GetProgramivNV 678
-#define _gloffset_GetTrackMatrixivNV 679
-#define _gloffset_GetVertexAttribPointervNV 680
-#define _gloffset_GetVertexAttribdvNV 681
-#define _gloffset_GetVertexAttribfvNV 682
-#define _gloffset_GetVertexAttribivNV 683
-#define _gloffset_IsProgramNV 684
-#define _gloffset_LoadProgramNV 685
-#define _gloffset_ProgramParameters4dvNV 686
-#define _gloffset_ProgramParameters4fvNV 687
-#define _gloffset_RequestResidentProgramsNV 688
-#define _gloffset_TrackMatrixNV 689
-#define _gloffset_VertexAttrib1dNV 690
-#define _gloffset_VertexAttrib1dvNV 691
-#define _gloffset_VertexAttrib1fNV 692
-#define _gloffset_VertexAttrib1fvNV 693
-#define _gloffset_VertexAttrib1sNV 694
-#define _gloffset_VertexAttrib1svNV 695
-#define _gloffset_VertexAttrib2dNV 696
-#define _gloffset_VertexAttrib2dvNV 697
-#define _gloffset_VertexAttrib2fNV 698
-#define _gloffset_VertexAttrib2fvNV 699
-#define _gloffset_VertexAttrib2sNV 700
-#define _gloffset_VertexAttrib2svNV 701
-#define _gloffset_VertexAttrib3dNV 702
-#define _gloffset_VertexAttrib3dvNV 703
-#define _gloffset_VertexAttrib3fNV 704
-#define _gloffset_VertexAttrib3fvNV 705
-#define _gloffset_VertexAttrib3sNV 706
-#define _gloffset_VertexAttrib3svNV 707
-#define _gloffset_VertexAttrib4dNV 708
-#define _gloffset_VertexAttrib4dvNV 709
-#define _gloffset_VertexAttrib4fNV 710
-#define _gloffset_VertexAttrib4fvNV 711
-#define _gloffset_VertexAttrib4sNV 712
-#define _gloffset_VertexAttrib4svNV 713
-#define _gloffset_VertexAttrib4ubNV 714
-#define _gloffset_VertexAttrib4ubvNV 715
-#define _gloffset_VertexAttribPointerNV 716
-#define _gloffset_VertexAttribs1dvNV 717
-#define _gloffset_VertexAttribs1fvNV 718
-#define _gloffset_VertexAttribs1svNV 719
-#define _gloffset_VertexAttribs2dvNV 720
-#define _gloffset_VertexAttribs2fvNV 721
-#define _gloffset_VertexAttribs2svNV 722
-#define _gloffset_VertexAttribs3dvNV 723
-#define _gloffset_VertexAttribs3fvNV 724
-#define _gloffset_VertexAttribs3svNV 725
-#define _gloffset_VertexAttribs4dvNV 726
-#define _gloffset_VertexAttribs4fvNV 727
-#define _gloffset_VertexAttribs4svNV 728
-#define _gloffset_VertexAttribs4ubvNV 729
-#define _gloffset_GetTexBumpParameterfvATI 730
-#define _gloffset_GetTexBumpParameterivATI 731
-#define _gloffset_TexBumpParameterfvATI 732
-#define _gloffset_TexBumpParameterivATI 733
-#define _gloffset_AlphaFragmentOp1ATI 734
-#define _gloffset_AlphaFragmentOp2ATI 735
-#define _gloffset_AlphaFragmentOp3ATI 736
-#define _gloffset_BeginFragmentShaderATI 737
-#define _gloffset_BindFragmentShaderATI 738
-#define _gloffset_ColorFragmentOp1ATI 739
-#define _gloffset_ColorFragmentOp2ATI 740
-#define _gloffset_ColorFragmentOp3ATI 741
-#define _gloffset_DeleteFragmentShaderATI 742
-#define _gloffset_EndFragmentShaderATI 743
-#define _gloffset_GenFragmentShadersATI 744
-#define _gloffset_PassTexCoordATI 745
-#define _gloffset_SampleMapATI 746
-#define _gloffset_SetFragmentShaderConstantATI 747
-#define _gloffset_PointParameteriNV 748
-#define _gloffset_PointParameterivNV 749
-#define _gloffset_ActiveStencilFaceEXT 750
-#define _gloffset_BindVertexArrayAPPLE 751
-#define _gloffset_DeleteVertexArraysAPPLE 752
-#define _gloffset_GenVertexArraysAPPLE 753
-#define _gloffset_IsVertexArrayAPPLE 754
-#define _gloffset_GetProgramNamedParameterdvNV 755
-#define _gloffset_GetProgramNamedParameterfvNV 756
-#define _gloffset_ProgramNamedParameter4dNV 757
-#define _gloffset_ProgramNamedParameter4dvNV 758
-#define _gloffset_ProgramNamedParameter4fNV 759
-#define _gloffset_ProgramNamedParameter4fvNV 760
-#define _gloffset_DepthBoundsEXT 761
-#define _gloffset_BlendEquationSeparateEXT 762
-#define _gloffset_BindFramebufferEXT 763
-#define _gloffset_BindRenderbufferEXT 764
-#define _gloffset_CheckFramebufferStatusEXT 765
-#define _gloffset_DeleteFramebuffersEXT 766
-#define _gloffset_DeleteRenderbuffersEXT 767
-#define _gloffset_FramebufferRenderbufferEXT 768
-#define _gloffset_FramebufferTexture1DEXT 769
-#define _gloffset_FramebufferTexture2DEXT 770
-#define _gloffset_FramebufferTexture3DEXT 771
-#define _gloffset_GenFramebuffersEXT 772
-#define _gloffset_GenRenderbuffersEXT 773
-#define _gloffset_GenerateMipmapEXT 774
-#define _gloffset_GetFramebufferAttachmentParameterivEXT 775
-#define _gloffset_GetRenderbufferParameterivEXT 776
-#define _gloffset_IsFramebufferEXT 777
-#define _gloffset_IsRenderbufferEXT 778
-#define _gloffset_RenderbufferStorageEXT 779
-#define _gloffset_BlitFramebufferEXT 780
-#define _gloffset_BufferParameteriAPPLE 781
-#define _gloffset_FlushMappedBufferRangeAPPLE 782
-#define _gloffset_FramebufferTextureLayerEXT 783
-#define _gloffset_ProvokingVertexEXT 784
-#define _gloffset_GetTexParameterPointervAPPLE 785
-#define _gloffset_TextureRangeAPPLE 786
-#define _gloffset_StencilFuncSeparateATI 787
-#define _gloffset_ProgramEnvParameters4fvEXT 788
-#define _gloffset_ProgramLocalParameters4fvEXT 789
-#define _gloffset_GetQueryObjecti64vEXT 790
-#define _gloffset_GetQueryObjectui64vEXT 791
-#define _gloffset_FIRST_DYNAMIC 792
+#define _gloffset_DrawElementsBaseVertex 574
+#define _gloffset_DrawRangeElementsBaseVertex 575
+#define _gloffset_MultiDrawElementsBaseVertex 576
+#define _gloffset_PolygonOffsetEXT 577
+#define _gloffset_GetPixelTexGenParameterfvSGIS 578
+#define _gloffset_GetPixelTexGenParameterivSGIS 579
+#define _gloffset_PixelTexGenParameterfSGIS 580
+#define _gloffset_PixelTexGenParameterfvSGIS 581
+#define _gloffset_PixelTexGenParameteriSGIS 582
+#define _gloffset_PixelTexGenParameterivSGIS 583
+#define _gloffset_SampleMaskSGIS 584
+#define _gloffset_SamplePatternSGIS 585
+#define _gloffset_ColorPointerEXT 586
+#define _gloffset_EdgeFlagPointerEXT 587
+#define _gloffset_IndexPointerEXT 588
+#define _gloffset_NormalPointerEXT 589
+#define _gloffset_TexCoordPointerEXT 590
+#define _gloffset_VertexPointerEXT 591
+#define _gloffset_PointParameterfEXT 592
+#define _gloffset_PointParameterfvEXT 593
+#define _gloffset_LockArraysEXT 594
+#define _gloffset_UnlockArraysEXT 595
+#define _gloffset_CullParameterdvEXT 596
+#define _gloffset_CullParameterfvEXT 597
+#define _gloffset_SecondaryColor3bEXT 598
+#define _gloffset_SecondaryColor3bvEXT 599
+#define _gloffset_SecondaryColor3dEXT 600
+#define _gloffset_SecondaryColor3dvEXT 601
+#define _gloffset_SecondaryColor3fEXT 602
+#define _gloffset_SecondaryColor3fvEXT 603
+#define _gloffset_SecondaryColor3iEXT 604
+#define _gloffset_SecondaryColor3ivEXT 605
+#define _gloffset_SecondaryColor3sEXT 606
+#define _gloffset_SecondaryColor3svEXT 607
+#define _gloffset_SecondaryColor3ubEXT 608
+#define _gloffset_SecondaryColor3ubvEXT 609
+#define _gloffset_SecondaryColor3uiEXT 610
+#define _gloffset_SecondaryColor3uivEXT 611
+#define _gloffset_SecondaryColor3usEXT 612
+#define _gloffset_SecondaryColor3usvEXT 613
+#define _gloffset_SecondaryColorPointerEXT 614
+#define _gloffset_MultiDrawArraysEXT 615
+#define _gloffset_MultiDrawElementsEXT 616
+#define _gloffset_FogCoordPointerEXT 617
+#define _gloffset_FogCoorddEXT 618
+#define _gloffset_FogCoorddvEXT 619
+#define _gloffset_FogCoordfEXT 620
+#define _gloffset_FogCoordfvEXT 621
+#define _gloffset_PixelTexGenSGIX 622
+#define _gloffset_BlendFuncSeparateEXT 623
+#define _gloffset_FlushVertexArrayRangeNV 624
+#define _gloffset_VertexArrayRangeNV 625
+#define _gloffset_CombinerInputNV 626
+#define _gloffset_CombinerOutputNV 627
+#define _gloffset_CombinerParameterfNV 628
+#define _gloffset_CombinerParameterfvNV 629
+#define _gloffset_CombinerParameteriNV 630
+#define _gloffset_CombinerParameterivNV 631
+#define _gloffset_FinalCombinerInputNV 632
+#define _gloffset_GetCombinerInputParameterfvNV 633
+#define _gloffset_GetCombinerInputParameterivNV 634
+#define _gloffset_GetCombinerOutputParameterfvNV 635
+#define _gloffset_GetCombinerOutputParameterivNV 636
+#define _gloffset_GetFinalCombinerInputParameterfvNV 637
+#define _gloffset_GetFinalCombinerInputParameterivNV 638
+#define _gloffset_ResizeBuffersMESA 639
+#define _gloffset_WindowPos2dMESA 640
+#define _gloffset_WindowPos2dvMESA 641
+#define _gloffset_WindowPos2fMESA 642
+#define _gloffset_WindowPos2fvMESA 643
+#define _gloffset_WindowPos2iMESA 644
+#define _gloffset_WindowPos2ivMESA 645
+#define _gloffset_WindowPos2sMESA 646
+#define _gloffset_WindowPos2svMESA 647
+#define _gloffset_WindowPos3dMESA 648
+#define _gloffset_WindowPos3dvMESA 649
+#define _gloffset_WindowPos3fMESA 650
+#define _gloffset_WindowPos3fvMESA 651
+#define _gloffset_WindowPos3iMESA 652
+#define _gloffset_WindowPos3ivMESA 653
+#define _gloffset_WindowPos3sMESA 654
+#define _gloffset_WindowPos3svMESA 655
+#define _gloffset_WindowPos4dMESA 656
+#define _gloffset_WindowPos4dvMESA 657
+#define _gloffset_WindowPos4fMESA 658
+#define _gloffset_WindowPos4fvMESA 659
+#define _gloffset_WindowPos4iMESA 660
+#define _gloffset_WindowPos4ivMESA 661
+#define _gloffset_WindowPos4sMESA 662
+#define _gloffset_WindowPos4svMESA 663
+#define _gloffset_MultiModeDrawArraysIBM 664
+#define _gloffset_MultiModeDrawElementsIBM 665
+#define _gloffset_DeleteFencesNV 666
+#define _gloffset_FinishFenceNV 667
+#define _gloffset_GenFencesNV 668
+#define _gloffset_GetFenceivNV 669
+#define _gloffset_IsFenceNV 670
+#define _gloffset_SetFenceNV 671
+#define _gloffset_TestFenceNV 672
+#define _gloffset_AreProgramsResidentNV 673
+#define _gloffset_BindProgramNV 674
+#define _gloffset_DeleteProgramsNV 675
+#define _gloffset_ExecuteProgramNV 676
+#define _gloffset_GenProgramsNV 677
+#define _gloffset_GetProgramParameterdvNV 678
+#define _gloffset_GetProgramParameterfvNV 679
+#define _gloffset_GetProgramStringNV 680
+#define _gloffset_GetProgramivNV 681
+#define _gloffset_GetTrackMatrixivNV 682
+#define _gloffset_GetVertexAttribPointervNV 683
+#define _gloffset_GetVertexAttribdvNV 684
+#define _gloffset_GetVertexAttribfvNV 685
+#define _gloffset_GetVertexAttribivNV 686
+#define _gloffset_IsProgramNV 687
+#define _gloffset_LoadProgramNV 688
+#define _gloffset_ProgramParameters4dvNV 689
+#define _gloffset_ProgramParameters4fvNV 690
+#define _gloffset_RequestResidentProgramsNV 691
+#define _gloffset_TrackMatrixNV 692
+#define _gloffset_VertexAttrib1dNV 693
+#define _gloffset_VertexAttrib1dvNV 694
+#define _gloffset_VertexAttrib1fNV 695
+#define _gloffset_VertexAttrib1fvNV 696
+#define _gloffset_VertexAttrib1sNV 697
+#define _gloffset_VertexAttrib1svNV 698
+#define _gloffset_VertexAttrib2dNV 699
+#define _gloffset_VertexAttrib2dvNV 700
+#define _gloffset_VertexAttrib2fNV 701
+#define _gloffset_VertexAttrib2fvNV 702
+#define _gloffset_VertexAttrib2sNV 703
+#define _gloffset_VertexAttrib2svNV 704
+#define _gloffset_VertexAttrib3dNV 705
+#define _gloffset_VertexAttrib3dvNV 706
+#define _gloffset_VertexAttrib3fNV 707
+#define _gloffset_VertexAttrib3fvNV 708
+#define _gloffset_VertexAttrib3sNV 709
+#define _gloffset_VertexAttrib3svNV 710
+#define _gloffset_VertexAttrib4dNV 711
+#define _gloffset_VertexAttrib4dvNV 712
+#define _gloffset_VertexAttrib4fNV 713
+#define _gloffset_VertexAttrib4fvNV 714
+#define _gloffset_VertexAttrib4sNV 715
+#define _gloffset_VertexAttrib4svNV 716
+#define _gloffset_VertexAttrib4ubNV 717
+#define _gloffset_VertexAttrib4ubvNV 718
+#define _gloffset_VertexAttribPointerNV 719
+#define _gloffset_VertexAttribs1dvNV 720
+#define _gloffset_VertexAttribs1fvNV 721
+#define _gloffset_VertexAttribs1svNV 722
+#define _gloffset_VertexAttribs2dvNV 723
+#define _gloffset_VertexAttribs2fvNV 724
+#define _gloffset_VertexAttribs2svNV 725
+#define _gloffset_VertexAttribs3dvNV 726
+#define _gloffset_VertexAttribs3fvNV 727
+#define _gloffset_VertexAttribs3svNV 728
+#define _gloffset_VertexAttribs4dvNV 729
+#define _gloffset_VertexAttribs4fvNV 730
+#define _gloffset_VertexAttribs4svNV 731
+#define _gloffset_VertexAttribs4ubvNV 732
+#define _gloffset_GetTexBumpParameterfvATI 733
+#define _gloffset_GetTexBumpParameterivATI 734
+#define _gloffset_TexBumpParameterfvATI 735
+#define _gloffset_TexBumpParameterivATI 736
+#define _gloffset_AlphaFragmentOp1ATI 737
+#define _gloffset_AlphaFragmentOp2ATI 738
+#define _gloffset_AlphaFragmentOp3ATI 739
+#define _gloffset_BeginFragmentShaderATI 740
+#define _gloffset_BindFragmentShaderATI 741
+#define _gloffset_ColorFragmentOp1ATI 742
+#define _gloffset_ColorFragmentOp2ATI 743
+#define _gloffset_ColorFragmentOp3ATI 744
+#define _gloffset_DeleteFragmentShaderATI 745
+#define _gloffset_EndFragmentShaderATI 746
+#define _gloffset_GenFragmentShadersATI 747
+#define _gloffset_PassTexCoordATI 748
+#define _gloffset_SampleMapATI 749
+#define _gloffset_SetFragmentShaderConstantATI 750
+#define _gloffset_PointParameteriNV 751
+#define _gloffset_PointParameterivNV 752
+#define _gloffset_ActiveStencilFaceEXT 753
+#define _gloffset_BindVertexArrayAPPLE 754
+#define _gloffset_DeleteVertexArraysAPPLE 755
+#define _gloffset_GenVertexArraysAPPLE 756
+#define _gloffset_IsVertexArrayAPPLE 757
+#define _gloffset_GetProgramNamedParameterdvNV 758
+#define _gloffset_GetProgramNamedParameterfvNV 759
+#define _gloffset_ProgramNamedParameter4dNV 760
+#define _gloffset_ProgramNamedParameter4dvNV 761
+#define _gloffset_ProgramNamedParameter4fNV 762
+#define _gloffset_ProgramNamedParameter4fvNV 763
+#define _gloffset_DepthBoundsEXT 764
+#define _gloffset_BlendEquationSeparateEXT 765
+#define _gloffset_BindFramebufferEXT 766
+#define _gloffset_BindRenderbufferEXT 767
+#define _gloffset_CheckFramebufferStatusEXT 768
+#define _gloffset_DeleteFramebuffersEXT 769
+#define _gloffset_DeleteRenderbuffersEXT 770
+#define _gloffset_FramebufferRenderbufferEXT 771
+#define _gloffset_FramebufferTexture1DEXT 772
+#define _gloffset_FramebufferTexture2DEXT 773
+#define _gloffset_FramebufferTexture3DEXT 774
+#define _gloffset_GenFramebuffersEXT 775
+#define _gloffset_GenRenderbuffersEXT 776
+#define _gloffset_GenerateMipmapEXT 777
+#define _gloffset_GetFramebufferAttachmentParameterivEXT 778
+#define _gloffset_GetRenderbufferParameterivEXT 779
+#define _gloffset_IsFramebufferEXT 780
+#define _gloffset_IsRenderbufferEXT 781
+#define _gloffset_RenderbufferStorageEXT 782
+#define _gloffset_BlitFramebufferEXT 783
+#define _gloffset_BufferParameteriAPPLE 784
+#define _gloffset_FlushMappedBufferRangeAPPLE 785
+#define _gloffset_FramebufferTextureLayerEXT 786
+#define _gloffset_ProvokingVertexEXT 787
+#define _gloffset_GetTexParameterPointervAPPLE 788
+#define _gloffset_TextureRangeAPPLE 789
+#define _gloffset_StencilFuncSeparateATI 790
+#define _gloffset_ProgramEnvParameters4fvEXT 791
+#define _gloffset_ProgramLocalParameters4fvEXT 792
+#define _gloffset_GetQueryObjecti64vEXT 793
+#define _gloffset_GetQueryObjectui64vEXT 794
+#define _gloffset_FIRST_DYNAMIC 795
 
 #else
 
@@ -994,6 +997,9 @@
 #define _gloffset_GetSynciv driDispatchRemapTable[GetSynciv_remap_index]
 #define _gloffset_IsSync driDispatchRemapTable[IsSync_remap_index]
 #define _gloffset_WaitSync driDispatchRemapTable[WaitSync_remap_index]
+#define _gloffset_DrawElementsBaseVertex driDispatchRemapTable[DrawElementsBaseVertex_remap_index]
+#define _gloffset_DrawRangeElementsBaseVertex driDispatchRemapTable[DrawRangeElementsBaseVertex_remap_index]
+#define _gloffset_MultiDrawElementsBaseVertex driDispatchRemapTable[MultiDrawElementsBaseVertex_remap_index]
 #define _gloffset_PolygonOffsetEXT driDispatchRemapTable[PolygonOffsetEXT_remap_index]
 #define _gloffset_GetPixelTexGenParameterfvSGIS driDispatchRemapTable[GetPixelTexGenParameterfvSGIS_remap_index]
 #define _gloffset_GetPixelTexGenParameterivSGIS driDispatchRemapTable[GetPixelTexGenParameterivSGIS_remap_index]
diff --git a/src/mesa/glapi/glapitable.h b/src/mesa/glapi/glapitable.h
index 855fcaa7fe..4f9e53b62d 100644
--- a/src/mesa/glapi/glapitable.h
+++ b/src/mesa/glapi/glapitable.h
@@ -614,224 +614,227 @@ struct _glapi_table
    void (GLAPIENTRYP GetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values); /* 571 */
    GLboolean (GLAPIENTRYP IsSync)(GLsync sync); /* 572 */
    void (GLAPIENTRYP WaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); /* 573 */
-   void (GLAPIENTRYP PolygonOffsetEXT)(GLfloat factor, GLfloat bias); /* 574 */
-   void (GLAPIENTRYP GetPixelTexGenParameterfvSGIS)(GLenum pname, GLfloat * params); /* 575 */
-   void (GLAPIENTRYP GetPixelTexGenParameterivSGIS)(GLenum pname, GLint * params); /* 576 */
-   void (GLAPIENTRYP PixelTexGenParameterfSGIS)(GLenum pname, GLfloat param); /* 577 */
-   void (GLAPIENTRYP PixelTexGenParameterfvSGIS)(GLenum pname, const GLfloat * params); /* 578 */
-   void (GLAPIENTRYP PixelTexGenParameteriSGIS)(GLenum pname, GLint param); /* 579 */
-   void (GLAPIENTRYP PixelTexGenParameterivSGIS)(GLenum pname, const GLint * params); /* 580 */
-   void (GLAPIENTRYP SampleMaskSGIS)(GLclampf value, GLboolean invert); /* 581 */
-   void (GLAPIENTRYP SamplePatternSGIS)(GLenum pattern); /* 582 */
-   void (GLAPIENTRYP ColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 583 */
-   void (GLAPIENTRYP EdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean * pointer); /* 584 */
-   void (GLAPIENTRYP IndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 585 */
-   void (GLAPIENTRYP NormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 586 */
-   void (GLAPIENTRYP TexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 587 */
-   void (GLAPIENTRYP VertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 588 */
-   void (GLAPIENTRYP PointParameterfEXT)(GLenum pname, GLfloat param); /* 589 */
-   void (GLAPIENTRYP PointParameterfvEXT)(GLenum pname, const GLfloat * params); /* 590 */
-   void (GLAPIENTRYP LockArraysEXT)(GLint first, GLsizei count); /* 591 */
-   void (GLAPIENTRYP UnlockArraysEXT)(void); /* 592 */
-   void (GLAPIENTRYP CullParameterdvEXT)(GLenum pname, GLdouble * params); /* 593 */
-   void (GLAPIENTRYP CullParameterfvEXT)(GLenum pname, GLfloat * params); /* 594 */
-   void (GLAPIENTRYP SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue); /* 595 */
-   void (GLAPIENTRYP SecondaryColor3bvEXT)(const GLbyte * v); /* 596 */
-   void (GLAPIENTRYP SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue); /* 597 */
-   void (GLAPIENTRYP SecondaryColor3dvEXT)(const GLdouble * v); /* 598 */
-   void (GLAPIENTRYP SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue); /* 599 */
-   void (GLAPIENTRYP SecondaryColor3fvEXT)(const GLfloat * v); /* 600 */
-   void (GLAPIENTRYP SecondaryColor3iEXT)(GLint red, GLint green, GLint blue); /* 601 */
-   void (GLAPIENTRYP SecondaryColor3ivEXT)(const GLint * v); /* 602 */
-   void (GLAPIENTRYP SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue); /* 603 */
-   void (GLAPIENTRYP SecondaryColor3svEXT)(const GLshort * v); /* 604 */
-   void (GLAPIENTRYP SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue); /* 605 */
-   void (GLAPIENTRYP SecondaryColor3ubvEXT)(const GLubyte * v); /* 606 */
-   void (GLAPIENTRYP SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue); /* 607 */
-   void (GLAPIENTRYP SecondaryColor3uivEXT)(const GLuint * v); /* 608 */
-   void (GLAPIENTRYP SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue); /* 609 */
-   void (GLAPIENTRYP SecondaryColor3usvEXT)(const GLushort * v); /* 610 */
-   void (GLAPIENTRYP SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 611 */
-   void (GLAPIENTRYP MultiDrawArraysEXT)(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount); /* 612 */
-   void (GLAPIENTRYP MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); /* 613 */
-   void (GLAPIENTRYP FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 614 */
-   void (GLAPIENTRYP FogCoorddEXT)(GLdouble coord); /* 615 */
-   void (GLAPIENTRYP FogCoorddvEXT)(const GLdouble * coord); /* 616 */
-   void (GLAPIENTRYP FogCoordfEXT)(GLfloat coord); /* 617 */
-   void (GLAPIENTRYP FogCoordfvEXT)(const GLfloat * coord); /* 618 */
-   void (GLAPIENTRYP PixelTexGenSGIX)(GLenum mode); /* 619 */
-   void (GLAPIENTRYP BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); /* 620 */
-   void (GLAPIENTRYP FlushVertexArrayRangeNV)(void); /* 621 */
-   void (GLAPIENTRYP VertexArrayRangeNV)(GLsizei length, const GLvoid * pointer); /* 622 */
-   void (GLAPIENTRYP CombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 623 */
-   void (GLAPIENTRYP CombinerOutputNV)(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); /* 624 */
-   void (GLAPIENTRYP CombinerParameterfNV)(GLenum pname, GLfloat param); /* 625 */
-   void (GLAPIENTRYP CombinerParameterfvNV)(GLenum pname, const GLfloat * params); /* 626 */
-   void (GLAPIENTRYP CombinerParameteriNV)(GLenum pname, GLint param); /* 627 */
-   void (GLAPIENTRYP CombinerParameterivNV)(GLenum pname, const GLint * params); /* 628 */
-   void (GLAPIENTRYP FinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 629 */
-   void (GLAPIENTRYP GetCombinerInputParameterfvNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params); /* 630 */
-   void (GLAPIENTRYP GetCombinerInputParameterivNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params); /* 631 */
-   void (GLAPIENTRYP GetCombinerOutputParameterfvNV)(GLenum stage, GLenum portion, GLenum pname, GLfloat * params); /* 632 */
-   void (GLAPIENTRYP GetCombinerOutputParameterivNV)(GLenum stage, GLenum portion, GLenum pname, GLint * params); /* 633 */
-   void (GLAPIENTRYP GetFinalCombinerInputParameterfvNV)(GLenum variable, GLenum pname, GLfloat * params); /* 634 */
-   void (GLAPIENTRYP GetFinalCombinerInputParameterivNV)(GLenum variable, GLenum pname, GLint * params); /* 635 */
-   void (GLAPIENTRYP ResizeBuffersMESA)(void); /* 636 */
-   void (GLAPIENTRYP WindowPos2dMESA)(GLdouble x, GLdouble y); /* 637 */
-   void (GLAPIENTRYP WindowPos2dvMESA)(const GLdouble * v); /* 638 */
-   void (GLAPIENTRYP WindowPos2fMESA)(GLfloat x, GLfloat y); /* 639 */
-   void (GLAPIENTRYP WindowPos2fvMESA)(const GLfloat * v); /* 640 */
-   void (GLAPIENTRYP WindowPos2iMESA)(GLint x, GLint y); /* 641 */
-   void (GLAPIENTRYP WindowPos2ivMESA)(const GLint * v); /* 642 */
-   void (GLAPIENTRYP WindowPos2sMESA)(GLshort x, GLshort y); /* 643 */
-   void (GLAPIENTRYP WindowPos2svMESA)(const GLshort * v); /* 644 */
-   void (GLAPIENTRYP WindowPos3dMESA)(GLdouble x, GLdouble y, GLdouble z); /* 645 */
-   void (GLAPIENTRYP WindowPos3dvMESA)(const GLdouble * v); /* 646 */
-   void (GLAPIENTRYP WindowPos3fMESA)(GLfloat x, GLfloat y, GLfloat z); /* 647 */
-   void (GLAPIENTRYP WindowPos3fvMESA)(const GLfloat * v); /* 648 */
-   void (GLAPIENTRYP WindowPos3iMESA)(GLint x, GLint y, GLint z); /* 649 */
-   void (GLAPIENTRYP WindowPos3ivMESA)(const GLint * v); /* 650 */
-   void (GLAPIENTRYP WindowPos3sMESA)(GLshort x, GLshort y, GLshort z); /* 651 */
-   void (GLAPIENTRYP WindowPos3svMESA)(const GLshort * v); /* 652 */
-   void (GLAPIENTRYP WindowPos4dMESA)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 653 */
-   void (GLAPIENTRYP WindowPos4dvMESA)(const GLdouble * v); /* 654 */
-   void (GLAPIENTRYP WindowPos4fMESA)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 655 */
-   void (GLAPIENTRYP WindowPos4fvMESA)(const GLfloat * v); /* 656 */
-   void (GLAPIENTRYP WindowPos4iMESA)(GLint x, GLint y, GLint z, GLint w); /* 657 */
-   void (GLAPIENTRYP WindowPos4ivMESA)(const GLint * v); /* 658 */
-   void (GLAPIENTRYP WindowPos4sMESA)(GLshort x, GLshort y, GLshort z, GLshort w); /* 659 */
-   void (GLAPIENTRYP WindowPos4svMESA)(const GLshort * v); /* 660 */
-   void (GLAPIENTRYP MultiModeDrawArraysIBM)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride); /* 661 */
-   void (GLAPIENTRYP MultiModeDrawElementsIBM)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride); /* 662 */
-   void (GLAPIENTRYP DeleteFencesNV)(GLsizei n, const GLuint * fences); /* 663 */
-   void (GLAPIENTRYP FinishFenceNV)(GLuint fence); /* 664 */
-   void (GLAPIENTRYP GenFencesNV)(GLsizei n, GLuint * fences); /* 665 */
-   void (GLAPIENTRYP GetFenceivNV)(GLuint fence, GLenum pname, GLint * params); /* 666 */
-   GLboolean (GLAPIENTRYP IsFenceNV)(GLuint fence); /* 667 */
-   void (GLAPIENTRYP SetFenceNV)(GLuint fence, GLenum condition); /* 668 */
-   GLboolean (GLAPIENTRYP TestFenceNV)(GLuint fence); /* 669 */
-   GLboolean (GLAPIENTRYP AreProgramsResidentNV)(GLsizei n, const GLuint * ids, GLboolean * residences); /* 670 */
-   void (GLAPIENTRYP BindProgramNV)(GLenum target, GLuint program); /* 671 */
-   void (GLAPIENTRYP DeleteProgramsNV)(GLsizei n, const GLuint * programs); /* 672 */
-   void (GLAPIENTRYP ExecuteProgramNV)(GLenum target, GLuint id, const GLfloat * params); /* 673 */
-   void (GLAPIENTRYP GenProgramsNV)(GLsizei n, GLuint * programs); /* 674 */
-   void (GLAPIENTRYP GetProgramParameterdvNV)(GLenum target, GLuint index, GLenum pname, GLdouble * params); /* 675 */
-   void (GLAPIENTRYP GetProgramParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat * params); /* 676 */
-   void (GLAPIENTRYP GetProgramStringNV)(GLuint id, GLenum pname, GLubyte * program); /* 677 */
-   void (GLAPIENTRYP GetProgramivNV)(GLuint id, GLenum pname, GLint * params); /* 678 */
-   void (GLAPIENTRYP GetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint * params); /* 679 */
-   void (GLAPIENTRYP GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer); /* 680 */
-   void (GLAPIENTRYP GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params); /* 681 */
-   void (GLAPIENTRYP GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params); /* 682 */
-   void (GLAPIENTRYP GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params); /* 683 */
-   GLboolean (GLAPIENTRYP IsProgramNV)(GLuint program); /* 684 */
-   void (GLAPIENTRYP LoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte * program); /* 685 */
-   void (GLAPIENTRYP ProgramParameters4dvNV)(GLenum target, GLuint index, GLuint num, const GLdouble * params); /* 686 */
-   void (GLAPIENTRYP ProgramParameters4fvNV)(GLenum target, GLuint index, GLuint num, const GLfloat * params); /* 687 */
-   void (GLAPIENTRYP RequestResidentProgramsNV)(GLsizei n, const GLuint * ids); /* 688 */
-   void (GLAPIENTRYP TrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform); /* 689 */
-   void (GLAPIENTRYP VertexAttrib1dNV)(GLuint index, GLdouble x); /* 690 */
-   void (GLAPIENTRYP VertexAttrib1dvNV)(GLuint index, const GLdouble * v); /* 691 */
-   void (GLAPIENTRYP VertexAttrib1fNV)(GLuint index, GLfloat x); /* 692 */
-   void (GLAPIENTRYP VertexAttrib1fvNV)(GLuint index, const GLfloat * v); /* 693 */
-   void (GLAPIENTRYP VertexAttrib1sNV)(GLuint index, GLshort x); /* 694 */
-   void (GLAPIENTRYP VertexAttrib1svNV)(GLuint index, const GLshort * v); /* 695 */
-   void (GLAPIENTRYP VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y); /* 696 */
-   void (GLAPIENTRYP VertexAttrib2dvNV)(GLuint index, const GLdouble * v); /* 697 */
-   void (GLAPIENTRYP VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y); /* 698 */
-   void (GLAPIENTRYP VertexAttrib2fvNV)(GLuint index, const GLfloat * v); /* 699 */
-   void (GLAPIENTRYP VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y); /* 700 */
-   void (GLAPIENTRYP VertexAttrib2svNV)(GLuint index, const GLshort * v); /* 701 */
-   void (GLAPIENTRYP VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 702 */
-   void (GLAPIENTRYP VertexAttrib3dvNV)(GLuint index, const GLdouble * v); /* 703 */
-   void (GLAPIENTRYP VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 704 */
-   void (GLAPIENTRYP VertexAttrib3fvNV)(GLuint index, const GLfloat * v); /* 705 */
-   void (GLAPIENTRYP VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z); /* 706 */
-   void (GLAPIENTRYP VertexAttrib3svNV)(GLuint index, const GLshort * v); /* 707 */
-   void (GLAPIENTRYP VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 708 */
-   void (GLAPIENTRYP VertexAttrib4dvNV)(GLuint index, const GLdouble * v); /* 709 */
-   void (GLAPIENTRYP VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 710 */
-   void (GLAPIENTRYP VertexAttrib4fvNV)(GLuint index, const GLfloat * v); /* 711 */
-   void (GLAPIENTRYP VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 712 */
-   void (GLAPIENTRYP VertexAttrib4svNV)(GLuint index, const GLshort * v); /* 713 */
-   void (GLAPIENTRYP VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 714 */
-   void (GLAPIENTRYP VertexAttrib4ubvNV)(GLuint index, const GLubyte * v); /* 715 */
-   void (GLAPIENTRYP VertexAttribPointerNV)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 716 */
-   void (GLAPIENTRYP VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 717 */
-   void (GLAPIENTRYP VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 718 */
-   void (GLAPIENTRYP VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort * v); /* 719 */
-   void (GLAPIENTRYP VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 720 */
-   void (GLAPIENTRYP VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 721 */
-   void (GLAPIENTRYP VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort * v); /* 722 */
-   void (GLAPIENTRYP VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 723 */
-   void (GLAPIENTRYP VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 724 */
-   void (GLAPIENTRYP VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort * v); /* 725 */
-   void (GLAPIENTRYP VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 726 */
-   void (GLAPIENTRYP VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 727 */
-   void (GLAPIENTRYP VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort * v); /* 728 */
-   void (GLAPIENTRYP VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte * v); /* 729 */
-   void (GLAPIENTRYP GetTexBumpParameterfvATI)(GLenum pname, GLfloat * param); /* 730 */
-   void (GLAPIENTRYP GetTexBumpParameterivATI)(GLenum pname, GLint * param); /* 731 */
-   void (GLAPIENTRYP TexBumpParameterfvATI)(GLenum pname, const GLfloat * param); /* 732 */
-   void (GLAPIENTRYP TexBumpParameterivATI)(GLenum pname, const GLint * param); /* 733 */
-   void (GLAPIENTRYP AlphaFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 734 */
-   void (GLAPIENTRYP AlphaFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 735 */
-   void (GLAPIENTRYP AlphaFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 736 */
-   void (GLAPIENTRYP BeginFragmentShaderATI)(void); /* 737 */
-   void (GLAPIENTRYP BindFragmentShaderATI)(GLuint id); /* 738 */
-   void (GLAPIENTRYP ColorFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 739 */
-   void (GLAPIENTRYP ColorFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 740 */
-   void (GLAPIENTRYP ColorFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 741 */
-   void (GLAPIENTRYP DeleteFragmentShaderATI)(GLuint id); /* 742 */
-   void (GLAPIENTRYP EndFragmentShaderATI)(void); /* 743 */
-   GLuint (GLAPIENTRYP GenFragmentShadersATI)(GLuint range); /* 744 */
-   void (GLAPIENTRYP PassTexCoordATI)(GLuint dst, GLuint coord, GLenum swizzle); /* 745 */
-   void (GLAPIENTRYP SampleMapATI)(GLuint dst, GLuint interp, GLenum swizzle); /* 746 */
-   void (GLAPIENTRYP SetFragmentShaderConstantATI)(GLuint dst, const GLfloat * value); /* 747 */
-   void (GLAPIENTRYP PointParameteriNV)(GLenum pname, GLint param); /* 748 */
-   void (GLAPIENTRYP PointParameterivNV)(GLenum pname, const GLint * params); /* 749 */
-   void (GLAPIENTRYP ActiveStencilFaceEXT)(GLenum face); /* 750 */
-   void (GLAPIENTRYP BindVertexArrayAPPLE)(GLuint array); /* 751 */
-   void (GLAPIENTRYP DeleteVertexArraysAPPLE)(GLsizei n, const GLuint * arrays); /* 752 */
-   void (GLAPIENTRYP GenVertexArraysAPPLE)(GLsizei n, GLuint * arrays); /* 753 */
-   GLboolean (GLAPIENTRYP IsVertexArrayAPPLE)(GLuint array); /* 754 */
-   void (GLAPIENTRYP GetProgramNamedParameterdvNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params); /* 755 */
-   void (GLAPIENTRYP GetProgramNamedParameterfvNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params); /* 756 */
-   void (GLAPIENTRYP ProgramNamedParameter4dNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 757 */
-   void (GLAPIENTRYP ProgramNamedParameter4dvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v); /* 758 */
-   void (GLAPIENTRYP ProgramNamedParameter4fNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 759 */
-   void (GLAPIENTRYP ProgramNamedParameter4fvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v); /* 760 */
-   void (GLAPIENTRYP DepthBoundsEXT)(GLclampd zmin, GLclampd zmax); /* 761 */
-   void (GLAPIENTRYP BlendEquationSeparateEXT)(GLenum modeRGB, GLenum modeA); /* 762 */
-   void (GLAPIENTRYP BindFramebufferEXT)(GLenum target, GLuint framebuffer); /* 763 */
-   void (GLAPIENTRYP BindRenderbufferEXT)(GLenum target, GLuint renderbuffer); /* 764 */
-   GLenum (GLAPIENTRYP CheckFramebufferStatusEXT)(GLenum target); /* 765 */
-   void (GLAPIENTRYP DeleteFramebuffersEXT)(GLsizei n, const GLuint * framebuffers); /* 766 */
-   void (GLAPIENTRYP DeleteRenderbuffersEXT)(GLsizei n, const GLuint * renderbuffers); /* 767 */
-   void (GLAPIENTRYP FramebufferRenderbufferEXT)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); /* 768 */
-   void (GLAPIENTRYP FramebufferTexture1DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 769 */
-   void (GLAPIENTRYP FramebufferTexture2DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 770 */
-   void (GLAPIENTRYP FramebufferTexture3DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); /* 771 */
-   void (GLAPIENTRYP GenFramebuffersEXT)(GLsizei n, GLuint * framebuffers); /* 772 */
-   void (GLAPIENTRYP GenRenderbuffersEXT)(GLsizei n, GLuint * renderbuffers); /* 773 */
-   void (GLAPIENTRYP GenerateMipmapEXT)(GLenum target); /* 774 */
-   void (GLAPIENTRYP GetFramebufferAttachmentParameterivEXT)(GLenum target, GLenum attachment, GLenum pname, GLint * params); /* 775 */
-   void (GLAPIENTRYP GetRenderbufferParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 776 */
-   GLboolean (GLAPIENTRYP IsFramebufferEXT)(GLuint framebuffer); /* 777 */
-   GLboolean (GLAPIENTRYP IsRenderbufferEXT)(GLuint renderbuffer); /* 778 */
-   void (GLAPIENTRYP RenderbufferStorageEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); /* 779 */
-   void (GLAPIENTRYP BlitFramebufferEXT)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); /* 780 */
-   void (GLAPIENTRYP BufferParameteriAPPLE)(GLenum target, GLenum pname, GLint param); /* 781 */
-   void (GLAPIENTRYP FlushMappedBufferRangeAPPLE)(GLenum target, GLintptr offset, GLsizeiptr size); /* 782 */
-   void (GLAPIENTRYP FramebufferTextureLayerEXT)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); /* 783 */
-   void (GLAPIENTRYP ProvokingVertexEXT)(GLenum mode); /* 784 */
-   void (GLAPIENTRYP GetTexParameterPointervAPPLE)(GLenum target, GLenum pname, GLvoid ** params); /* 785 */
-   void (GLAPIENTRYP TextureRangeAPPLE)(GLenum target, GLsizei length, GLvoid * pointer); /* 786 */
-   void (GLAPIENTRYP StencilFuncSeparateATI)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); /* 787 */
-   void (GLAPIENTRYP ProgramEnvParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 788 */
-   void (GLAPIENTRYP ProgramLocalParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 789 */
-   void (GLAPIENTRYP GetQueryObjecti64vEXT)(GLuint id, GLenum pname, GLint64EXT * params); /* 790 */
-   void (GLAPIENTRYP GetQueryObjectui64vEXT)(GLuint id, GLenum pname, GLuint64EXT * params); /* 791 */
+   void (GLAPIENTRYP DrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex); /* 574 */
+   void (GLAPIENTRYP DrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex); /* 575 */
+   void (GLAPIENTRYP MultiDrawElementsBaseVertex)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount, const GLint * basevertex); /* 576 */
+   void (GLAPIENTRYP PolygonOffsetEXT)(GLfloat factor, GLfloat bias); /* 577 */
+   void (GLAPIENTRYP GetPixelTexGenParameterfvSGIS)(GLenum pname, GLfloat * params); /* 578 */
+   void (GLAPIENTRYP GetPixelTexGenParameterivSGIS)(GLenum pname, GLint * params); /* 579 */
+   void (GLAPIENTRYP PixelTexGenParameterfSGIS)(GLenum pname, GLfloat param); /* 580 */
+   void (GLAPIENTRYP PixelTexGenParameterfvSGIS)(GLenum pname, const GLfloat * params); /* 581 */
+   void (GLAPIENTRYP PixelTexGenParameteriSGIS)(GLenum pname, GLint param); /* 582 */
+   void (GLAPIENTRYP PixelTexGenParameterivSGIS)(GLenum pname, const GLint * params); /* 583 */
+   void (GLAPIENTRYP SampleMaskSGIS)(GLclampf value, GLboolean invert); /* 584 */
+   void (GLAPIENTRYP SamplePatternSGIS)(GLenum pattern); /* 585 */
+   void (GLAPIENTRYP ColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 586 */
+   void (GLAPIENTRYP EdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean * pointer); /* 587 */
+   void (GLAPIENTRYP IndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 588 */
+   void (GLAPIENTRYP NormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 589 */
+   void (GLAPIENTRYP TexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 590 */
+   void (GLAPIENTRYP VertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 591 */
+   void (GLAPIENTRYP PointParameterfEXT)(GLenum pname, GLfloat param); /* 592 */
+   void (GLAPIENTRYP PointParameterfvEXT)(GLenum pname, const GLfloat * params); /* 593 */
+   void (GLAPIENTRYP LockArraysEXT)(GLint first, GLsizei count); /* 594 */
+   void (GLAPIENTRYP UnlockArraysEXT)(void); /* 595 */
+   void (GLAPIENTRYP CullParameterdvEXT)(GLenum pname, GLdouble * params); /* 596 */
+   void (GLAPIENTRYP CullParameterfvEXT)(GLenum pname, GLfloat * params); /* 597 */
+   void (GLAPIENTRYP SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue); /* 598 */
+   void (GLAPIENTRYP SecondaryColor3bvEXT)(const GLbyte * v); /* 599 */
+   void (GLAPIENTRYP SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue); /* 600 */
+   void (GLAPIENTRYP SecondaryColor3dvEXT)(const GLdouble * v); /* 601 */
+   void (GLAPIENTRYP SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue); /* 602 */
+   void (GLAPIENTRYP SecondaryColor3fvEXT)(const GLfloat * v); /* 603 */
+   void (GLAPIENTRYP SecondaryColor3iEXT)(GLint red, GLint green, GLint blue); /* 604 */
+   void (GLAPIENTRYP SecondaryColor3ivEXT)(const GLint * v); /* 605 */
+   void (GLAPIENTRYP SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue); /* 606 */
+   void (GLAPIENTRYP SecondaryColor3svEXT)(const GLshort * v); /* 607 */
+   void (GLAPIENTRYP SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue); /* 608 */
+   void (GLAPIENTRYP SecondaryColor3ubvEXT)(const GLubyte * v); /* 609 */
+   void (GLAPIENTRYP SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue); /* 610 */
+   void (GLAPIENTRYP SecondaryColor3uivEXT)(const GLuint * v); /* 611 */
+   void (GLAPIENTRYP SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue); /* 612 */
+   void (GLAPIENTRYP SecondaryColor3usvEXT)(const GLushort * v); /* 613 */
+   void (GLAPIENTRYP SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 614 */
+   void (GLAPIENTRYP MultiDrawArraysEXT)(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount); /* 615 */
+   void (GLAPIENTRYP MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); /* 616 */
+   void (GLAPIENTRYP FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 617 */
+   void (GLAPIENTRYP FogCoorddEXT)(GLdouble coord); /* 618 */
+   void (GLAPIENTRYP FogCoorddvEXT)(const GLdouble * coord); /* 619 */
+   void (GLAPIENTRYP FogCoordfEXT)(GLfloat coord); /* 620 */
+   void (GLAPIENTRYP FogCoordfvEXT)(const GLfloat * coord); /* 621 */
+   void (GLAPIENTRYP PixelTexGenSGIX)(GLenum mode); /* 622 */
+   void (GLAPIENTRYP BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); /* 623 */
+   void (GLAPIENTRYP FlushVertexArrayRangeNV)(void); /* 624 */
+   void (GLAPIENTRYP VertexArrayRangeNV)(GLsizei length, const GLvoid * pointer); /* 625 */
+   void (GLAPIENTRYP CombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 626 */
+   void (GLAPIENTRYP CombinerOutputNV)(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); /* 627 */
+   void (GLAPIENTRYP CombinerParameterfNV)(GLenum pname, GLfloat param); /* 628 */
+   void (GLAPIENTRYP CombinerParameterfvNV)(GLenum pname, const GLfloat * params); /* 629 */
+   void (GLAPIENTRYP CombinerParameteriNV)(GLenum pname, GLint param); /* 630 */
+   void (GLAPIENTRYP CombinerParameterivNV)(GLenum pname, const GLint * params); /* 631 */
+   void (GLAPIENTRYP FinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 632 */
+   void (GLAPIENTRYP GetCombinerInputParameterfvNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params); /* 633 */
+   void (GLAPIENTRYP GetCombinerInputParameterivNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params); /* 634 */
+   void (GLAPIENTRYP GetCombinerOutputParameterfvNV)(GLenum stage, GLenum portion, GLenum pname, GLfloat * params); /* 635 */
+   void (GLAPIENTRYP GetCombinerOutputParameterivNV)(GLenum stage, GLenum portion, GLenum pname, GLint * params); /* 636 */
+   void (GLAPIENTRYP GetFinalCombinerInputParameterfvNV)(GLenum variable, GLenum pname, GLfloat * params); /* 637 */
+   void (GLAPIENTRYP GetFinalCombinerInputParameterivNV)(GLenum variable, GLenum pname, GLint * params); /* 638 */
+   void (GLAPIENTRYP ResizeBuffersMESA)(void); /* 639 */
+   void (GLAPIENTRYP WindowPos2dMESA)(GLdouble x, GLdouble y); /* 640 */
+   void (GLAPIENTRYP WindowPos2dvMESA)(const GLdouble * v); /* 641 */
+   void (GLAPIENTRYP WindowPos2fMESA)(GLfloat x, GLfloat y); /* 642 */
+   void (GLAPIENTRYP WindowPos2fvMESA)(const GLfloat * v); /* 643 */
+   void (GLAPIENTRYP WindowPos2iMESA)(GLint x, GLint y); /* 644 */
+   void (GLAPIENTRYP WindowPos2ivMESA)(const GLint * v); /* 645 */
+   void (GLAPIENTRYP WindowPos2sMESA)(GLshort x, GLshort y); /* 646 */
+   void (GLAPIENTRYP WindowPos2svMESA)(const GLshort * v); /* 647 */
+   void (GLAPIENTRYP WindowPos3dMESA)(GLdouble x, GLdouble y, GLdouble z); /* 648 */
+   void (GLAPIENTRYP WindowPos3dvMESA)(const GLdouble * v); /* 649 */
+   void (GLAPIENTRYP WindowPos3fMESA)(GLfloat x, GLfloat y, GLfloat z); /* 650 */
+   void (GLAPIENTRYP WindowPos3fvMESA)(const GLfloat * v); /* 651 */
+   void (GLAPIENTRYP WindowPos3iMESA)(GLint x, GLint y, GLint z); /* 652 */
+   void (GLAPIENTRYP WindowPos3ivMESA)(const GLint * v); /* 653 */
+   void (GLAPIENTRYP WindowPos3sMESA)(GLshort x, GLshort y, GLshort z); /* 654 */
+   void (GLAPIENTRYP WindowPos3svMESA)(const GLshort * v); /* 655 */
+   void (GLAPIENTRYP WindowPos4dMESA)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 656 */
+   void (GLAPIENTRYP WindowPos4dvMESA)(const GLdouble * v); /* 657 */
+   void (GLAPIENTRYP WindowPos4fMESA)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 658 */
+   void (GLAPIENTRYP WindowPos4fvMESA)(const GLfloat * v); /* 659 */
+   void (GLAPIENTRYP WindowPos4iMESA)(GLint x, GLint y, GLint z, GLint w); /* 660 */
+   void (GLAPIENTRYP WindowPos4ivMESA)(const GLint * v); /* 661 */
+   void (GLAPIENTRYP WindowPos4sMESA)(GLshort x, GLshort y, GLshort z, GLshort w); /* 662 */
+   void (GLAPIENTRYP WindowPos4svMESA)(const GLshort * v); /* 663 */
+   void (GLAPIENTRYP MultiModeDrawArraysIBM)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride); /* 664 */
+   void (GLAPIENTRYP MultiModeDrawElementsIBM)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride); /* 665 */
+   void (GLAPIENTRYP DeleteFencesNV)(GLsizei n, const GLuint * fences); /* 666 */
+   void (GLAPIENTRYP FinishFenceNV)(GLuint fence); /* 667 */
+   void (GLAPIENTRYP GenFencesNV)(GLsizei n, GLuint * fences); /* 668 */
+   void (GLAPIENTRYP GetFenceivNV)(GLuint fence, GLenum pname, GLint * params); /* 669 */
+   GLboolean (GLAPIENTRYP IsFenceNV)(GLuint fence); /* 670 */
+   void (GLAPIENTRYP SetFenceNV)(GLuint fence, GLenum condition); /* 671 */
+   GLboolean (GLAPIENTRYP TestFenceNV)(GLuint fence); /* 672 */
+   GLboolean (GLAPIENTRYP AreProgramsResidentNV)(GLsizei n, const GLuint * ids, GLboolean * residences); /* 673 */
+   void (GLAPIENTRYP BindProgramNV)(GLenum target, GLuint program); /* 674 */
+   void (GLAPIENTRYP DeleteProgramsNV)(GLsizei n, const GLuint * programs); /* 675 */
+   void (GLAPIENTRYP ExecuteProgramNV)(GLenum target, GLuint id, const GLfloat * params); /* 676 */
+   void (GLAPIENTRYP GenProgramsNV)(GLsizei n, GLuint * programs); /* 677 */
+   void (GLAPIENTRYP GetProgramParameterdvNV)(GLenum target, GLuint index, GLenum pname, GLdouble * params); /* 678 */
+   void (GLAPIENTRYP GetProgramParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat * params); /* 679 */
+   void (GLAPIENTRYP GetProgramStringNV)(GLuint id, GLenum pname, GLubyte * program); /* 680 */
+   void (GLAPIENTRYP GetProgramivNV)(GLuint id, GLenum pname, GLint * params); /* 681 */
+   void (GLAPIENTRYP GetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint * params); /* 682 */
+   void (GLAPIENTRYP GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer); /* 683 */
+   void (GLAPIENTRYP GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params); /* 684 */
+   void (GLAPIENTRYP GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params); /* 685 */
+   void (GLAPIENTRYP GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params); /* 686 */
+   GLboolean (GLAPIENTRYP IsProgramNV)(GLuint program); /* 687 */
+   void (GLAPIENTRYP LoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte * program); /* 688 */
+   void (GLAPIENTRYP ProgramParameters4dvNV)(GLenum target, GLuint index, GLuint num, const GLdouble * params); /* 689 */
+   void (GLAPIENTRYP ProgramParameters4fvNV)(GLenum target, GLuint index, GLuint num, const GLfloat * params); /* 690 */
+   void (GLAPIENTRYP RequestResidentProgramsNV)(GLsizei n, const GLuint * ids); /* 691 */
+   void (GLAPIENTRYP TrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform); /* 692 */
+   void (GLAPIENTRYP VertexAttrib1dNV)(GLuint index, GLdouble x); /* 693 */
+   void (GLAPIENTRYP VertexAttrib1dvNV)(GLuint index, const GLdouble * v); /* 694 */
+   void (GLAPIENTRYP VertexAttrib1fNV)(GLuint index, GLfloat x); /* 695 */
+   void (GLAPIENTRYP VertexAttrib1fvNV)(GLuint index, const GLfloat * v); /* 696 */
+   void (GLAPIENTRYP VertexAttrib1sNV)(GLuint index, GLshort x); /* 697 */
+   void (GLAPIENTRYP VertexAttrib1svNV)(GLuint index, const GLshort * v); /* 698 */
+   void (GLAPIENTRYP VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y); /* 699 */
+   void (GLAPIENTRYP VertexAttrib2dvNV)(GLuint index, const GLdouble * v); /* 700 */
+   void (GLAPIENTRYP VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y); /* 701 */
+   void (GLAPIENTRYP VertexAttrib2fvNV)(GLuint index, const GLfloat * v); /* 702 */
+   void (GLAPIENTRYP VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y); /* 703 */
+   void (GLAPIENTRYP VertexAttrib2svNV)(GLuint index, const GLshort * v); /* 704 */
+   void (GLAPIENTRYP VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 705 */
+   void (GLAPIENTRYP VertexAttrib3dvNV)(GLuint index, const GLdouble * v); /* 706 */
+   void (GLAPIENTRYP VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 707 */
+   void (GLAPIENTRYP VertexAttrib3fvNV)(GLuint index, const GLfloat * v); /* 708 */
+   void (GLAPIENTRYP VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z); /* 709 */
+   void (GLAPIENTRYP VertexAttrib3svNV)(GLuint index, const GLshort * v); /* 710 */
+   void (GLAPIENTRYP VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 711 */
+   void (GLAPIENTRYP VertexAttrib4dvNV)(GLuint index, const GLdouble * v); /* 712 */
+   void (GLAPIENTRYP VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 713 */
+   void (GLAPIENTRYP VertexAttrib4fvNV)(GLuint index, const GLfloat * v); /* 714 */
+   void (GLAPIENTRYP VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 715 */
+   void (GLAPIENTRYP VertexAttrib4svNV)(GLuint index, const GLshort * v); /* 716 */
+   void (GLAPIENTRYP VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 717 */
+   void (GLAPIENTRYP VertexAttrib4ubvNV)(GLuint index, const GLubyte * v); /* 718 */
+   void (GLAPIENTRYP VertexAttribPointerNV)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 719 */
+   void (GLAPIENTRYP VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 720 */
+   void (GLAPIENTRYP VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 721 */
+   void (GLAPIENTRYP VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort * v); /* 722 */
+   void (GLAPIENTRYP VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 723 */
+   void (GLAPIENTRYP VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 724 */
+   void (GLAPIENTRYP VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort * v); /* 725 */
+   void (GLAPIENTRYP VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 726 */
+   void (GLAPIENTRYP VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 727 */
+   void (GLAPIENTRYP VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort * v); /* 728 */
+   void (GLAPIENTRYP VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 729 */
+   void (GLAPIENTRYP VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 730 */
+   void (GLAPIENTRYP VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort * v); /* 731 */
+   void (GLAPIENTRYP VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte * v); /* 732 */
+   void (GLAPIENTRYP GetTexBumpParameterfvATI)(GLenum pname, GLfloat * param); /* 733 */
+   void (GLAPIENTRYP GetTexBumpParameterivATI)(GLenum pname, GLint * param); /* 734 */
+   void (GLAPIENTRYP TexBumpParameterfvATI)(GLenum pname, const GLfloat * param); /* 735 */
+   void (GLAPIENTRYP TexBumpParameterivATI)(GLenum pname, const GLint * param); /* 736 */
+   void (GLAPIENTRYP AlphaFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 737 */
+   void (GLAPIENTRYP AlphaFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 738 */
+   void (GLAPIENTRYP AlphaFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 739 */
+   void (GLAPIENTRYP BeginFragmentShaderATI)(void); /* 740 */
+   void (GLAPIENTRYP BindFragmentShaderATI)(GLuint id); /* 741 */
+   void (GLAPIENTRYP ColorFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 742 */
+   void (GLAPIENTRYP ColorFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 743 */
+   void (GLAPIENTRYP ColorFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 744 */
+   void (GLAPIENTRYP DeleteFragmentShaderATI)(GLuint id); /* 745 */
+   void (GLAPIENTRYP EndFragmentShaderATI)(void); /* 746 */
+   GLuint (GLAPIENTRYP GenFragmentShadersATI)(GLuint range); /* 747 */
+   void (GLAPIENTRYP PassTexCoordATI)(GLuint dst, GLuint coord, GLenum swizzle); /* 748 */
+   void (GLAPIENTRYP SampleMapATI)(GLuint dst, GLuint interp, GLenum swizzle); /* 749 */
+   void (GLAPIENTRYP SetFragmentShaderConstantATI)(GLuint dst, const GLfloat * value); /* 750 */
+   void (GLAPIENTRYP PointParameteriNV)(GLenum pname, GLint param); /* 751 */
+   void (GLAPIENTRYP PointParameterivNV)(GLenum pname, const GLint * params); /* 752 */
+   void (GLAPIENTRYP ActiveStencilFaceEXT)(GLenum face); /* 753 */
+   void (GLAPIENTRYP BindVertexArrayAPPLE)(GLuint array); /* 754 */
+   void (GLAPIENTRYP DeleteVertexArraysAPPLE)(GLsizei n, const GLuint * arrays); /* 755 */
+   void (GLAPIENTRYP GenVertexArraysAPPLE)(GLsizei n, GLuint * arrays); /* 756 */
+   GLboolean (GLAPIENTRYP IsVertexArrayAPPLE)(GLuint array); /* 757 */
+   void (GLAPIENTRYP GetProgramNamedParameterdvNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params); /* 758 */
+   void (GLAPIENTRYP GetProgramNamedParameterfvNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params); /* 759 */
+   void (GLAPIENTRYP ProgramNamedParameter4dNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 760 */
+   void (GLAPIENTRYP ProgramNamedParameter4dvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v); /* 761 */
+   void (GLAPIENTRYP ProgramNamedParameter4fNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 762 */
+   void (GLAPIENTRYP ProgramNamedParameter4fvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v); /* 763 */
+   void (GLAPIENTRYP DepthBoundsEXT)(GLclampd zmin, GLclampd zmax); /* 764 */
+   void (GLAPIENTRYP BlendEquationSeparateEXT)(GLenum modeRGB, GLenum modeA); /* 765 */
+   void (GLAPIENTRYP BindFramebufferEXT)(GLenum target, GLuint framebuffer); /* 766 */
+   void (GLAPIENTRYP BindRenderbufferEXT)(GLenum target, GLuint renderbuffer); /* 767 */
+   GLenum (GLAPIENTRYP CheckFramebufferStatusEXT)(GLenum target); /* 768 */
+   void (GLAPIENTRYP DeleteFramebuffersEXT)(GLsizei n, const GLuint * framebuffers); /* 769 */
+   void (GLAPIENTRYP DeleteRenderbuffersEXT)(GLsizei n, const GLuint * renderbuffers); /* 770 */
+   void (GLAPIENTRYP FramebufferRenderbufferEXT)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); /* 771 */
+   void (GLAPIENTRYP FramebufferTexture1DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 772 */
+   void (GLAPIENTRYP FramebufferTexture2DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 773 */
+   void (GLAPIENTRYP FramebufferTexture3DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); /* 774 */
+   void (GLAPIENTRYP GenFramebuffersEXT)(GLsizei n, GLuint * framebuffers); /* 775 */
+   void (GLAPIENTRYP GenRenderbuffersEXT)(GLsizei n, GLuint * renderbuffers); /* 776 */
+   void (GLAPIENTRYP GenerateMipmapEXT)(GLenum target); /* 777 */
+   void (GLAPIENTRYP GetFramebufferAttachmentParameterivEXT)(GLenum target, GLenum attachment, GLenum pname, GLint * params); /* 778 */
+   void (GLAPIENTRYP GetRenderbufferParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 779 */
+   GLboolean (GLAPIENTRYP IsFramebufferEXT)(GLuint framebuffer); /* 780 */
+   GLboolean (GLAPIENTRYP IsRenderbufferEXT)(GLuint renderbuffer); /* 781 */
+   void (GLAPIENTRYP RenderbufferStorageEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); /* 782 */
+   void (GLAPIENTRYP BlitFramebufferEXT)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); /* 783 */
+   void (GLAPIENTRYP BufferParameteriAPPLE)(GLenum target, GLenum pname, GLint param); /* 784 */
+   void (GLAPIENTRYP FlushMappedBufferRangeAPPLE)(GLenum target, GLintptr offset, GLsizeiptr size); /* 785 */
+   void (GLAPIENTRYP FramebufferTextureLayerEXT)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); /* 786 */
+   void (GLAPIENTRYP ProvokingVertexEXT)(GLenum mode); /* 787 */
+   void (GLAPIENTRYP GetTexParameterPointervAPPLE)(GLenum target, GLenum pname, GLvoid ** params); /* 788 */
+   void (GLAPIENTRYP TextureRangeAPPLE)(GLenum target, GLsizei length, GLvoid * pointer); /* 789 */
+   void (GLAPIENTRYP StencilFuncSeparateATI)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); /* 790 */
+   void (GLAPIENTRYP ProgramEnvParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 791 */
+   void (GLAPIENTRYP ProgramLocalParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 792 */
+   void (GLAPIENTRYP GetQueryObjecti64vEXT)(GLuint id, GLenum pname, GLint64EXT * params); /* 793 */
+   void (GLAPIENTRYP GetQueryObjectui64vEXT)(GLuint id, GLenum pname, GLuint64EXT * params); /* 794 */
 };
 
 #endif /* !defined( _GLAPI_TABLE_H_ ) */
diff --git a/src/mesa/glapi/glapitemp.h b/src/mesa/glapi/glapitemp.h
index e08f9548f5..d9a3690f2a 100644
--- a/src/mesa/glapi/glapitemp.h
+++ b/src/mesa/glapi/glapitemp.h
@@ -4071,63 +4071,78 @@ KEYWORD1 void KEYWORD2 NAME(WaitSync)(GLsync sync, GLbitfield flags, GLuint64 ti
    DISPATCH(WaitSync, (sync, flags, timeout), (F, "glWaitSync(%d, %d, %d);\n", sync, flags, timeout));
 }
 
+KEYWORD1 void KEYWORD2 NAME(DrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex)
+{
+   DISPATCH(DrawElementsBaseVertex, (mode, count, type, indices, basevertex), (F, "glDrawElementsBaseVertex(0x%x, %d, 0x%x, %p, %d);\n", mode, count, type, (const void *) indices, basevertex));
+}
+
+KEYWORD1 void KEYWORD2 NAME(DrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex)
+{
+   DISPATCH(DrawRangeElementsBaseVertex, (mode, start, end, count, type, indices, basevertex), (F, "glDrawRangeElementsBaseVertex(0x%x, %d, %d, %d, 0x%x, %p, %d);\n", mode, start, end, count, type, (const void *) indices, basevertex));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiDrawElementsBaseVertex)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount, const GLint * basevertex)
+{
+   DISPATCH(MultiDrawElementsBaseVertex, (mode, count, type, indices, primcount, basevertex), (F, "glMultiDrawElementsBaseVertex(0x%x, %p, 0x%x, %p, %d, %p);\n", mode, (const void *) count, type, (const void *) indices, primcount, (const void *) basevertex));
+}
+
 KEYWORD1 void KEYWORD2 NAME(PolygonOffsetEXT)(GLfloat factor, GLfloat bias)
 {
    DISPATCH(PolygonOffsetEXT, (factor, bias), (F, "glPolygonOffsetEXT(%f, %f);\n", factor, bias));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_575)(GLenum pname, GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_575)(GLenum pname, GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, GLfloat * params)
 {
    DISPATCH(GetPixelTexGenParameterfvSGIS, (pname, params), (F, "glGetPixelTexGenParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_576)(GLenum pname, GLint * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_576)(GLenum pname, GLint * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint * params)
 {
    DISPATCH(GetPixelTexGenParameterivSGIS, (pname, params), (F, "glGetPixelTexGenParameterivSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_577)(GLenum pname, GLfloat param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, GLfloat param);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_577)(GLenum pname, GLfloat param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, GLfloat param)
 {
    DISPATCH(PixelTexGenParameterfSGIS, (pname, param), (F, "glPixelTexGenParameterfSGIS(0x%x, %f);\n", pname, param));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLenum pname, const GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLenum pname, const GLfloat * params)
 {
    DISPATCH(PixelTexGenParameterfvSGIS, (pname, params), (F, "glPixelTexGenParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pname, GLint param);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pname, GLint param)
 {
    DISPATCH(PixelTexGenParameteriSGIS, (pname, param), (F, "glPixelTexGenParameteriSGIS(0x%x, %d);\n", pname, param));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, const GLint * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_583)(GLenum pname, const GLint * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, const GLint * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_583)(GLenum pname, const GLint * params)
 {
    DISPATCH(PixelTexGenParameterivSGIS, (pname, params), (F, "glPixelTexGenParameterivSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLclampf value, GLboolean invert);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_584)(GLclampf value, GLboolean invert);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLclampf value, GLboolean invert)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_584)(GLclampf value, GLboolean invert)
 {
    DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskSGIS(%f, %d);\n", value, invert));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pattern);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_585)(GLenum pattern);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pattern)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_585)(GLenum pattern)
 {
    DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternSGIS(0x%x);\n", pattern));
 }
@@ -4177,9 +4192,9 @@ KEYWORD1 void KEYWORD2 NAME(PointParameterfEXT)(GLenum pname, GLfloat param)
    DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfEXT(0x%x, %f);\n", pname, param));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_589)(GLenum pname, GLfloat param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_592)(GLenum pname, GLfloat param);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_589)(GLenum pname, GLfloat param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_592)(GLenum pname, GLfloat param)
 {
    DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfSGIS(0x%x, %f);\n", pname, param));
 }
@@ -4199,9 +4214,9 @@ KEYWORD1 void KEYWORD2 NAME(PointParameterfvEXT)(GLenum pname, const GLfloat * p
    DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvEXT(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_590)(GLenum pname, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, const GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_590)(GLenum pname, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, const GLfloat * params)
 {
    DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
@@ -4216,16 +4231,16 @@ KEYWORD1 void KEYWORD2 NAME(UnlockArraysEXT)(void)
    DISPATCH(UnlockArraysEXT, (), (F, "glUnlockArraysEXT();\n"));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, GLdouble * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_596)(GLenum pname, GLdouble * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, GLdouble * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_596)(GLenum pname, GLdouble * params)
 {
    DISPATCH(CullParameterdvEXT, (pname, params), (F, "glCullParameterdvEXT(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_594)(GLenum pname, GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_597)(GLenum pname, GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_594)(GLenum pname, GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_597)(GLenum pname, GLfloat * params)
 {
    DISPATCH(CullParameterfvEXT, (pname, params), (F, "glCullParameterfvEXT(0x%x, %p);\n", pname, (const void *) params));
 }
@@ -4470,9 +4485,9 @@ KEYWORD1 void KEYWORD2 NAME(FogCoordfvEXT)(const GLfloat * coord)
    DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfvEXT(%p);\n", (const void *) coord));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_619)(GLenum mode);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_622)(GLenum mode);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_619)(GLenum mode)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_622)(GLenum mode)
 {
    DISPATCH(PixelTexGenSGIX, (mode), (F, "glPixelTexGenSGIX(0x%x);\n", mode));
 }
@@ -4487,9 +4502,9 @@ KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfac
    DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateEXT(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_620)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_623)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_620)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_623)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
    DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateINGR(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
 }
@@ -4854,65 +4869,65 @@ KEYWORD1 void KEYWORD2 NAME(WindowPos4svMESA)(const GLshort * v)
    DISPATCH(WindowPos4svMESA, (v), (F, "glWindowPos4svMESA(%p);\n", (const void *) v));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_661)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_661)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)
 {
    DISPATCH(MultiModeDrawArraysIBM, (mode, first, count, primcount, modestride), (F, "glMultiModeDrawArraysIBM(%p, %p, %p, %d, %d);\n", (const void *) mode, (const void *) first, (const void *) count, primcount, modestride));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_662)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_662)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride)
 {
    DISPATCH(MultiModeDrawElementsIBM, (mode, count, type, indices, primcount, modestride), (F, "glMultiModeDrawElementsIBM(%p, %p, 0x%x, %p, %d, %d);\n", (const void *) mode, (const void *) count, type, (const void *) indices, primcount, modestride));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_663)(GLsizei n, const GLuint * fences);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLsizei n, const GLuint * fences);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_663)(GLsizei n, const GLuint * fences)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLsizei n, const GLuint * fences)
 {
    DISPATCH(DeleteFencesNV, (n, fences), (F, "glDeleteFencesNV(%d, %p);\n", n, (const void *) fences));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(GLuint fence);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(GLuint fence)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence)
 {
    DISPATCH(FinishFenceNV, (fence), (F, "glFinishFenceNV(%d);\n", fence));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(GLsizei n, GLuint * fences);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLsizei n, GLuint * fences);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(GLsizei n, GLuint * fences)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLsizei n, GLuint * fences)
 {
    DISPATCH(GenFencesNV, (n, fences), (F, "glGenFencesNV(%d, %p);\n", n, (const void *) fences));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLuint fence, GLenum pname, GLint * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence, GLenum pname, GLint * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLuint fence, GLenum pname, GLint * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence, GLenum pname, GLint * params)
 {
    DISPATCH(GetFenceivNV, (fence, pname, params), (F, "glGetFenceivNV(%d, 0x%x, %p);\n", fence, pname, (const void *) params));
 }
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence);
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_670)(GLuint fence);
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence)
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_670)(GLuint fence)
 {
    RETURN_DISPATCH(IsFenceNV, (fence), (F, "glIsFenceNV(%d);\n", fence));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLuint fence, GLenum condition);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_671)(GLuint fence, GLenum condition);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLuint fence, GLenum condition)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_671)(GLuint fence, GLenum condition)
 {
    DISPATCH(SetFenceNV, (fence, condition), (F, "glSetFenceNV(%d, 0x%x);\n", fence, condition));
 }
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence);
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_672)(GLuint fence);
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence)
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_672)(GLuint fence)
 {
    RETURN_DISPATCH(TestFenceNV, (fence), (F, "glTestFenceNV(%d);\n", fence));
 }
@@ -5357,16 +5372,16 @@ KEYWORD1 void KEYWORD2 NAME(PointParameterivNV)(GLenum pname, const GLint * para
    DISPATCH(PointParameterivNV, (pname, params), (F, "glPointParameterivNV(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_750)(GLenum face);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLenum face);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_750)(GLenum face)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLenum face)
 {
    DISPATCH(ActiveStencilFaceEXT, (face), (F, "glActiveStencilFaceEXT(0x%x);\n", face));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_751)(GLuint array);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_754)(GLuint array);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_751)(GLuint array)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_754)(GLuint array)
 {
    DISPATCH(BindVertexArrayAPPLE, (array), (F, "glBindVertexArrayAPPLE(%d);\n", array));
 }
@@ -5376,16 +5391,16 @@ KEYWORD1 void KEYWORD2 NAME(DeleteVertexArrays)(GLsizei n, const GLuint * arrays
    DISPATCH(DeleteVertexArraysAPPLE, (n, arrays), (F, "glDeleteVertexArrays(%d, %p);\n", n, (const void *) arrays));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_752)(GLsizei n, const GLuint * arrays);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_755)(GLsizei n, const GLuint * arrays);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_752)(GLsizei n, const GLuint * arrays)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_755)(GLsizei n, const GLuint * arrays)
 {
    DISPATCH(DeleteVertexArraysAPPLE, (n, arrays), (F, "glDeleteVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLsizei n, GLuint * arrays);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_756)(GLsizei n, GLuint * arrays);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLsizei n, GLuint * arrays)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_756)(GLsizei n, GLuint * arrays)
 {
    DISPATCH(GenVertexArraysAPPLE, (n, arrays), (F, "glGenVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays));
 }
@@ -5395,9 +5410,9 @@ KEYWORD1 GLboolean KEYWORD2 NAME(IsVertexArray)(GLuint array)
    RETURN_DISPATCH(IsVertexArrayAPPLE, (array), (F, "glIsVertexArray(%d);\n", array));
 }
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_754)(GLuint array);
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_757)(GLuint array);
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_754)(GLuint array)
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_757)(GLuint array)
 {
    RETURN_DISPATCH(IsVertexArrayAPPLE, (array), (F, "glIsVertexArrayAPPLE(%d);\n", array));
 }
@@ -5432,9 +5447,9 @@ KEYWORD1 void KEYWORD2 NAME(ProgramNamedParameter4fvNV)(GLuint id, GLsizei len,
    DISPATCH(ProgramNamedParameter4fvNV, (id, len, name, v), (F, "glProgramNamedParameter4fvNV(%d, %d, %p, %p);\n", id, len, (const void *) name, (const void *) v));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_761)(GLclampd zmin, GLclampd zmax);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_764)(GLclampd zmin, GLclampd zmax);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_761)(GLclampd zmin, GLclampd zmax)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_764)(GLclampd zmin, GLclampd zmax)
 {
    DISPATCH(DepthBoundsEXT, (zmin, zmax), (F, "glDepthBoundsEXT(%f, %f);\n", zmin, zmax));
 }
@@ -5444,9 +5459,9 @@ KEYWORD1 void KEYWORD2 NAME(BlendEquationSeparate)(GLenum modeRGB, GLenum modeA)
    DISPATCH(BlendEquationSeparateEXT, (modeRGB, modeA), (F, "glBlendEquationSeparate(0x%x, 0x%x);\n", modeRGB, modeA));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_762)(GLenum modeRGB, GLenum modeA);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_765)(GLenum modeRGB, GLenum modeA);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_762)(GLenum modeRGB, GLenum modeA)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_765)(GLenum modeRGB, GLenum modeA)
 {
    DISPATCH(BlendEquationSeparateEXT, (modeRGB, modeA), (F, "glBlendEquationSeparateEXT(0x%x, 0x%x);\n", modeRGB, modeA));
 }
@@ -5626,23 +5641,23 @@ KEYWORD1 void KEYWORD2 NAME(BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint src
    DISPATCH(BlitFramebufferEXT, (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter), (F, "glBlitFramebuffer(%d, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x);\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_780)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_783)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_780)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_783)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
    DISPATCH(BlitFramebufferEXT, (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter), (F, "glBlitFramebufferEXT(%d, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x);\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_781)(GLenum target, GLenum pname, GLint param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_784)(GLenum target, GLenum pname, GLint param);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_781)(GLenum target, GLenum pname, GLint param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_784)(GLenum target, GLenum pname, GLint param)
 {
    DISPATCH(BufferParameteriAPPLE, (target, pname, param), (F, "glBufferParameteriAPPLE(0x%x, 0x%x, %d);\n", target, pname, param));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_782)(GLenum target, GLintptr offset, GLsizeiptr size);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLintptr offset, GLsizeiptr size);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_782)(GLenum target, GLintptr offset, GLsizeiptr size)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLintptr offset, GLsizeiptr size)
 {
    DISPATCH(FlushMappedBufferRangeAPPLE, (target, offset, size), (F, "glFlushMappedBufferRangeAPPLE(0x%x, %d, %d);\n", target, offset, size));
 }
@@ -5662,51 +5677,56 @@ KEYWORD1 void KEYWORD2 NAME(ProvokingVertexEXT)(GLenum mode)
    DISPATCH(ProvokingVertexEXT, (mode), (F, "glProvokingVertexEXT(0x%x);\n", mode));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLenum pname, GLvoid ** params);
+KEYWORD1 void KEYWORD2 NAME(ProvokingVertex)(GLenum mode)
+{
+   DISPATCH(ProvokingVertexEXT, (mode), (F, "glProvokingVertex(0x%x);\n", mode));
+}
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLenum pname, GLvoid ** params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_788)(GLenum target, GLenum pname, GLvoid ** params);
+
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_788)(GLenum target, GLenum pname, GLvoid ** params)
 {
    DISPATCH(GetTexParameterPointervAPPLE, (target, pname, params), (F, "glGetTexParameterPointervAPPLE(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_786)(GLenum target, GLsizei length, GLvoid * pointer);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_789)(GLenum target, GLsizei length, GLvoid * pointer);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_786)(GLenum target, GLsizei length, GLvoid * pointer)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_789)(GLenum target, GLsizei length, GLvoid * pointer)
 {
    DISPATCH(TextureRangeAPPLE, (target, length, pointer), (F, "glTextureRangeAPPLE(0x%x, %d, %p);\n", target, length, (const void *) pointer));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_787)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_790)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_787)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_790)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
 {
    DISPATCH(StencilFuncSeparateATI, (frontfunc, backfunc, ref, mask), (F, "glStencilFuncSeparateATI(0x%x, 0x%x, %d, %d);\n", frontfunc, backfunc, ref, mask));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_788)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_791)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_788)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_791)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
 {
    DISPATCH(ProgramEnvParameters4fvEXT, (target, index, count, params), (F, "glProgramEnvParameters4fvEXT(0x%x, %d, %d, %p);\n", target, index, count, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_789)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_792)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_789)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_792)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
 {
    DISPATCH(ProgramLocalParameters4fvEXT, (target, index, count, params), (F, "glProgramLocalParameters4fvEXT(0x%x, %d, %d, %p);\n", target, index, count, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_790)(GLuint id, GLenum pname, GLint64EXT * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_793)(GLuint id, GLenum pname, GLint64EXT * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_790)(GLuint id, GLenum pname, GLint64EXT * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_793)(GLuint id, GLenum pname, GLint64EXT * params)
 {
    DISPATCH(GetQueryObjecti64vEXT, (id, pname, params), (F, "glGetQueryObjecti64vEXT(%d, 0x%x, %p);\n", id, pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_791)(GLuint id, GLenum pname, GLuint64EXT * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_794)(GLuint id, GLenum pname, GLuint64EXT * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_791)(GLuint id, GLenum pname, GLuint64EXT * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_794)(GLuint id, GLenum pname, GLuint64EXT * params)
 {
    DISPATCH(GetQueryObjectui64vEXT, (id, pname, params), (F, "glGetQueryObjectui64vEXT(%d, 0x%x, %p);\n", id, pname, (const void *) params));
 }
@@ -6299,15 +6319,18 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(GetSynciv),
    TABLE_ENTRY(IsSync),
    TABLE_ENTRY(WaitSync),
+   TABLE_ENTRY(DrawElementsBaseVertex),
+   TABLE_ENTRY(DrawRangeElementsBaseVertex),
+   TABLE_ENTRY(MultiDrawElementsBaseVertex),
    TABLE_ENTRY(PolygonOffsetEXT),
-   TABLE_ENTRY(_dispatch_stub_575),
-   TABLE_ENTRY(_dispatch_stub_576),
-   TABLE_ENTRY(_dispatch_stub_577),
    TABLE_ENTRY(_dispatch_stub_578),
    TABLE_ENTRY(_dispatch_stub_579),
    TABLE_ENTRY(_dispatch_stub_580),
    TABLE_ENTRY(_dispatch_stub_581),
    TABLE_ENTRY(_dispatch_stub_582),
+   TABLE_ENTRY(_dispatch_stub_583),
+   TABLE_ENTRY(_dispatch_stub_584),
+   TABLE_ENTRY(_dispatch_stub_585),
    TABLE_ENTRY(ColorPointerEXT),
    TABLE_ENTRY(EdgeFlagPointerEXT),
    TABLE_ENTRY(IndexPointerEXT),
@@ -6318,8 +6341,8 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(PointParameterfvEXT),
    TABLE_ENTRY(LockArraysEXT),
    TABLE_ENTRY(UnlockArraysEXT),
-   TABLE_ENTRY(_dispatch_stub_593),
-   TABLE_ENTRY(_dispatch_stub_594),
+   TABLE_ENTRY(_dispatch_stub_596),
+   TABLE_ENTRY(_dispatch_stub_597),
    TABLE_ENTRY(SecondaryColor3bEXT),
    TABLE_ENTRY(SecondaryColor3bvEXT),
    TABLE_ENTRY(SecondaryColor3dEXT),
@@ -6344,7 +6367,7 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(FogCoorddvEXT),
    TABLE_ENTRY(FogCoordfEXT),
    TABLE_ENTRY(FogCoordfvEXT),
-   TABLE_ENTRY(_dispatch_stub_619),
+   TABLE_ENTRY(_dispatch_stub_622),
    TABLE_ENTRY(BlendFuncSeparateEXT),
    TABLE_ENTRY(FlushVertexArrayRangeNV),
    TABLE_ENTRY(VertexArrayRangeNV),
@@ -6386,15 +6409,15 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(WindowPos4ivMESA),
    TABLE_ENTRY(WindowPos4sMESA),
    TABLE_ENTRY(WindowPos4svMESA),
-   TABLE_ENTRY(_dispatch_stub_661),
-   TABLE_ENTRY(_dispatch_stub_662),
-   TABLE_ENTRY(_dispatch_stub_663),
    TABLE_ENTRY(_dispatch_stub_664),
    TABLE_ENTRY(_dispatch_stub_665),
    TABLE_ENTRY(_dispatch_stub_666),
    TABLE_ENTRY(_dispatch_stub_667),
    TABLE_ENTRY(_dispatch_stub_668),
    TABLE_ENTRY(_dispatch_stub_669),
+   TABLE_ENTRY(_dispatch_stub_670),
+   TABLE_ENTRY(_dispatch_stub_671),
+   TABLE_ENTRY(_dispatch_stub_672),
    TABLE_ENTRY(AreProgramsResidentNV),
    TABLE_ENTRY(BindProgramNV),
    TABLE_ENTRY(DeleteProgramsNV),
@@ -6475,19 +6498,19 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(SetFragmentShaderConstantATI),
    TABLE_ENTRY(PointParameteriNV),
    TABLE_ENTRY(PointParameterivNV),
-   TABLE_ENTRY(_dispatch_stub_750),
-   TABLE_ENTRY(_dispatch_stub_751),
-   TABLE_ENTRY(_dispatch_stub_752),
    TABLE_ENTRY(_dispatch_stub_753),
    TABLE_ENTRY(_dispatch_stub_754),
+   TABLE_ENTRY(_dispatch_stub_755),
+   TABLE_ENTRY(_dispatch_stub_756),
+   TABLE_ENTRY(_dispatch_stub_757),
    TABLE_ENTRY(GetProgramNamedParameterdvNV),
    TABLE_ENTRY(GetProgramNamedParameterfvNV),
    TABLE_ENTRY(ProgramNamedParameter4dNV),
    TABLE_ENTRY(ProgramNamedParameter4dvNV),
    TABLE_ENTRY(ProgramNamedParameter4fNV),
    TABLE_ENTRY(ProgramNamedParameter4fvNV),
-   TABLE_ENTRY(_dispatch_stub_761),
-   TABLE_ENTRY(_dispatch_stub_762),
+   TABLE_ENTRY(_dispatch_stub_764),
+   TABLE_ENTRY(_dispatch_stub_765),
    TABLE_ENTRY(BindFramebufferEXT),
    TABLE_ENTRY(BindRenderbufferEXT),
    TABLE_ENTRY(CheckFramebufferStatusEXT),
@@ -6505,18 +6528,18 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(IsFramebufferEXT),
    TABLE_ENTRY(IsRenderbufferEXT),
    TABLE_ENTRY(RenderbufferStorageEXT),
-   TABLE_ENTRY(_dispatch_stub_780),
-   TABLE_ENTRY(_dispatch_stub_781),
-   TABLE_ENTRY(_dispatch_stub_782),
+   TABLE_ENTRY(_dispatch_stub_783),
+   TABLE_ENTRY(_dispatch_stub_784),
+   TABLE_ENTRY(_dispatch_stub_785),
    TABLE_ENTRY(FramebufferTextureLayerEXT),
    TABLE_ENTRY(ProvokingVertexEXT),
-   TABLE_ENTRY(_dispatch_stub_785),
-   TABLE_ENTRY(_dispatch_stub_786),
-   TABLE_ENTRY(_dispatch_stub_787),
    TABLE_ENTRY(_dispatch_stub_788),
    TABLE_ENTRY(_dispatch_stub_789),
    TABLE_ENTRY(_dispatch_stub_790),
    TABLE_ENTRY(_dispatch_stub_791),
+   TABLE_ENTRY(_dispatch_stub_792),
+   TABLE_ENTRY(_dispatch_stub_793),
+   TABLE_ENTRY(_dispatch_stub_794),
    /* A whole bunch of no-op functions.  These might be called
     * when someone tries to call a dynamically-registered
     * extension function without a current rendering context.
@@ -6905,6 +6928,7 @@ static _glapi_proc UNUSED_TABLE_NAME[] = {
    TABLE_ENTRY(RenderbufferStorage),
    TABLE_ENTRY(BlitFramebuffer),
    TABLE_ENTRY(FramebufferTextureLayer),
+   TABLE_ENTRY(ProvokingVertex),
 };
 #endif /*UNUSED_TABLE_NAME*/
 
diff --git a/src/mesa/glapi/glprocs.h b/src/mesa/glapi/glprocs.h
index ae6603262e..c29f8b57be 100644
--- a/src/mesa/glapi/glprocs.h
+++ b/src/mesa/glapi/glprocs.h
@@ -626,6 +626,9 @@ static const char gl_string_table[] =
     "glGetSynciv\0"
     "glIsSync\0"
     "glWaitSync\0"
+    "glDrawElementsBaseVertex\0"
+    "glDrawRangeElementsBaseVertex\0"
+    "glMultiDrawElementsBaseVertex\0"
     "glPolygonOffsetEXT\0"
     "glGetPixelTexGenParameterfvSGIS\0"
     "glGetPixelTexGenParameterivSGIS\0"
@@ -1144,6 +1147,7 @@ static const char gl_string_table[] =
     "glRenderbufferStorage\0"
     "glBlitFramebuffer\0"
     "glFramebufferTextureLayer\0"
+    "glProvokingVertex\0"
     ;
 
 
@@ -1161,43 +1165,43 @@ static const char gl_string_table[] =
 #define gl_dispatch_stub_364 mgl_dispatch_stub_364
 #define gl_dispatch_stub_365 mgl_dispatch_stub_365
 #define gl_dispatch_stub_366 mgl_dispatch_stub_366
-#define gl_dispatch_stub_575 mgl_dispatch_stub_575
-#define gl_dispatch_stub_576 mgl_dispatch_stub_576
-#define gl_dispatch_stub_577 mgl_dispatch_stub_577
 #define gl_dispatch_stub_578 mgl_dispatch_stub_578
 #define gl_dispatch_stub_579 mgl_dispatch_stub_579
 #define gl_dispatch_stub_580 mgl_dispatch_stub_580
 #define gl_dispatch_stub_581 mgl_dispatch_stub_581
 #define gl_dispatch_stub_582 mgl_dispatch_stub_582
-#define gl_dispatch_stub_593 mgl_dispatch_stub_593
-#define gl_dispatch_stub_594 mgl_dispatch_stub_594
-#define gl_dispatch_stub_619 mgl_dispatch_stub_619
-#define gl_dispatch_stub_661 mgl_dispatch_stub_661
-#define gl_dispatch_stub_662 mgl_dispatch_stub_662
-#define gl_dispatch_stub_663 mgl_dispatch_stub_663
+#define gl_dispatch_stub_583 mgl_dispatch_stub_583
+#define gl_dispatch_stub_584 mgl_dispatch_stub_584
+#define gl_dispatch_stub_585 mgl_dispatch_stub_585
+#define gl_dispatch_stub_596 mgl_dispatch_stub_596
+#define gl_dispatch_stub_597 mgl_dispatch_stub_597
+#define gl_dispatch_stub_622 mgl_dispatch_stub_622
 #define gl_dispatch_stub_664 mgl_dispatch_stub_664
 #define gl_dispatch_stub_665 mgl_dispatch_stub_665
 #define gl_dispatch_stub_666 mgl_dispatch_stub_666
 #define gl_dispatch_stub_667 mgl_dispatch_stub_667
 #define gl_dispatch_stub_668 mgl_dispatch_stub_668
 #define gl_dispatch_stub_669 mgl_dispatch_stub_669
-#define gl_dispatch_stub_750 mgl_dispatch_stub_750
-#define gl_dispatch_stub_751 mgl_dispatch_stub_751
-#define gl_dispatch_stub_752 mgl_dispatch_stub_752
+#define gl_dispatch_stub_670 mgl_dispatch_stub_670
+#define gl_dispatch_stub_671 mgl_dispatch_stub_671
+#define gl_dispatch_stub_672 mgl_dispatch_stub_672
 #define gl_dispatch_stub_753 mgl_dispatch_stub_753
 #define gl_dispatch_stub_754 mgl_dispatch_stub_754
-#define gl_dispatch_stub_761 mgl_dispatch_stub_761
-#define gl_dispatch_stub_762 mgl_dispatch_stub_762
-#define gl_dispatch_stub_780 mgl_dispatch_stub_780
-#define gl_dispatch_stub_781 mgl_dispatch_stub_781
-#define gl_dispatch_stub_782 mgl_dispatch_stub_782
+#define gl_dispatch_stub_755 mgl_dispatch_stub_755
+#define gl_dispatch_stub_756 mgl_dispatch_stub_756
+#define gl_dispatch_stub_757 mgl_dispatch_stub_757
+#define gl_dispatch_stub_764 mgl_dispatch_stub_764
+#define gl_dispatch_stub_765 mgl_dispatch_stub_765
+#define gl_dispatch_stub_783 mgl_dispatch_stub_783
+#define gl_dispatch_stub_784 mgl_dispatch_stub_784
 #define gl_dispatch_stub_785 mgl_dispatch_stub_785
-#define gl_dispatch_stub_786 mgl_dispatch_stub_786
-#define gl_dispatch_stub_787 mgl_dispatch_stub_787
 #define gl_dispatch_stub_788 mgl_dispatch_stub_788
 #define gl_dispatch_stub_789 mgl_dispatch_stub_789
 #define gl_dispatch_stub_790 mgl_dispatch_stub_790
 #define gl_dispatch_stub_791 mgl_dispatch_stub_791
+#define gl_dispatch_stub_792 mgl_dispatch_stub_792
+#define gl_dispatch_stub_793 mgl_dispatch_stub_793
+#define gl_dispatch_stub_794 mgl_dispatch_stub_794
 #endif /* USE_MGL_NAMESPACE */
 
 
@@ -1215,43 +1219,43 @@ void GLAPIENTRY gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params
 void GLAPIENTRY gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values);
 void GLAPIENTRY gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params);
 void GLAPIENTRY gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params);
-void GLAPIENTRY gl_dispatch_stub_575(GLenum pname, GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_576(GLenum pname, GLint * params);
-void GLAPIENTRY gl_dispatch_stub_577(GLenum pname, GLfloat param);
-void GLAPIENTRY gl_dispatch_stub_578(GLenum pname, const GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_579(GLenum pname, GLint param);
-void GLAPIENTRY gl_dispatch_stub_580(GLenum pname, const GLint * params);
-void GLAPIENTRY gl_dispatch_stub_581(GLclampf value, GLboolean invert);
-void GLAPIENTRY gl_dispatch_stub_582(GLenum pattern);
-void GLAPIENTRY gl_dispatch_stub_593(GLenum pname, GLdouble * params);
-void GLAPIENTRY gl_dispatch_stub_594(GLenum pname, GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_619(GLenum mode);
-void GLAPIENTRY gl_dispatch_stub_661(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
-void GLAPIENTRY gl_dispatch_stub_662(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
-void GLAPIENTRY gl_dispatch_stub_663(GLsizei n, const GLuint * fences);
-void GLAPIENTRY gl_dispatch_stub_664(GLuint fence);
-void GLAPIENTRY gl_dispatch_stub_665(GLsizei n, GLuint * fences);
-void GLAPIENTRY gl_dispatch_stub_666(GLuint fence, GLenum pname, GLint * params);
-GLboolean GLAPIENTRY gl_dispatch_stub_667(GLuint fence);
-void GLAPIENTRY gl_dispatch_stub_668(GLuint fence, GLenum condition);
-GLboolean GLAPIENTRY gl_dispatch_stub_669(GLuint fence);
-void GLAPIENTRY gl_dispatch_stub_750(GLenum face);
-void GLAPIENTRY gl_dispatch_stub_751(GLuint array);
-void GLAPIENTRY gl_dispatch_stub_752(GLsizei n, const GLuint * arrays);
-void GLAPIENTRY gl_dispatch_stub_753(GLsizei n, GLuint * arrays);
-GLboolean GLAPIENTRY gl_dispatch_stub_754(GLuint array);
-void GLAPIENTRY gl_dispatch_stub_761(GLclampd zmin, GLclampd zmax);
-void GLAPIENTRY gl_dispatch_stub_762(GLenum modeRGB, GLenum modeA);
-void GLAPIENTRY gl_dispatch_stub_780(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-void GLAPIENTRY gl_dispatch_stub_781(GLenum target, GLenum pname, GLint param);
-void GLAPIENTRY gl_dispatch_stub_782(GLenum target, GLintptr offset, GLsizeiptr size);
-void GLAPIENTRY gl_dispatch_stub_785(GLenum target, GLenum pname, GLvoid ** params);
-void GLAPIENTRY gl_dispatch_stub_786(GLenum target, GLsizei length, GLvoid * pointer);
-void GLAPIENTRY gl_dispatch_stub_787(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
-void GLAPIENTRY gl_dispatch_stub_788(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_789(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_790(GLuint id, GLenum pname, GLint64EXT * params);
-void GLAPIENTRY gl_dispatch_stub_791(GLuint id, GLenum pname, GLuint64EXT * params);
+void GLAPIENTRY gl_dispatch_stub_578(GLenum pname, GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_579(GLenum pname, GLint * params);
+void GLAPIENTRY gl_dispatch_stub_580(GLenum pname, GLfloat param);
+void GLAPIENTRY gl_dispatch_stub_581(GLenum pname, const GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_582(GLenum pname, GLint param);
+void GLAPIENTRY gl_dispatch_stub_583(GLenum pname, const GLint * params);
+void GLAPIENTRY gl_dispatch_stub_584(GLclampf value, GLboolean invert);
+void GLAPIENTRY gl_dispatch_stub_585(GLenum pattern);
+void GLAPIENTRY gl_dispatch_stub_596(GLenum pname, GLdouble * params);
+void GLAPIENTRY gl_dispatch_stub_597(GLenum pname, GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_622(GLenum mode);
+void GLAPIENTRY gl_dispatch_stub_664(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
+void GLAPIENTRY gl_dispatch_stub_665(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
+void GLAPIENTRY gl_dispatch_stub_666(GLsizei n, const GLuint * fences);
+void GLAPIENTRY gl_dispatch_stub_667(GLuint fence);
+void GLAPIENTRY gl_dispatch_stub_668(GLsizei n, GLuint * fences);
+void GLAPIENTRY gl_dispatch_stub_669(GLuint fence, GLenum pname, GLint * params);
+GLboolean GLAPIENTRY gl_dispatch_stub_670(GLuint fence);
+void GLAPIENTRY gl_dispatch_stub_671(GLuint fence, GLenum condition);
+GLboolean GLAPIENTRY gl_dispatch_stub_672(GLuint fence);
+void GLAPIENTRY gl_dispatch_stub_753(GLenum face);
+void GLAPIENTRY gl_dispatch_stub_754(GLuint array);
+void GLAPIENTRY gl_dispatch_stub_755(GLsizei n, const GLuint * arrays);
+void GLAPIENTRY gl_dispatch_stub_756(GLsizei n, GLuint * arrays);
+GLboolean GLAPIENTRY gl_dispatch_stub_757(GLuint array);
+void GLAPIENTRY gl_dispatch_stub_764(GLclampd zmin, GLclampd zmax);
+void GLAPIENTRY gl_dispatch_stub_765(GLenum modeRGB, GLenum modeA);
+void GLAPIENTRY gl_dispatch_stub_783(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+void GLAPIENTRY gl_dispatch_stub_784(GLenum target, GLenum pname, GLint param);
+void GLAPIENTRY gl_dispatch_stub_785(GLenum target, GLintptr offset, GLsizeiptr size);
+void GLAPIENTRY gl_dispatch_stub_788(GLenum target, GLenum pname, GLvoid ** params);
+void GLAPIENTRY gl_dispatch_stub_789(GLenum target, GLsizei length, GLvoid * pointer);
+void GLAPIENTRY gl_dispatch_stub_790(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+void GLAPIENTRY gl_dispatch_stub_791(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_792(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_793(GLuint id, GLenum pname, GLint64EXT * params);
+void GLAPIENTRY gl_dispatch_stub_794(GLuint id, GLenum pname, GLuint64EXT * params);
 #endif /* defined(NEED_FUNCTION_POINTER) || defined(GLX_INDIRECT_RENDERING) */
 
 static const glprocs_table_t static_functions[] = {
@@ -1829,524 +1833,528 @@ static const glprocs_table_t static_functions[] = {
     NAME_FUNC_OFFSET( 9140, glGetSynciv, glGetSynciv, NULL, _gloffset_GetSynciv),
     NAME_FUNC_OFFSET( 9152, glIsSync, glIsSync, NULL, _gloffset_IsSync),
     NAME_FUNC_OFFSET( 9161, glWaitSync, glWaitSync, NULL, _gloffset_WaitSync),
-    NAME_FUNC_OFFSET( 9172, glPolygonOffsetEXT, glPolygonOffsetEXT, NULL, _gloffset_PolygonOffsetEXT),
-    NAME_FUNC_OFFSET( 9191, gl_dispatch_stub_575, gl_dispatch_stub_575, NULL, _gloffset_GetPixelTexGenParameterfvSGIS),
-    NAME_FUNC_OFFSET( 9223, gl_dispatch_stub_576, gl_dispatch_stub_576, NULL, _gloffset_GetPixelTexGenParameterivSGIS),
-    NAME_FUNC_OFFSET( 9255, gl_dispatch_stub_577, gl_dispatch_stub_577, NULL, _gloffset_PixelTexGenParameterfSGIS),
-    NAME_FUNC_OFFSET( 9283, gl_dispatch_stub_578, gl_dispatch_stub_578, NULL, _gloffset_PixelTexGenParameterfvSGIS),
-    NAME_FUNC_OFFSET( 9312, gl_dispatch_stub_579, gl_dispatch_stub_579, NULL, _gloffset_PixelTexGenParameteriSGIS),
-    NAME_FUNC_OFFSET( 9340, gl_dispatch_stub_580, gl_dispatch_stub_580, NULL, _gloffset_PixelTexGenParameterivSGIS),
-    NAME_FUNC_OFFSET( 9369, gl_dispatch_stub_581, gl_dispatch_stub_581, NULL, _gloffset_SampleMaskSGIS),
-    NAME_FUNC_OFFSET( 9386, gl_dispatch_stub_582, gl_dispatch_stub_582, NULL, _gloffset_SamplePatternSGIS),
-    NAME_FUNC_OFFSET( 9406, glColorPointerEXT, glColorPointerEXT, NULL, _gloffset_ColorPointerEXT),
-    NAME_FUNC_OFFSET( 9424, glEdgeFlagPointerEXT, glEdgeFlagPointerEXT, NULL, _gloffset_EdgeFlagPointerEXT),
-    NAME_FUNC_OFFSET( 9445, glIndexPointerEXT, glIndexPointerEXT, NULL, _gloffset_IndexPointerEXT),
-    NAME_FUNC_OFFSET( 9463, glNormalPointerEXT, glNormalPointerEXT, NULL, _gloffset_NormalPointerEXT),
-    NAME_FUNC_OFFSET( 9482, glTexCoordPointerEXT, glTexCoordPointerEXT, NULL, _gloffset_TexCoordPointerEXT),
-    NAME_FUNC_OFFSET( 9503, glVertexPointerEXT, glVertexPointerEXT, NULL, _gloffset_VertexPointerEXT),
-    NAME_FUNC_OFFSET( 9522, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
-    NAME_FUNC_OFFSET( 9543, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
-    NAME_FUNC_OFFSET( 9565, glLockArraysEXT, glLockArraysEXT, NULL, _gloffset_LockArraysEXT),
-    NAME_FUNC_OFFSET( 9581, glUnlockArraysEXT, glUnlockArraysEXT, NULL, _gloffset_UnlockArraysEXT),
-    NAME_FUNC_OFFSET( 9599, gl_dispatch_stub_593, gl_dispatch_stub_593, NULL, _gloffset_CullParameterdvEXT),
-    NAME_FUNC_OFFSET( 9620, gl_dispatch_stub_594, gl_dispatch_stub_594, NULL, _gloffset_CullParameterfvEXT),
-    NAME_FUNC_OFFSET( 9641, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
-    NAME_FUNC_OFFSET( 9663, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
-    NAME_FUNC_OFFSET( 9686, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
-    NAME_FUNC_OFFSET( 9708, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
-    NAME_FUNC_OFFSET( 9731, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
-    NAME_FUNC_OFFSET( 9753, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
-    NAME_FUNC_OFFSET( 9776, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
-    NAME_FUNC_OFFSET( 9798, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
-    NAME_FUNC_OFFSET( 9821, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
-    NAME_FUNC_OFFSET( 9843, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
-    NAME_FUNC_OFFSET( 9866, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
-    NAME_FUNC_OFFSET( 9889, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
-    NAME_FUNC_OFFSET( 9913, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
-    NAME_FUNC_OFFSET( 9936, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
-    NAME_FUNC_OFFSET( 9960, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
-    NAME_FUNC_OFFSET( 9983, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
-    NAME_FUNC_OFFSET(10007, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
-    NAME_FUNC_OFFSET(10034, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
-    NAME_FUNC_OFFSET(10055, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
-    NAME_FUNC_OFFSET(10078, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
-    NAME_FUNC_OFFSET(10099, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
-    NAME_FUNC_OFFSET(10114, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
-    NAME_FUNC_OFFSET(10130, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
-    NAME_FUNC_OFFSET(10145, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
-    NAME_FUNC_OFFSET(10161, gl_dispatch_stub_619, gl_dispatch_stub_619, NULL, _gloffset_PixelTexGenSGIX),
-    NAME_FUNC_OFFSET(10179, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
-    NAME_FUNC_OFFSET(10202, glFlushVertexArrayRangeNV, glFlushVertexArrayRangeNV, NULL, _gloffset_FlushVertexArrayRangeNV),
-    NAME_FUNC_OFFSET(10228, glVertexArrayRangeNV, glVertexArrayRangeNV, NULL, _gloffset_VertexArrayRangeNV),
-    NAME_FUNC_OFFSET(10249, glCombinerInputNV, glCombinerInputNV, NULL, _gloffset_CombinerInputNV),
-    NAME_FUNC_OFFSET(10267, glCombinerOutputNV, glCombinerOutputNV, NULL, _gloffset_CombinerOutputNV),
-    NAME_FUNC_OFFSET(10286, glCombinerParameterfNV, glCombinerParameterfNV, NULL, _gloffset_CombinerParameterfNV),
-    NAME_FUNC_OFFSET(10309, glCombinerParameterfvNV, glCombinerParameterfvNV, NULL, _gloffset_CombinerParameterfvNV),
-    NAME_FUNC_OFFSET(10333, glCombinerParameteriNV, glCombinerParameteriNV, NULL, _gloffset_CombinerParameteriNV),
-    NAME_FUNC_OFFSET(10356, glCombinerParameterivNV, glCombinerParameterivNV, NULL, _gloffset_CombinerParameterivNV),
-    NAME_FUNC_OFFSET(10380, glFinalCombinerInputNV, glFinalCombinerInputNV, NULL, _gloffset_FinalCombinerInputNV),
-    NAME_FUNC_OFFSET(10403, glGetCombinerInputParameterfvNV, glGetCombinerInputParameterfvNV, NULL, _gloffset_GetCombinerInputParameterfvNV),
-    NAME_FUNC_OFFSET(10435, glGetCombinerInputParameterivNV, glGetCombinerInputParameterivNV, NULL, _gloffset_GetCombinerInputParameterivNV),
-    NAME_FUNC_OFFSET(10467, glGetCombinerOutputParameterfvNV, glGetCombinerOutputParameterfvNV, NULL, _gloffset_GetCombinerOutputParameterfvNV),
-    NAME_FUNC_OFFSET(10500, glGetCombinerOutputParameterivNV, glGetCombinerOutputParameterivNV, NULL, _gloffset_GetCombinerOutputParameterivNV),
-    NAME_FUNC_OFFSET(10533, glGetFinalCombinerInputParameterfvNV, glGetFinalCombinerInputParameterfvNV, NULL, _gloffset_GetFinalCombinerInputParameterfvNV),
-    NAME_FUNC_OFFSET(10570, glGetFinalCombinerInputParameterivNV, glGetFinalCombinerInputParameterivNV, NULL, _gloffset_GetFinalCombinerInputParameterivNV),
-    NAME_FUNC_OFFSET(10607, glResizeBuffersMESA, glResizeBuffersMESA, NULL, _gloffset_ResizeBuffersMESA),
-    NAME_FUNC_OFFSET(10627, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
-    NAME_FUNC_OFFSET(10645, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
-    NAME_FUNC_OFFSET(10664, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
-    NAME_FUNC_OFFSET(10682, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
-    NAME_FUNC_OFFSET(10701, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
-    NAME_FUNC_OFFSET(10719, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
-    NAME_FUNC_OFFSET(10738, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
-    NAME_FUNC_OFFSET(10756, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
-    NAME_FUNC_OFFSET(10775, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
-    NAME_FUNC_OFFSET(10793, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
-    NAME_FUNC_OFFSET(10812, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
-    NAME_FUNC_OFFSET(10830, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
-    NAME_FUNC_OFFSET(10849, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
-    NAME_FUNC_OFFSET(10867, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
-    NAME_FUNC_OFFSET(10886, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
-    NAME_FUNC_OFFSET(10904, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
-    NAME_FUNC_OFFSET(10923, glWindowPos4dMESA, glWindowPos4dMESA, NULL, _gloffset_WindowPos4dMESA),
-    NAME_FUNC_OFFSET(10941, glWindowPos4dvMESA, glWindowPos4dvMESA, NULL, _gloffset_WindowPos4dvMESA),
-    NAME_FUNC_OFFSET(10960, glWindowPos4fMESA, glWindowPos4fMESA, NULL, _gloffset_WindowPos4fMESA),
-    NAME_FUNC_OFFSET(10978, glWindowPos4fvMESA, glWindowPos4fvMESA, NULL, _gloffset_WindowPos4fvMESA),
-    NAME_FUNC_OFFSET(10997, glWindowPos4iMESA, glWindowPos4iMESA, NULL, _gloffset_WindowPos4iMESA),
-    NAME_FUNC_OFFSET(11015, glWindowPos4ivMESA, glWindowPos4ivMESA, NULL, _gloffset_WindowPos4ivMESA),
-    NAME_FUNC_OFFSET(11034, glWindowPos4sMESA, glWindowPos4sMESA, NULL, _gloffset_WindowPos4sMESA),
-    NAME_FUNC_OFFSET(11052, glWindowPos4svMESA, glWindowPos4svMESA, NULL, _gloffset_WindowPos4svMESA),
-    NAME_FUNC_OFFSET(11071, gl_dispatch_stub_661, gl_dispatch_stub_661, NULL, _gloffset_MultiModeDrawArraysIBM),
-    NAME_FUNC_OFFSET(11096, gl_dispatch_stub_662, gl_dispatch_stub_662, NULL, _gloffset_MultiModeDrawElementsIBM),
-    NAME_FUNC_OFFSET(11123, gl_dispatch_stub_663, gl_dispatch_stub_663, NULL, _gloffset_DeleteFencesNV),
-    NAME_FUNC_OFFSET(11140, gl_dispatch_stub_664, gl_dispatch_stub_664, NULL, _gloffset_FinishFenceNV),
-    NAME_FUNC_OFFSET(11156, gl_dispatch_stub_665, gl_dispatch_stub_665, NULL, _gloffset_GenFencesNV),
-    NAME_FUNC_OFFSET(11170, gl_dispatch_stub_666, gl_dispatch_stub_666, NULL, _gloffset_GetFenceivNV),
-    NAME_FUNC_OFFSET(11185, gl_dispatch_stub_667, gl_dispatch_stub_667, NULL, _gloffset_IsFenceNV),
-    NAME_FUNC_OFFSET(11197, gl_dispatch_stub_668, gl_dispatch_stub_668, NULL, _gloffset_SetFenceNV),
-    NAME_FUNC_OFFSET(11210, gl_dispatch_stub_669, gl_dispatch_stub_669, NULL, _gloffset_TestFenceNV),
-    NAME_FUNC_OFFSET(11224, glAreProgramsResidentNV, glAreProgramsResidentNV, NULL, _gloffset_AreProgramsResidentNV),
-    NAME_FUNC_OFFSET(11248, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
-    NAME_FUNC_OFFSET(11264, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
-    NAME_FUNC_OFFSET(11283, glExecuteProgramNV, glExecuteProgramNV, NULL, _gloffset_ExecuteProgramNV),
-    NAME_FUNC_OFFSET(11302, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
-    NAME_FUNC_OFFSET(11318, glGetProgramParameterdvNV, glGetProgramParameterdvNV, NULL, _gloffset_GetProgramParameterdvNV),
-    NAME_FUNC_OFFSET(11344, glGetProgramParameterfvNV, glGetProgramParameterfvNV, NULL, _gloffset_GetProgramParameterfvNV),
-    NAME_FUNC_OFFSET(11370, glGetProgramStringNV, glGetProgramStringNV, NULL, _gloffset_GetProgramStringNV),
-    NAME_FUNC_OFFSET(11391, glGetProgramivNV, glGetProgramivNV, NULL, _gloffset_GetProgramivNV),
-    NAME_FUNC_OFFSET(11408, glGetTrackMatrixivNV, glGetTrackMatrixivNV, NULL, _gloffset_GetTrackMatrixivNV),
-    NAME_FUNC_OFFSET(11429, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
-    NAME_FUNC_OFFSET(11457, glGetVertexAttribdvNV, glGetVertexAttribdvNV, NULL, _gloffset_GetVertexAttribdvNV),
-    NAME_FUNC_OFFSET(11479, glGetVertexAttribfvNV, glGetVertexAttribfvNV, NULL, _gloffset_GetVertexAttribfvNV),
-    NAME_FUNC_OFFSET(11501, glGetVertexAttribivNV, glGetVertexAttribivNV, NULL, _gloffset_GetVertexAttribivNV),
-    NAME_FUNC_OFFSET(11523, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
-    NAME_FUNC_OFFSET(11537, glLoadProgramNV, glLoadProgramNV, NULL, _gloffset_LoadProgramNV),
-    NAME_FUNC_OFFSET(11553, glProgramParameters4dvNV, glProgramParameters4dvNV, NULL, _gloffset_ProgramParameters4dvNV),
-    NAME_FUNC_OFFSET(11578, glProgramParameters4fvNV, glProgramParameters4fvNV, NULL, _gloffset_ProgramParameters4fvNV),
-    NAME_FUNC_OFFSET(11603, glRequestResidentProgramsNV, glRequestResidentProgramsNV, NULL, _gloffset_RequestResidentProgramsNV),
-    NAME_FUNC_OFFSET(11631, glTrackMatrixNV, glTrackMatrixNV, NULL, _gloffset_TrackMatrixNV),
-    NAME_FUNC_OFFSET(11647, glVertexAttrib1dNV, glVertexAttrib1dNV, NULL, _gloffset_VertexAttrib1dNV),
-    NAME_FUNC_OFFSET(11666, glVertexAttrib1dvNV, glVertexAttrib1dvNV, NULL, _gloffset_VertexAttrib1dvNV),
-    NAME_FUNC_OFFSET(11686, glVertexAttrib1fNV, glVertexAttrib1fNV, NULL, _gloffset_VertexAttrib1fNV),
-    NAME_FUNC_OFFSET(11705, glVertexAttrib1fvNV, glVertexAttrib1fvNV, NULL, _gloffset_VertexAttrib1fvNV),
-    NAME_FUNC_OFFSET(11725, glVertexAttrib1sNV, glVertexAttrib1sNV, NULL, _gloffset_VertexAttrib1sNV),
-    NAME_FUNC_OFFSET(11744, glVertexAttrib1svNV, glVertexAttrib1svNV, NULL, _gloffset_VertexAttrib1svNV),
-    NAME_FUNC_OFFSET(11764, glVertexAttrib2dNV, glVertexAttrib2dNV, NULL, _gloffset_VertexAttrib2dNV),
-    NAME_FUNC_OFFSET(11783, glVertexAttrib2dvNV, glVertexAttrib2dvNV, NULL, _gloffset_VertexAttrib2dvNV),
-    NAME_FUNC_OFFSET(11803, glVertexAttrib2fNV, glVertexAttrib2fNV, NULL, _gloffset_VertexAttrib2fNV),
-    NAME_FUNC_OFFSET(11822, glVertexAttrib2fvNV, glVertexAttrib2fvNV, NULL, _gloffset_VertexAttrib2fvNV),
-    NAME_FUNC_OFFSET(11842, glVertexAttrib2sNV, glVertexAttrib2sNV, NULL, _gloffset_VertexAttrib2sNV),
-    NAME_FUNC_OFFSET(11861, glVertexAttrib2svNV, glVertexAttrib2svNV, NULL, _gloffset_VertexAttrib2svNV),
-    NAME_FUNC_OFFSET(11881, glVertexAttrib3dNV, glVertexAttrib3dNV, NULL, _gloffset_VertexAttrib3dNV),
-    NAME_FUNC_OFFSET(11900, glVertexAttrib3dvNV, glVertexAttrib3dvNV, NULL, _gloffset_VertexAttrib3dvNV),
-    NAME_FUNC_OFFSET(11920, glVertexAttrib3fNV, glVertexAttrib3fNV, NULL, _gloffset_VertexAttrib3fNV),
-    NAME_FUNC_OFFSET(11939, glVertexAttrib3fvNV, glVertexAttrib3fvNV, NULL, _gloffset_VertexAttrib3fvNV),
-    NAME_FUNC_OFFSET(11959, glVertexAttrib3sNV, glVertexAttrib3sNV, NULL, _gloffset_VertexAttrib3sNV),
-    NAME_FUNC_OFFSET(11978, glVertexAttrib3svNV, glVertexAttrib3svNV, NULL, _gloffset_VertexAttrib3svNV),
-    NAME_FUNC_OFFSET(11998, glVertexAttrib4dNV, glVertexAttrib4dNV, NULL, _gloffset_VertexAttrib4dNV),
-    NAME_FUNC_OFFSET(12017, glVertexAttrib4dvNV, glVertexAttrib4dvNV, NULL, _gloffset_VertexAttrib4dvNV),
-    NAME_FUNC_OFFSET(12037, glVertexAttrib4fNV, glVertexAttrib4fNV, NULL, _gloffset_VertexAttrib4fNV),
-    NAME_FUNC_OFFSET(12056, glVertexAttrib4fvNV, glVertexAttrib4fvNV, NULL, _gloffset_VertexAttrib4fvNV),
-    NAME_FUNC_OFFSET(12076, glVertexAttrib4sNV, glVertexAttrib4sNV, NULL, _gloffset_VertexAttrib4sNV),
-    NAME_FUNC_OFFSET(12095, glVertexAttrib4svNV, glVertexAttrib4svNV, NULL, _gloffset_VertexAttrib4svNV),
-    NAME_FUNC_OFFSET(12115, glVertexAttrib4ubNV, glVertexAttrib4ubNV, NULL, _gloffset_VertexAttrib4ubNV),
-    NAME_FUNC_OFFSET(12135, glVertexAttrib4ubvNV, glVertexAttrib4ubvNV, NULL, _gloffset_VertexAttrib4ubvNV),
-    NAME_FUNC_OFFSET(12156, glVertexAttribPointerNV, glVertexAttribPointerNV, NULL, _gloffset_VertexAttribPointerNV),
-    NAME_FUNC_OFFSET(12180, glVertexAttribs1dvNV, glVertexAttribs1dvNV, NULL, _gloffset_VertexAttribs1dvNV),
-    NAME_FUNC_OFFSET(12201, glVertexAttribs1fvNV, glVertexAttribs1fvNV, NULL, _gloffset_VertexAttribs1fvNV),
-    NAME_FUNC_OFFSET(12222, glVertexAttribs1svNV, glVertexAttribs1svNV, NULL, _gloffset_VertexAttribs1svNV),
-    NAME_FUNC_OFFSET(12243, glVertexAttribs2dvNV, glVertexAttribs2dvNV, NULL, _gloffset_VertexAttribs2dvNV),
-    NAME_FUNC_OFFSET(12264, glVertexAttribs2fvNV, glVertexAttribs2fvNV, NULL, _gloffset_VertexAttribs2fvNV),
-    NAME_FUNC_OFFSET(12285, glVertexAttribs2svNV, glVertexAttribs2svNV, NULL, _gloffset_VertexAttribs2svNV),
-    NAME_FUNC_OFFSET(12306, glVertexAttribs3dvNV, glVertexAttribs3dvNV, NULL, _gloffset_VertexAttribs3dvNV),
-    NAME_FUNC_OFFSET(12327, glVertexAttribs3fvNV, glVertexAttribs3fvNV, NULL, _gloffset_VertexAttribs3fvNV),
-    NAME_FUNC_OFFSET(12348, glVertexAttribs3svNV, glVertexAttribs3svNV, NULL, _gloffset_VertexAttribs3svNV),
-    NAME_FUNC_OFFSET(12369, glVertexAttribs4dvNV, glVertexAttribs4dvNV, NULL, _gloffset_VertexAttribs4dvNV),
-    NAME_FUNC_OFFSET(12390, glVertexAttribs4fvNV, glVertexAttribs4fvNV, NULL, _gloffset_VertexAttribs4fvNV),
-    NAME_FUNC_OFFSET(12411, glVertexAttribs4svNV, glVertexAttribs4svNV, NULL, _gloffset_VertexAttribs4svNV),
-    NAME_FUNC_OFFSET(12432, glVertexAttribs4ubvNV, glVertexAttribs4ubvNV, NULL, _gloffset_VertexAttribs4ubvNV),
-    NAME_FUNC_OFFSET(12454, glGetTexBumpParameterfvATI, glGetTexBumpParameterfvATI, NULL, _gloffset_GetTexBumpParameterfvATI),
-    NAME_FUNC_OFFSET(12481, glGetTexBumpParameterivATI, glGetTexBumpParameterivATI, NULL, _gloffset_GetTexBumpParameterivATI),
-    NAME_FUNC_OFFSET(12508, glTexBumpParameterfvATI, glTexBumpParameterfvATI, NULL, _gloffset_TexBumpParameterfvATI),
-    NAME_FUNC_OFFSET(12532, glTexBumpParameterivATI, glTexBumpParameterivATI, NULL, _gloffset_TexBumpParameterivATI),
-    NAME_FUNC_OFFSET(12556, glAlphaFragmentOp1ATI, glAlphaFragmentOp1ATI, NULL, _gloffset_AlphaFragmentOp1ATI),
-    NAME_FUNC_OFFSET(12578, glAlphaFragmentOp2ATI, glAlphaFragmentOp2ATI, NULL, _gloffset_AlphaFragmentOp2ATI),
-    NAME_FUNC_OFFSET(12600, glAlphaFragmentOp3ATI, glAlphaFragmentOp3ATI, NULL, _gloffset_AlphaFragmentOp3ATI),
-    NAME_FUNC_OFFSET(12622, glBeginFragmentShaderATI, glBeginFragmentShaderATI, NULL, _gloffset_BeginFragmentShaderATI),
-    NAME_FUNC_OFFSET(12647, glBindFragmentShaderATI, glBindFragmentShaderATI, NULL, _gloffset_BindFragmentShaderATI),
-    NAME_FUNC_OFFSET(12671, glColorFragmentOp1ATI, glColorFragmentOp1ATI, NULL, _gloffset_ColorFragmentOp1ATI),
-    NAME_FUNC_OFFSET(12693, glColorFragmentOp2ATI, glColorFragmentOp2ATI, NULL, _gloffset_ColorFragmentOp2ATI),
-    NAME_FUNC_OFFSET(12715, glColorFragmentOp3ATI, glColorFragmentOp3ATI, NULL, _gloffset_ColorFragmentOp3ATI),
-    NAME_FUNC_OFFSET(12737, glDeleteFragmentShaderATI, glDeleteFragmentShaderATI, NULL, _gloffset_DeleteFragmentShaderATI),
-    NAME_FUNC_OFFSET(12763, glEndFragmentShaderATI, glEndFragmentShaderATI, NULL, _gloffset_EndFragmentShaderATI),
-    NAME_FUNC_OFFSET(12786, glGenFragmentShadersATI, glGenFragmentShadersATI, NULL, _gloffset_GenFragmentShadersATI),
-    NAME_FUNC_OFFSET(12810, glPassTexCoordATI, glPassTexCoordATI, NULL, _gloffset_PassTexCoordATI),
-    NAME_FUNC_OFFSET(12828, glSampleMapATI, glSampleMapATI, NULL, _gloffset_SampleMapATI),
-    NAME_FUNC_OFFSET(12843, glSetFragmentShaderConstantATI, glSetFragmentShaderConstantATI, NULL, _gloffset_SetFragmentShaderConstantATI),
-    NAME_FUNC_OFFSET(12874, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
-    NAME_FUNC_OFFSET(12894, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
-    NAME_FUNC_OFFSET(12915, gl_dispatch_stub_750, gl_dispatch_stub_750, NULL, _gloffset_ActiveStencilFaceEXT),
-    NAME_FUNC_OFFSET(12938, gl_dispatch_stub_751, gl_dispatch_stub_751, NULL, _gloffset_BindVertexArrayAPPLE),
-    NAME_FUNC_OFFSET(12961, gl_dispatch_stub_752, gl_dispatch_stub_752, NULL, _gloffset_DeleteVertexArraysAPPLE),
-    NAME_FUNC_OFFSET(12987, gl_dispatch_stub_753, gl_dispatch_stub_753, NULL, _gloffset_GenVertexArraysAPPLE),
-    NAME_FUNC_OFFSET(13010, gl_dispatch_stub_754, gl_dispatch_stub_754, NULL, _gloffset_IsVertexArrayAPPLE),
-    NAME_FUNC_OFFSET(13031, glGetProgramNamedParameterdvNV, glGetProgramNamedParameterdvNV, NULL, _gloffset_GetProgramNamedParameterdvNV),
-    NAME_FUNC_OFFSET(13062, glGetProgramNamedParameterfvNV, glGetProgramNamedParameterfvNV, NULL, _gloffset_GetProgramNamedParameterfvNV),
-    NAME_FUNC_OFFSET(13093, glProgramNamedParameter4dNV, glProgramNamedParameter4dNV, NULL, _gloffset_ProgramNamedParameter4dNV),
-    NAME_FUNC_OFFSET(13121, glProgramNamedParameter4dvNV, glProgramNamedParameter4dvNV, NULL, _gloffset_ProgramNamedParameter4dvNV),
-    NAME_FUNC_OFFSET(13150, glProgramNamedParameter4fNV, glProgramNamedParameter4fNV, NULL, _gloffset_ProgramNamedParameter4fNV),
-    NAME_FUNC_OFFSET(13178, glProgramNamedParameter4fvNV, glProgramNamedParameter4fvNV, NULL, _gloffset_ProgramNamedParameter4fvNV),
-    NAME_FUNC_OFFSET(13207, gl_dispatch_stub_761, gl_dispatch_stub_761, NULL, _gloffset_DepthBoundsEXT),
-    NAME_FUNC_OFFSET(13224, gl_dispatch_stub_762, gl_dispatch_stub_762, NULL, _gloffset_BlendEquationSeparateEXT),
-    NAME_FUNC_OFFSET(13251, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
-    NAME_FUNC_OFFSET(13272, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
-    NAME_FUNC_OFFSET(13294, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
-    NAME_FUNC_OFFSET(13322, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
-    NAME_FUNC_OFFSET(13346, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
-    NAME_FUNC_OFFSET(13371, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
-    NAME_FUNC_OFFSET(13400, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
-    NAME_FUNC_OFFSET(13426, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
-    NAME_FUNC_OFFSET(13452, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
-    NAME_FUNC_OFFSET(13478, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
-    NAME_FUNC_OFFSET(13499, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
-    NAME_FUNC_OFFSET(13521, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
-    NAME_FUNC_OFFSET(13541, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
-    NAME_FUNC_OFFSET(13582, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
-    NAME_FUNC_OFFSET(13614, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
-    NAME_FUNC_OFFSET(13633, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
-    NAME_FUNC_OFFSET(13653, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
-    NAME_FUNC_OFFSET(13678, gl_dispatch_stub_780, gl_dispatch_stub_780, NULL, _gloffset_BlitFramebufferEXT),
-    NAME_FUNC_OFFSET(13699, gl_dispatch_stub_781, gl_dispatch_stub_781, NULL, _gloffset_BufferParameteriAPPLE),
-    NAME_FUNC_OFFSET(13723, gl_dispatch_stub_782, gl_dispatch_stub_782, NULL, _gloffset_FlushMappedBufferRangeAPPLE),
-    NAME_FUNC_OFFSET(13753, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
-    NAME_FUNC_OFFSET(13782, glProvokingVertexEXT, glProvokingVertexEXT, NULL, _gloffset_ProvokingVertexEXT),
-    NAME_FUNC_OFFSET(13803, gl_dispatch_stub_785, gl_dispatch_stub_785, NULL, _gloffset_GetTexParameterPointervAPPLE),
-    NAME_FUNC_OFFSET(13834, gl_dispatch_stub_786, gl_dispatch_stub_786, NULL, _gloffset_TextureRangeAPPLE),
-    NAME_FUNC_OFFSET(13854, gl_dispatch_stub_787, gl_dispatch_stub_787, NULL, _gloffset_StencilFuncSeparateATI),
-    NAME_FUNC_OFFSET(13879, gl_dispatch_stub_788, gl_dispatch_stub_788, NULL, _gloffset_ProgramEnvParameters4fvEXT),
-    NAME_FUNC_OFFSET(13908, gl_dispatch_stub_789, gl_dispatch_stub_789, NULL, _gloffset_ProgramLocalParameters4fvEXT),
-    NAME_FUNC_OFFSET(13939, gl_dispatch_stub_790, gl_dispatch_stub_790, NULL, _gloffset_GetQueryObjecti64vEXT),
-    NAME_FUNC_OFFSET(13963, gl_dispatch_stub_791, gl_dispatch_stub_791, NULL, _gloffset_GetQueryObjectui64vEXT),
-    NAME_FUNC_OFFSET(13988, glArrayElement, glArrayElement, NULL, _gloffset_ArrayElement),
-    NAME_FUNC_OFFSET(14006, glBindTexture, glBindTexture, NULL, _gloffset_BindTexture),
-    NAME_FUNC_OFFSET(14023, glDrawArrays, glDrawArrays, NULL, _gloffset_DrawArrays),
-    NAME_FUNC_OFFSET(14039, glAreTexturesResident, glAreTexturesResidentEXT, glAreTexturesResidentEXT, _gloffset_AreTexturesResident),
-    NAME_FUNC_OFFSET(14064, glCopyTexImage1D, glCopyTexImage1D, NULL, _gloffset_CopyTexImage1D),
-    NAME_FUNC_OFFSET(14084, glCopyTexImage2D, glCopyTexImage2D, NULL, _gloffset_CopyTexImage2D),
-    NAME_FUNC_OFFSET(14104, glCopyTexSubImage1D, glCopyTexSubImage1D, NULL, _gloffset_CopyTexSubImage1D),
-    NAME_FUNC_OFFSET(14127, glCopyTexSubImage2D, glCopyTexSubImage2D, NULL, _gloffset_CopyTexSubImage2D),
-    NAME_FUNC_OFFSET(14150, glDeleteTextures, glDeleteTexturesEXT, glDeleteTexturesEXT, _gloffset_DeleteTextures),
-    NAME_FUNC_OFFSET(14170, glGenTextures, glGenTexturesEXT, glGenTexturesEXT, _gloffset_GenTextures),
-    NAME_FUNC_OFFSET(14187, glGetPointerv, glGetPointerv, NULL, _gloffset_GetPointerv),
-    NAME_FUNC_OFFSET(14204, glIsTexture, glIsTextureEXT, glIsTextureEXT, _gloffset_IsTexture),
-    NAME_FUNC_OFFSET(14219, glPrioritizeTextures, glPrioritizeTextures, NULL, _gloffset_PrioritizeTextures),
-    NAME_FUNC_OFFSET(14243, glTexSubImage1D, glTexSubImage1D, NULL, _gloffset_TexSubImage1D),
-    NAME_FUNC_OFFSET(14262, glTexSubImage2D, glTexSubImage2D, NULL, _gloffset_TexSubImage2D),
-    NAME_FUNC_OFFSET(14281, glBlendColor, glBlendColor, NULL, _gloffset_BlendColor),
-    NAME_FUNC_OFFSET(14297, glBlendEquation, glBlendEquation, NULL, _gloffset_BlendEquation),
-    NAME_FUNC_OFFSET(14316, glDrawRangeElements, glDrawRangeElements, NULL, _gloffset_DrawRangeElements),
-    NAME_FUNC_OFFSET(14339, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
-    NAME_FUNC_OFFSET(14355, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
-    NAME_FUNC_OFFSET(14371, glColorTableParameterfv, glColorTableParameterfv, NULL, _gloffset_ColorTableParameterfv),
-    NAME_FUNC_OFFSET(14398, glColorTableParameteriv, glColorTableParameteriv, NULL, _gloffset_ColorTableParameteriv),
-    NAME_FUNC_OFFSET(14425, glCopyColorTable, glCopyColorTable, NULL, _gloffset_CopyColorTable),
-    NAME_FUNC_OFFSET(14445, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
-    NAME_FUNC_OFFSET(14464, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
-    NAME_FUNC_OFFSET(14483, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
-    NAME_FUNC_OFFSET(14513, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
-    NAME_FUNC_OFFSET(14543, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
-    NAME_FUNC_OFFSET(14573, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
-    NAME_FUNC_OFFSET(14603, glColorSubTable, glColorSubTable, NULL, _gloffset_ColorSubTable),
-    NAME_FUNC_OFFSET(14622, glCopyColorSubTable, glCopyColorSubTable, NULL, _gloffset_CopyColorSubTable),
-    NAME_FUNC_OFFSET(14645, glConvolutionFilter1D, glConvolutionFilter1D, NULL, _gloffset_ConvolutionFilter1D),
-    NAME_FUNC_OFFSET(14670, glConvolutionFilter2D, glConvolutionFilter2D, NULL, _gloffset_ConvolutionFilter2D),
-    NAME_FUNC_OFFSET(14695, glConvolutionParameterf, glConvolutionParameterf, NULL, _gloffset_ConvolutionParameterf),
-    NAME_FUNC_OFFSET(14722, glConvolutionParameterfv, glConvolutionParameterfv, NULL, _gloffset_ConvolutionParameterfv),
-    NAME_FUNC_OFFSET(14750, glConvolutionParameteri, glConvolutionParameteri, NULL, _gloffset_ConvolutionParameteri),
-    NAME_FUNC_OFFSET(14777, glConvolutionParameteriv, glConvolutionParameteriv, NULL, _gloffset_ConvolutionParameteriv),
-    NAME_FUNC_OFFSET(14805, glCopyConvolutionFilter1D, glCopyConvolutionFilter1D, NULL, _gloffset_CopyConvolutionFilter1D),
-    NAME_FUNC_OFFSET(14834, glCopyConvolutionFilter2D, glCopyConvolutionFilter2D, NULL, _gloffset_CopyConvolutionFilter2D),
-    NAME_FUNC_OFFSET(14863, glGetConvolutionFilter, gl_dispatch_stub_356, gl_dispatch_stub_356, _gloffset_GetConvolutionFilter),
-    NAME_FUNC_OFFSET(14889, glGetConvolutionParameterfv, gl_dispatch_stub_357, gl_dispatch_stub_357, _gloffset_GetConvolutionParameterfv),
-    NAME_FUNC_OFFSET(14920, glGetConvolutionParameteriv, gl_dispatch_stub_358, gl_dispatch_stub_358, _gloffset_GetConvolutionParameteriv),
-    NAME_FUNC_OFFSET(14951, glGetSeparableFilter, gl_dispatch_stub_359, gl_dispatch_stub_359, _gloffset_GetSeparableFilter),
-    NAME_FUNC_OFFSET(14975, glSeparableFilter2D, glSeparableFilter2D, NULL, _gloffset_SeparableFilter2D),
-    NAME_FUNC_OFFSET(14998, glGetHistogram, gl_dispatch_stub_361, gl_dispatch_stub_361, _gloffset_GetHistogram),
-    NAME_FUNC_OFFSET(15016, glGetHistogramParameterfv, gl_dispatch_stub_362, gl_dispatch_stub_362, _gloffset_GetHistogramParameterfv),
-    NAME_FUNC_OFFSET(15045, glGetHistogramParameteriv, gl_dispatch_stub_363, gl_dispatch_stub_363, _gloffset_GetHistogramParameteriv),
-    NAME_FUNC_OFFSET(15074, glGetMinmax, gl_dispatch_stub_364, gl_dispatch_stub_364, _gloffset_GetMinmax),
-    NAME_FUNC_OFFSET(15089, glGetMinmaxParameterfv, gl_dispatch_stub_365, gl_dispatch_stub_365, _gloffset_GetMinmaxParameterfv),
-    NAME_FUNC_OFFSET(15115, glGetMinmaxParameteriv, gl_dispatch_stub_366, gl_dispatch_stub_366, _gloffset_GetMinmaxParameteriv),
-    NAME_FUNC_OFFSET(15141, glHistogram, glHistogram, NULL, _gloffset_Histogram),
-    NAME_FUNC_OFFSET(15156, glMinmax, glMinmax, NULL, _gloffset_Minmax),
-    NAME_FUNC_OFFSET(15168, glResetHistogram, glResetHistogram, NULL, _gloffset_ResetHistogram),
-    NAME_FUNC_OFFSET(15188, glResetMinmax, glResetMinmax, NULL, _gloffset_ResetMinmax),
-    NAME_FUNC_OFFSET(15205, glTexImage3D, glTexImage3D, NULL, _gloffset_TexImage3D),
-    NAME_FUNC_OFFSET(15221, glTexSubImage3D, glTexSubImage3D, NULL, _gloffset_TexSubImage3D),
-    NAME_FUNC_OFFSET(15240, glCopyTexSubImage3D, glCopyTexSubImage3D, NULL, _gloffset_CopyTexSubImage3D),
-    NAME_FUNC_OFFSET(15263, glActiveTextureARB, glActiveTextureARB, NULL, _gloffset_ActiveTextureARB),
-    NAME_FUNC_OFFSET(15279, glClientActiveTextureARB, glClientActiveTextureARB, NULL, _gloffset_ClientActiveTextureARB),
-    NAME_FUNC_OFFSET(15301, glMultiTexCoord1dARB, glMultiTexCoord1dARB, NULL, _gloffset_MultiTexCoord1dARB),
-    NAME_FUNC_OFFSET(15319, glMultiTexCoord1dvARB, glMultiTexCoord1dvARB, NULL, _gloffset_MultiTexCoord1dvARB),
-    NAME_FUNC_OFFSET(15338, glMultiTexCoord1fARB, glMultiTexCoord1fARB, NULL, _gloffset_MultiTexCoord1fARB),
-    NAME_FUNC_OFFSET(15356, glMultiTexCoord1fvARB, glMultiTexCoord1fvARB, NULL, _gloffset_MultiTexCoord1fvARB),
-    NAME_FUNC_OFFSET(15375, glMultiTexCoord1iARB, glMultiTexCoord1iARB, NULL, _gloffset_MultiTexCoord1iARB),
-    NAME_FUNC_OFFSET(15393, glMultiTexCoord1ivARB, glMultiTexCoord1ivARB, NULL, _gloffset_MultiTexCoord1ivARB),
-    NAME_FUNC_OFFSET(15412, glMultiTexCoord1sARB, glMultiTexCoord1sARB, NULL, _gloffset_MultiTexCoord1sARB),
-    NAME_FUNC_OFFSET(15430, glMultiTexCoord1svARB, glMultiTexCoord1svARB, NULL, _gloffset_MultiTexCoord1svARB),
-    NAME_FUNC_OFFSET(15449, glMultiTexCoord2dARB, glMultiTexCoord2dARB, NULL, _gloffset_MultiTexCoord2dARB),
-    NAME_FUNC_OFFSET(15467, glMultiTexCoord2dvARB, glMultiTexCoord2dvARB, NULL, _gloffset_MultiTexCoord2dvARB),
-    NAME_FUNC_OFFSET(15486, glMultiTexCoord2fARB, glMultiTexCoord2fARB, NULL, _gloffset_MultiTexCoord2fARB),
-    NAME_FUNC_OFFSET(15504, glMultiTexCoord2fvARB, glMultiTexCoord2fvARB, NULL, _gloffset_MultiTexCoord2fvARB),
-    NAME_FUNC_OFFSET(15523, glMultiTexCoord2iARB, glMultiTexCoord2iARB, NULL, _gloffset_MultiTexCoord2iARB),
-    NAME_FUNC_OFFSET(15541, glMultiTexCoord2ivARB, glMultiTexCoord2ivARB, NULL, _gloffset_MultiTexCoord2ivARB),
-    NAME_FUNC_OFFSET(15560, glMultiTexCoord2sARB, glMultiTexCoord2sARB, NULL, _gloffset_MultiTexCoord2sARB),
-    NAME_FUNC_OFFSET(15578, glMultiTexCoord2svARB, glMultiTexCoord2svARB, NULL, _gloffset_MultiTexCoord2svARB),
-    NAME_FUNC_OFFSET(15597, glMultiTexCoord3dARB, glMultiTexCoord3dARB, NULL, _gloffset_MultiTexCoord3dARB),
-    NAME_FUNC_OFFSET(15615, glMultiTexCoord3dvARB, glMultiTexCoord3dvARB, NULL, _gloffset_MultiTexCoord3dvARB),
-    NAME_FUNC_OFFSET(15634, glMultiTexCoord3fARB, glMultiTexCoord3fARB, NULL, _gloffset_MultiTexCoord3fARB),
-    NAME_FUNC_OFFSET(15652, glMultiTexCoord3fvARB, glMultiTexCoord3fvARB, NULL, _gloffset_MultiTexCoord3fvARB),
-    NAME_FUNC_OFFSET(15671, glMultiTexCoord3iARB, glMultiTexCoord3iARB, NULL, _gloffset_MultiTexCoord3iARB),
-    NAME_FUNC_OFFSET(15689, glMultiTexCoord3ivARB, glMultiTexCoord3ivARB, NULL, _gloffset_MultiTexCoord3ivARB),
-    NAME_FUNC_OFFSET(15708, glMultiTexCoord3sARB, glMultiTexCoord3sARB, NULL, _gloffset_MultiTexCoord3sARB),
-    NAME_FUNC_OFFSET(15726, glMultiTexCoord3svARB, glMultiTexCoord3svARB, NULL, _gloffset_MultiTexCoord3svARB),
-    NAME_FUNC_OFFSET(15745, glMultiTexCoord4dARB, glMultiTexCoord4dARB, NULL, _gloffset_MultiTexCoord4dARB),
-    NAME_FUNC_OFFSET(15763, glMultiTexCoord4dvARB, glMultiTexCoord4dvARB, NULL, _gloffset_MultiTexCoord4dvARB),
-    NAME_FUNC_OFFSET(15782, glMultiTexCoord4fARB, glMultiTexCoord4fARB, NULL, _gloffset_MultiTexCoord4fARB),
-    NAME_FUNC_OFFSET(15800, glMultiTexCoord4fvARB, glMultiTexCoord4fvARB, NULL, _gloffset_MultiTexCoord4fvARB),
-    NAME_FUNC_OFFSET(15819, glMultiTexCoord4iARB, glMultiTexCoord4iARB, NULL, _gloffset_MultiTexCoord4iARB),
-    NAME_FUNC_OFFSET(15837, glMultiTexCoord4ivARB, glMultiTexCoord4ivARB, NULL, _gloffset_MultiTexCoord4ivARB),
-    NAME_FUNC_OFFSET(15856, glMultiTexCoord4sARB, glMultiTexCoord4sARB, NULL, _gloffset_MultiTexCoord4sARB),
-    NAME_FUNC_OFFSET(15874, glMultiTexCoord4svARB, glMultiTexCoord4svARB, NULL, _gloffset_MultiTexCoord4svARB),
-    NAME_FUNC_OFFSET(15893, glStencilOpSeparate, glStencilOpSeparate, NULL, _gloffset_StencilOpSeparate),
-    NAME_FUNC_OFFSET(15916, glLoadTransposeMatrixdARB, glLoadTransposeMatrixdARB, NULL, _gloffset_LoadTransposeMatrixdARB),
-    NAME_FUNC_OFFSET(15939, glLoadTransposeMatrixfARB, glLoadTransposeMatrixfARB, NULL, _gloffset_LoadTransposeMatrixfARB),
-    NAME_FUNC_OFFSET(15962, glMultTransposeMatrixdARB, glMultTransposeMatrixdARB, NULL, _gloffset_MultTransposeMatrixdARB),
-    NAME_FUNC_OFFSET(15985, glMultTransposeMatrixfARB, glMultTransposeMatrixfARB, NULL, _gloffset_MultTransposeMatrixfARB),
-    NAME_FUNC_OFFSET(16008, glSampleCoverageARB, glSampleCoverageARB, NULL, _gloffset_SampleCoverageARB),
-    NAME_FUNC_OFFSET(16025, glCompressedTexImage1DARB, glCompressedTexImage1DARB, NULL, _gloffset_CompressedTexImage1DARB),
-    NAME_FUNC_OFFSET(16048, glCompressedTexImage2DARB, glCompressedTexImage2DARB, NULL, _gloffset_CompressedTexImage2DARB),
-    NAME_FUNC_OFFSET(16071, glCompressedTexImage3DARB, glCompressedTexImage3DARB, NULL, _gloffset_CompressedTexImage3DARB),
-    NAME_FUNC_OFFSET(16094, glCompressedTexSubImage1DARB, glCompressedTexSubImage1DARB, NULL, _gloffset_CompressedTexSubImage1DARB),
-    NAME_FUNC_OFFSET(16120, glCompressedTexSubImage2DARB, glCompressedTexSubImage2DARB, NULL, _gloffset_CompressedTexSubImage2DARB),
-    NAME_FUNC_OFFSET(16146, glCompressedTexSubImage3DARB, glCompressedTexSubImage3DARB, NULL, _gloffset_CompressedTexSubImage3DARB),
-    NAME_FUNC_OFFSET(16172, glGetCompressedTexImageARB, glGetCompressedTexImageARB, NULL, _gloffset_GetCompressedTexImageARB),
-    NAME_FUNC_OFFSET(16196, glDisableVertexAttribArrayARB, glDisableVertexAttribArrayARB, NULL, _gloffset_DisableVertexAttribArrayARB),
-    NAME_FUNC_OFFSET(16223, glEnableVertexAttribArrayARB, glEnableVertexAttribArrayARB, NULL, _gloffset_EnableVertexAttribArrayARB),
-    NAME_FUNC_OFFSET(16249, glGetVertexAttribdvARB, glGetVertexAttribdvARB, NULL, _gloffset_GetVertexAttribdvARB),
-    NAME_FUNC_OFFSET(16269, glGetVertexAttribfvARB, glGetVertexAttribfvARB, NULL, _gloffset_GetVertexAttribfvARB),
-    NAME_FUNC_OFFSET(16289, glGetVertexAttribivARB, glGetVertexAttribivARB, NULL, _gloffset_GetVertexAttribivARB),
-    NAME_FUNC_OFFSET(16309, glProgramEnvParameter4dARB, glProgramEnvParameter4dARB, NULL, _gloffset_ProgramEnvParameter4dARB),
-    NAME_FUNC_OFFSET(16332, glProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB, NULL, _gloffset_ProgramEnvParameter4dvARB),
-    NAME_FUNC_OFFSET(16356, glProgramEnvParameter4fARB, glProgramEnvParameter4fARB, NULL, _gloffset_ProgramEnvParameter4fARB),
-    NAME_FUNC_OFFSET(16379, glProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB, NULL, _gloffset_ProgramEnvParameter4fvARB),
-    NAME_FUNC_OFFSET(16403, glVertexAttrib1dARB, glVertexAttrib1dARB, NULL, _gloffset_VertexAttrib1dARB),
-    NAME_FUNC_OFFSET(16420, glVertexAttrib1dvARB, glVertexAttrib1dvARB, NULL, _gloffset_VertexAttrib1dvARB),
-    NAME_FUNC_OFFSET(16438, glVertexAttrib1fARB, glVertexAttrib1fARB, NULL, _gloffset_VertexAttrib1fARB),
-    NAME_FUNC_OFFSET(16455, glVertexAttrib1fvARB, glVertexAttrib1fvARB, NULL, _gloffset_VertexAttrib1fvARB),
-    NAME_FUNC_OFFSET(16473, glVertexAttrib1sARB, glVertexAttrib1sARB, NULL, _gloffset_VertexAttrib1sARB),
-    NAME_FUNC_OFFSET(16490, glVertexAttrib1svARB, glVertexAttrib1svARB, NULL, _gloffset_VertexAttrib1svARB),
-    NAME_FUNC_OFFSET(16508, glVertexAttrib2dARB, glVertexAttrib2dARB, NULL, _gloffset_VertexAttrib2dARB),
-    NAME_FUNC_OFFSET(16525, glVertexAttrib2dvARB, glVertexAttrib2dvARB, NULL, _gloffset_VertexAttrib2dvARB),
-    NAME_FUNC_OFFSET(16543, glVertexAttrib2fARB, glVertexAttrib2fARB, NULL, _gloffset_VertexAttrib2fARB),
-    NAME_FUNC_OFFSET(16560, glVertexAttrib2fvARB, glVertexAttrib2fvARB, NULL, _gloffset_VertexAttrib2fvARB),
-    NAME_FUNC_OFFSET(16578, glVertexAttrib2sARB, glVertexAttrib2sARB, NULL, _gloffset_VertexAttrib2sARB),
-    NAME_FUNC_OFFSET(16595, glVertexAttrib2svARB, glVertexAttrib2svARB, NULL, _gloffset_VertexAttrib2svARB),
-    NAME_FUNC_OFFSET(16613, glVertexAttrib3dARB, glVertexAttrib3dARB, NULL, _gloffset_VertexAttrib3dARB),
-    NAME_FUNC_OFFSET(16630, glVertexAttrib3dvARB, glVertexAttrib3dvARB, NULL, _gloffset_VertexAttrib3dvARB),
-    NAME_FUNC_OFFSET(16648, glVertexAttrib3fARB, glVertexAttrib3fARB, NULL, _gloffset_VertexAttrib3fARB),
-    NAME_FUNC_OFFSET(16665, glVertexAttrib3fvARB, glVertexAttrib3fvARB, NULL, _gloffset_VertexAttrib3fvARB),
-    NAME_FUNC_OFFSET(16683, glVertexAttrib3sARB, glVertexAttrib3sARB, NULL, _gloffset_VertexAttrib3sARB),
-    NAME_FUNC_OFFSET(16700, glVertexAttrib3svARB, glVertexAttrib3svARB, NULL, _gloffset_VertexAttrib3svARB),
-    NAME_FUNC_OFFSET(16718, glVertexAttrib4NbvARB, glVertexAttrib4NbvARB, NULL, _gloffset_VertexAttrib4NbvARB),
-    NAME_FUNC_OFFSET(16737, glVertexAttrib4NivARB, glVertexAttrib4NivARB, NULL, _gloffset_VertexAttrib4NivARB),
-    NAME_FUNC_OFFSET(16756, glVertexAttrib4NsvARB, glVertexAttrib4NsvARB, NULL, _gloffset_VertexAttrib4NsvARB),
-    NAME_FUNC_OFFSET(16775, glVertexAttrib4NubARB, glVertexAttrib4NubARB, NULL, _gloffset_VertexAttrib4NubARB),
-    NAME_FUNC_OFFSET(16794, glVertexAttrib4NubvARB, glVertexAttrib4NubvARB, NULL, _gloffset_VertexAttrib4NubvARB),
-    NAME_FUNC_OFFSET(16814, glVertexAttrib4NuivARB, glVertexAttrib4NuivARB, NULL, _gloffset_VertexAttrib4NuivARB),
-    NAME_FUNC_OFFSET(16834, glVertexAttrib4NusvARB, glVertexAttrib4NusvARB, NULL, _gloffset_VertexAttrib4NusvARB),
-    NAME_FUNC_OFFSET(16854, glVertexAttrib4bvARB, glVertexAttrib4bvARB, NULL, _gloffset_VertexAttrib4bvARB),
-    NAME_FUNC_OFFSET(16872, glVertexAttrib4dARB, glVertexAttrib4dARB, NULL, _gloffset_VertexAttrib4dARB),
-    NAME_FUNC_OFFSET(16889, glVertexAttrib4dvARB, glVertexAttrib4dvARB, NULL, _gloffset_VertexAttrib4dvARB),
-    NAME_FUNC_OFFSET(16907, glVertexAttrib4fARB, glVertexAttrib4fARB, NULL, _gloffset_VertexAttrib4fARB),
-    NAME_FUNC_OFFSET(16924, glVertexAttrib4fvARB, glVertexAttrib4fvARB, NULL, _gloffset_VertexAttrib4fvARB),
-    NAME_FUNC_OFFSET(16942, glVertexAttrib4ivARB, glVertexAttrib4ivARB, NULL, _gloffset_VertexAttrib4ivARB),
-    NAME_FUNC_OFFSET(16960, glVertexAttrib4sARB, glVertexAttrib4sARB, NULL, _gloffset_VertexAttrib4sARB),
-    NAME_FUNC_OFFSET(16977, glVertexAttrib4svARB, glVertexAttrib4svARB, NULL, _gloffset_VertexAttrib4svARB),
-    NAME_FUNC_OFFSET(16995, glVertexAttrib4ubvARB, glVertexAttrib4ubvARB, NULL, _gloffset_VertexAttrib4ubvARB),
-    NAME_FUNC_OFFSET(17014, glVertexAttrib4uivARB, glVertexAttrib4uivARB, NULL, _gloffset_VertexAttrib4uivARB),
-    NAME_FUNC_OFFSET(17033, glVertexAttrib4usvARB, glVertexAttrib4usvARB, NULL, _gloffset_VertexAttrib4usvARB),
-    NAME_FUNC_OFFSET(17052, glVertexAttribPointerARB, glVertexAttribPointerARB, NULL, _gloffset_VertexAttribPointerARB),
-    NAME_FUNC_OFFSET(17074, glBindBufferARB, glBindBufferARB, NULL, _gloffset_BindBufferARB),
-    NAME_FUNC_OFFSET(17087, glBufferDataARB, glBufferDataARB, NULL, _gloffset_BufferDataARB),
-    NAME_FUNC_OFFSET(17100, glBufferSubDataARB, glBufferSubDataARB, NULL, _gloffset_BufferSubDataARB),
-    NAME_FUNC_OFFSET(17116, glDeleteBuffersARB, glDeleteBuffersARB, NULL, _gloffset_DeleteBuffersARB),
-    NAME_FUNC_OFFSET(17132, glGenBuffersARB, glGenBuffersARB, NULL, _gloffset_GenBuffersARB),
-    NAME_FUNC_OFFSET(17145, glGetBufferParameterivARB, glGetBufferParameterivARB, NULL, _gloffset_GetBufferParameterivARB),
-    NAME_FUNC_OFFSET(17168, glGetBufferPointervARB, glGetBufferPointervARB, NULL, _gloffset_GetBufferPointervARB),
-    NAME_FUNC_OFFSET(17188, glGetBufferSubDataARB, glGetBufferSubDataARB, NULL, _gloffset_GetBufferSubDataARB),
-    NAME_FUNC_OFFSET(17207, glIsBufferARB, glIsBufferARB, NULL, _gloffset_IsBufferARB),
-    NAME_FUNC_OFFSET(17218, glMapBufferARB, glMapBufferARB, NULL, _gloffset_MapBufferARB),
-    NAME_FUNC_OFFSET(17230, glUnmapBufferARB, glUnmapBufferARB, NULL, _gloffset_UnmapBufferARB),
-    NAME_FUNC_OFFSET(17244, glBeginQueryARB, glBeginQueryARB, NULL, _gloffset_BeginQueryARB),
-    NAME_FUNC_OFFSET(17257, glDeleteQueriesARB, glDeleteQueriesARB, NULL, _gloffset_DeleteQueriesARB),
-    NAME_FUNC_OFFSET(17273, glEndQueryARB, glEndQueryARB, NULL, _gloffset_EndQueryARB),
-    NAME_FUNC_OFFSET(17284, glGenQueriesARB, glGenQueriesARB, NULL, _gloffset_GenQueriesARB),
-    NAME_FUNC_OFFSET(17297, glGetQueryObjectivARB, glGetQueryObjectivARB, NULL, _gloffset_GetQueryObjectivARB),
-    NAME_FUNC_OFFSET(17316, glGetQueryObjectuivARB, glGetQueryObjectuivARB, NULL, _gloffset_GetQueryObjectuivARB),
-    NAME_FUNC_OFFSET(17336, glGetQueryivARB, glGetQueryivARB, NULL, _gloffset_GetQueryivARB),
-    NAME_FUNC_OFFSET(17349, glIsQueryARB, glIsQueryARB, NULL, _gloffset_IsQueryARB),
-    NAME_FUNC_OFFSET(17359, glCompileShaderARB, glCompileShaderARB, NULL, _gloffset_CompileShaderARB),
-    NAME_FUNC_OFFSET(17375, glGetActiveUniformARB, glGetActiveUniformARB, NULL, _gloffset_GetActiveUniformARB),
-    NAME_FUNC_OFFSET(17394, glGetShaderSourceARB, glGetShaderSourceARB, NULL, _gloffset_GetShaderSourceARB),
-    NAME_FUNC_OFFSET(17412, glGetUniformLocationARB, glGetUniformLocationARB, NULL, _gloffset_GetUniformLocationARB),
-    NAME_FUNC_OFFSET(17433, glGetUniformfvARB, glGetUniformfvARB, NULL, _gloffset_GetUniformfvARB),
-    NAME_FUNC_OFFSET(17448, glGetUniformivARB, glGetUniformivARB, NULL, _gloffset_GetUniformivARB),
-    NAME_FUNC_OFFSET(17463, glLinkProgramARB, glLinkProgramARB, NULL, _gloffset_LinkProgramARB),
-    NAME_FUNC_OFFSET(17477, glShaderSourceARB, glShaderSourceARB, NULL, _gloffset_ShaderSourceARB),
-    NAME_FUNC_OFFSET(17492, glUniform1fARB, glUniform1fARB, NULL, _gloffset_Uniform1fARB),
-    NAME_FUNC_OFFSET(17504, glUniform1fvARB, glUniform1fvARB, NULL, _gloffset_Uniform1fvARB),
-    NAME_FUNC_OFFSET(17517, glUniform1iARB, glUniform1iARB, NULL, _gloffset_Uniform1iARB),
-    NAME_FUNC_OFFSET(17529, glUniform1ivARB, glUniform1ivARB, NULL, _gloffset_Uniform1ivARB),
-    NAME_FUNC_OFFSET(17542, glUniform2fARB, glUniform2fARB, NULL, _gloffset_Uniform2fARB),
-    NAME_FUNC_OFFSET(17554, glUniform2fvARB, glUniform2fvARB, NULL, _gloffset_Uniform2fvARB),
-    NAME_FUNC_OFFSET(17567, glUniform2iARB, glUniform2iARB, NULL, _gloffset_Uniform2iARB),
-    NAME_FUNC_OFFSET(17579, glUniform2ivARB, glUniform2ivARB, NULL, _gloffset_Uniform2ivARB),
-    NAME_FUNC_OFFSET(17592, glUniform3fARB, glUniform3fARB, NULL, _gloffset_Uniform3fARB),
-    NAME_FUNC_OFFSET(17604, glUniform3fvARB, glUniform3fvARB, NULL, _gloffset_Uniform3fvARB),
-    NAME_FUNC_OFFSET(17617, glUniform3iARB, glUniform3iARB, NULL, _gloffset_Uniform3iARB),
-    NAME_FUNC_OFFSET(17629, glUniform3ivARB, glUniform3ivARB, NULL, _gloffset_Uniform3ivARB),
-    NAME_FUNC_OFFSET(17642, glUniform4fARB, glUniform4fARB, NULL, _gloffset_Uniform4fARB),
-    NAME_FUNC_OFFSET(17654, glUniform4fvARB, glUniform4fvARB, NULL, _gloffset_Uniform4fvARB),
-    NAME_FUNC_OFFSET(17667, glUniform4iARB, glUniform4iARB, NULL, _gloffset_Uniform4iARB),
-    NAME_FUNC_OFFSET(17679, glUniform4ivARB, glUniform4ivARB, NULL, _gloffset_Uniform4ivARB),
-    NAME_FUNC_OFFSET(17692, glUniformMatrix2fvARB, glUniformMatrix2fvARB, NULL, _gloffset_UniformMatrix2fvARB),
-    NAME_FUNC_OFFSET(17711, glUniformMatrix3fvARB, glUniformMatrix3fvARB, NULL, _gloffset_UniformMatrix3fvARB),
-    NAME_FUNC_OFFSET(17730, glUniformMatrix4fvARB, glUniformMatrix4fvARB, NULL, _gloffset_UniformMatrix4fvARB),
-    NAME_FUNC_OFFSET(17749, glUseProgramObjectARB, glUseProgramObjectARB, NULL, _gloffset_UseProgramObjectARB),
-    NAME_FUNC_OFFSET(17762, glValidateProgramARB, glValidateProgramARB, NULL, _gloffset_ValidateProgramARB),
-    NAME_FUNC_OFFSET(17780, glBindAttribLocationARB, glBindAttribLocationARB, NULL, _gloffset_BindAttribLocationARB),
-    NAME_FUNC_OFFSET(17801, glGetActiveAttribARB, glGetActiveAttribARB, NULL, _gloffset_GetActiveAttribARB),
-    NAME_FUNC_OFFSET(17819, glGetAttribLocationARB, glGetAttribLocationARB, NULL, _gloffset_GetAttribLocationARB),
-    NAME_FUNC_OFFSET(17839, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
-    NAME_FUNC_OFFSET(17853, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
-    NAME_FUNC_OFFSET(17870, gl_dispatch_stub_581, gl_dispatch_stub_581, NULL, _gloffset_SampleMaskSGIS),
-    NAME_FUNC_OFFSET(17886, gl_dispatch_stub_582, gl_dispatch_stub_582, NULL, _gloffset_SamplePatternSGIS),
-    NAME_FUNC_OFFSET(17905, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
-    NAME_FUNC_OFFSET(17923, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
-    NAME_FUNC_OFFSET(17944, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
-    NAME_FUNC_OFFSET(17966, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
-    NAME_FUNC_OFFSET(17985, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
-    NAME_FUNC_OFFSET(18007, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
-    NAME_FUNC_OFFSET(18030, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
-    NAME_FUNC_OFFSET(18049, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
-    NAME_FUNC_OFFSET(18069, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
-    NAME_FUNC_OFFSET(18088, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
-    NAME_FUNC_OFFSET(18108, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
-    NAME_FUNC_OFFSET(18127, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
-    NAME_FUNC_OFFSET(18147, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
-    NAME_FUNC_OFFSET(18166, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
-    NAME_FUNC_OFFSET(18186, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
-    NAME_FUNC_OFFSET(18205, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
-    NAME_FUNC_OFFSET(18225, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
-    NAME_FUNC_OFFSET(18245, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
-    NAME_FUNC_OFFSET(18266, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
-    NAME_FUNC_OFFSET(18286, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
-    NAME_FUNC_OFFSET(18307, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
-    NAME_FUNC_OFFSET(18327, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
-    NAME_FUNC_OFFSET(18348, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
-    NAME_FUNC_OFFSET(18372, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
-    NAME_FUNC_OFFSET(18390, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
-    NAME_FUNC_OFFSET(18410, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
-    NAME_FUNC_OFFSET(18428, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
-    NAME_FUNC_OFFSET(18440, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
-    NAME_FUNC_OFFSET(18453, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
-    NAME_FUNC_OFFSET(18465, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
-    NAME_FUNC_OFFSET(18478, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
-    NAME_FUNC_OFFSET(18498, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
-    NAME_FUNC_OFFSET(18522, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
-    NAME_FUNC_OFFSET(18536, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
-    NAME_FUNC_OFFSET(18553, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
-    NAME_FUNC_OFFSET(18568, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
-    NAME_FUNC_OFFSET(18586, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
-    NAME_FUNC_OFFSET(18600, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
-    NAME_FUNC_OFFSET(18617, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
-    NAME_FUNC_OFFSET(18632, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
-    NAME_FUNC_OFFSET(18650, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
-    NAME_FUNC_OFFSET(18664, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
-    NAME_FUNC_OFFSET(18681, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
-    NAME_FUNC_OFFSET(18696, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
-    NAME_FUNC_OFFSET(18714, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
-    NAME_FUNC_OFFSET(18728, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
-    NAME_FUNC_OFFSET(18745, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
-    NAME_FUNC_OFFSET(18760, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
-    NAME_FUNC_OFFSET(18778, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
-    NAME_FUNC_OFFSET(18792, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
-    NAME_FUNC_OFFSET(18809, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
-    NAME_FUNC_OFFSET(18824, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
-    NAME_FUNC_OFFSET(18842, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
-    NAME_FUNC_OFFSET(18856, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
-    NAME_FUNC_OFFSET(18873, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
-    NAME_FUNC_OFFSET(18888, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
-    NAME_FUNC_OFFSET(18906, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
-    NAME_FUNC_OFFSET(18920, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
-    NAME_FUNC_OFFSET(18937, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
-    NAME_FUNC_OFFSET(18952, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
-    NAME_FUNC_OFFSET(18970, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
-    NAME_FUNC_OFFSET(18984, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
-    NAME_FUNC_OFFSET(19001, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
-    NAME_FUNC_OFFSET(19016, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
-    NAME_FUNC_OFFSET(19034, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
-    NAME_FUNC_OFFSET(19051, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
-    NAME_FUNC_OFFSET(19071, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
-    NAME_FUNC_OFFSET(19088, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
-    NAME_FUNC_OFFSET(19114, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
-    NAME_FUNC_OFFSET(19143, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
-    NAME_FUNC_OFFSET(19158, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
-    NAME_FUNC_OFFSET(19176, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
-    NAME_FUNC_OFFSET(19195, gl_dispatch_stub_752, gl_dispatch_stub_752, NULL, _gloffset_DeleteVertexArraysAPPLE),
-    NAME_FUNC_OFFSET(19216, gl_dispatch_stub_754, gl_dispatch_stub_754, NULL, _gloffset_IsVertexArrayAPPLE),
-    NAME_FUNC_OFFSET(19232, gl_dispatch_stub_762, gl_dispatch_stub_762, NULL, _gloffset_BlendEquationSeparateEXT),
-    NAME_FUNC_OFFSET(19256, gl_dispatch_stub_762, gl_dispatch_stub_762, NULL, _gloffset_BlendEquationSeparateEXT),
-    NAME_FUNC_OFFSET(19283, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
-    NAME_FUNC_OFFSET(19301, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
-    NAME_FUNC_OFFSET(19320, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
-    NAME_FUNC_OFFSET(19345, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
-    NAME_FUNC_OFFSET(19366, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
-    NAME_FUNC_OFFSET(19388, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
-    NAME_FUNC_OFFSET(19414, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
-    NAME_FUNC_OFFSET(19437, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
-    NAME_FUNC_OFFSET(19460, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
-    NAME_FUNC_OFFSET(19483, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
-    NAME_FUNC_OFFSET(19501, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
-    NAME_FUNC_OFFSET(19520, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
-    NAME_FUNC_OFFSET(19537, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
-    NAME_FUNC_OFFSET(19575, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
-    NAME_FUNC_OFFSET(19604, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
-    NAME_FUNC_OFFSET(19620, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
-    NAME_FUNC_OFFSET(19637, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
-    NAME_FUNC_OFFSET(19659, gl_dispatch_stub_780, gl_dispatch_stub_780, NULL, _gloffset_BlitFramebufferEXT),
-    NAME_FUNC_OFFSET(19677, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
+    NAME_FUNC_OFFSET( 9172, glDrawElementsBaseVertex, glDrawElementsBaseVertex, NULL, _gloffset_DrawElementsBaseVertex),
+    NAME_FUNC_OFFSET( 9197, glDrawRangeElementsBaseVertex, glDrawRangeElementsBaseVertex, NULL, _gloffset_DrawRangeElementsBaseVertex),
+    NAME_FUNC_OFFSET( 9227, glMultiDrawElementsBaseVertex, glMultiDrawElementsBaseVertex, NULL, _gloffset_MultiDrawElementsBaseVertex),
+    NAME_FUNC_OFFSET( 9257, glPolygonOffsetEXT, glPolygonOffsetEXT, NULL, _gloffset_PolygonOffsetEXT),
+    NAME_FUNC_OFFSET( 9276, gl_dispatch_stub_578, gl_dispatch_stub_578, NULL, _gloffset_GetPixelTexGenParameterfvSGIS),
+    NAME_FUNC_OFFSET( 9308, gl_dispatch_stub_579, gl_dispatch_stub_579, NULL, _gloffset_GetPixelTexGenParameterivSGIS),
+    NAME_FUNC_OFFSET( 9340, gl_dispatch_stub_580, gl_dispatch_stub_580, NULL, _gloffset_PixelTexGenParameterfSGIS),
+    NAME_FUNC_OFFSET( 9368, gl_dispatch_stub_581, gl_dispatch_stub_581, NULL, _gloffset_PixelTexGenParameterfvSGIS),
+    NAME_FUNC_OFFSET( 9397, gl_dispatch_stub_582, gl_dispatch_stub_582, NULL, _gloffset_PixelTexGenParameteriSGIS),
+    NAME_FUNC_OFFSET( 9425, gl_dispatch_stub_583, gl_dispatch_stub_583, NULL, _gloffset_PixelTexGenParameterivSGIS),
+    NAME_FUNC_OFFSET( 9454, gl_dispatch_stub_584, gl_dispatch_stub_584, NULL, _gloffset_SampleMaskSGIS),
+    NAME_FUNC_OFFSET( 9471, gl_dispatch_stub_585, gl_dispatch_stub_585, NULL, _gloffset_SamplePatternSGIS),
+    NAME_FUNC_OFFSET( 9491, glColorPointerEXT, glColorPointerEXT, NULL, _gloffset_ColorPointerEXT),
+    NAME_FUNC_OFFSET( 9509, glEdgeFlagPointerEXT, glEdgeFlagPointerEXT, NULL, _gloffset_EdgeFlagPointerEXT),
+    NAME_FUNC_OFFSET( 9530, glIndexPointerEXT, glIndexPointerEXT, NULL, _gloffset_IndexPointerEXT),
+    NAME_FUNC_OFFSET( 9548, glNormalPointerEXT, glNormalPointerEXT, NULL, _gloffset_NormalPointerEXT),
+    NAME_FUNC_OFFSET( 9567, glTexCoordPointerEXT, glTexCoordPointerEXT, NULL, _gloffset_TexCoordPointerEXT),
+    NAME_FUNC_OFFSET( 9588, glVertexPointerEXT, glVertexPointerEXT, NULL, _gloffset_VertexPointerEXT),
+    NAME_FUNC_OFFSET( 9607, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+    NAME_FUNC_OFFSET( 9628, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+    NAME_FUNC_OFFSET( 9650, glLockArraysEXT, glLockArraysEXT, NULL, _gloffset_LockArraysEXT),
+    NAME_FUNC_OFFSET( 9666, glUnlockArraysEXT, glUnlockArraysEXT, NULL, _gloffset_UnlockArraysEXT),
+    NAME_FUNC_OFFSET( 9684, gl_dispatch_stub_596, gl_dispatch_stub_596, NULL, _gloffset_CullParameterdvEXT),
+    NAME_FUNC_OFFSET( 9705, gl_dispatch_stub_597, gl_dispatch_stub_597, NULL, _gloffset_CullParameterfvEXT),
+    NAME_FUNC_OFFSET( 9726, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
+    NAME_FUNC_OFFSET( 9748, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
+    NAME_FUNC_OFFSET( 9771, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
+    NAME_FUNC_OFFSET( 9793, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
+    NAME_FUNC_OFFSET( 9816, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
+    NAME_FUNC_OFFSET( 9838, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
+    NAME_FUNC_OFFSET( 9861, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
+    NAME_FUNC_OFFSET( 9883, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
+    NAME_FUNC_OFFSET( 9906, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
+    NAME_FUNC_OFFSET( 9928, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
+    NAME_FUNC_OFFSET( 9951, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
+    NAME_FUNC_OFFSET( 9974, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
+    NAME_FUNC_OFFSET( 9998, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
+    NAME_FUNC_OFFSET(10021, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
+    NAME_FUNC_OFFSET(10045, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
+    NAME_FUNC_OFFSET(10068, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
+    NAME_FUNC_OFFSET(10092, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
+    NAME_FUNC_OFFSET(10119, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
+    NAME_FUNC_OFFSET(10140, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
+    NAME_FUNC_OFFSET(10163, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
+    NAME_FUNC_OFFSET(10184, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
+    NAME_FUNC_OFFSET(10199, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
+    NAME_FUNC_OFFSET(10215, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
+    NAME_FUNC_OFFSET(10230, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
+    NAME_FUNC_OFFSET(10246, gl_dispatch_stub_622, gl_dispatch_stub_622, NULL, _gloffset_PixelTexGenSGIX),
+    NAME_FUNC_OFFSET(10264, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
+    NAME_FUNC_OFFSET(10287, glFlushVertexArrayRangeNV, glFlushVertexArrayRangeNV, NULL, _gloffset_FlushVertexArrayRangeNV),
+    NAME_FUNC_OFFSET(10313, glVertexArrayRangeNV, glVertexArrayRangeNV, NULL, _gloffset_VertexArrayRangeNV),
+    NAME_FUNC_OFFSET(10334, glCombinerInputNV, glCombinerInputNV, NULL, _gloffset_CombinerInputNV),
+    NAME_FUNC_OFFSET(10352, glCombinerOutputNV, glCombinerOutputNV, NULL, _gloffset_CombinerOutputNV),
+    NAME_FUNC_OFFSET(10371, glCombinerParameterfNV, glCombinerParameterfNV, NULL, _gloffset_CombinerParameterfNV),
+    NAME_FUNC_OFFSET(10394, glCombinerParameterfvNV, glCombinerParameterfvNV, NULL, _gloffset_CombinerParameterfvNV),
+    NAME_FUNC_OFFSET(10418, glCombinerParameteriNV, glCombinerParameteriNV, NULL, _gloffset_CombinerParameteriNV),
+    NAME_FUNC_OFFSET(10441, glCombinerParameterivNV, glCombinerParameterivNV, NULL, _gloffset_CombinerParameterivNV),
+    NAME_FUNC_OFFSET(10465, glFinalCombinerInputNV, glFinalCombinerInputNV, NULL, _gloffset_FinalCombinerInputNV),
+    NAME_FUNC_OFFSET(10488, glGetCombinerInputParameterfvNV, glGetCombinerInputParameterfvNV, NULL, _gloffset_GetCombinerInputParameterfvNV),
+    NAME_FUNC_OFFSET(10520, glGetCombinerInputParameterivNV, glGetCombinerInputParameterivNV, NULL, _gloffset_GetCombinerInputParameterivNV),
+    NAME_FUNC_OFFSET(10552, glGetCombinerOutputParameterfvNV, glGetCombinerOutputParameterfvNV, NULL, _gloffset_GetCombinerOutputParameterfvNV),
+    NAME_FUNC_OFFSET(10585, glGetCombinerOutputParameterivNV, glGetCombinerOutputParameterivNV, NULL, _gloffset_GetCombinerOutputParameterivNV),
+    NAME_FUNC_OFFSET(10618, glGetFinalCombinerInputParameterfvNV, glGetFinalCombinerInputParameterfvNV, NULL, _gloffset_GetFinalCombinerInputParameterfvNV),
+    NAME_FUNC_OFFSET(10655, glGetFinalCombinerInputParameterivNV, glGetFinalCombinerInputParameterivNV, NULL, _gloffset_GetFinalCombinerInputParameterivNV),
+    NAME_FUNC_OFFSET(10692, glResizeBuffersMESA, glResizeBuffersMESA, NULL, _gloffset_ResizeBuffersMESA),
+    NAME_FUNC_OFFSET(10712, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
+    NAME_FUNC_OFFSET(10730, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
+    NAME_FUNC_OFFSET(10749, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
+    NAME_FUNC_OFFSET(10767, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
+    NAME_FUNC_OFFSET(10786, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
+    NAME_FUNC_OFFSET(10804, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
+    NAME_FUNC_OFFSET(10823, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
+    NAME_FUNC_OFFSET(10841, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
+    NAME_FUNC_OFFSET(10860, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
+    NAME_FUNC_OFFSET(10878, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
+    NAME_FUNC_OFFSET(10897, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
+    NAME_FUNC_OFFSET(10915, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
+    NAME_FUNC_OFFSET(10934, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
+    NAME_FUNC_OFFSET(10952, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
+    NAME_FUNC_OFFSET(10971, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
+    NAME_FUNC_OFFSET(10989, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
+    NAME_FUNC_OFFSET(11008, glWindowPos4dMESA, glWindowPos4dMESA, NULL, _gloffset_WindowPos4dMESA),
+    NAME_FUNC_OFFSET(11026, glWindowPos4dvMESA, glWindowPos4dvMESA, NULL, _gloffset_WindowPos4dvMESA),
+    NAME_FUNC_OFFSET(11045, glWindowPos4fMESA, glWindowPos4fMESA, NULL, _gloffset_WindowPos4fMESA),
+    NAME_FUNC_OFFSET(11063, glWindowPos4fvMESA, glWindowPos4fvMESA, NULL, _gloffset_WindowPos4fvMESA),
+    NAME_FUNC_OFFSET(11082, glWindowPos4iMESA, glWindowPos4iMESA, NULL, _gloffset_WindowPos4iMESA),
+    NAME_FUNC_OFFSET(11100, glWindowPos4ivMESA, glWindowPos4ivMESA, NULL, _gloffset_WindowPos4ivMESA),
+    NAME_FUNC_OFFSET(11119, glWindowPos4sMESA, glWindowPos4sMESA, NULL, _gloffset_WindowPos4sMESA),
+    NAME_FUNC_OFFSET(11137, glWindowPos4svMESA, glWindowPos4svMESA, NULL, _gloffset_WindowPos4svMESA),
+    NAME_FUNC_OFFSET(11156, gl_dispatch_stub_664, gl_dispatch_stub_664, NULL, _gloffset_MultiModeDrawArraysIBM),
+    NAME_FUNC_OFFSET(11181, gl_dispatch_stub_665, gl_dispatch_stub_665, NULL, _gloffset_MultiModeDrawElementsIBM),
+    NAME_FUNC_OFFSET(11208, gl_dispatch_stub_666, gl_dispatch_stub_666, NULL, _gloffset_DeleteFencesNV),
+    NAME_FUNC_OFFSET(11225, gl_dispatch_stub_667, gl_dispatch_stub_667, NULL, _gloffset_FinishFenceNV),
+    NAME_FUNC_OFFSET(11241, gl_dispatch_stub_668, gl_dispatch_stub_668, NULL, _gloffset_GenFencesNV),
+    NAME_FUNC_OFFSET(11255, gl_dispatch_stub_669, gl_dispatch_stub_669, NULL, _gloffset_GetFenceivNV),
+    NAME_FUNC_OFFSET(11270, gl_dispatch_stub_670, gl_dispatch_stub_670, NULL, _gloffset_IsFenceNV),
+    NAME_FUNC_OFFSET(11282, gl_dispatch_stub_671, gl_dispatch_stub_671, NULL, _gloffset_SetFenceNV),
+    NAME_FUNC_OFFSET(11295, gl_dispatch_stub_672, gl_dispatch_stub_672, NULL, _gloffset_TestFenceNV),
+    NAME_FUNC_OFFSET(11309, glAreProgramsResidentNV, glAreProgramsResidentNV, NULL, _gloffset_AreProgramsResidentNV),
+    NAME_FUNC_OFFSET(11333, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
+    NAME_FUNC_OFFSET(11349, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
+    NAME_FUNC_OFFSET(11368, glExecuteProgramNV, glExecuteProgramNV, NULL, _gloffset_ExecuteProgramNV),
+    NAME_FUNC_OFFSET(11387, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
+    NAME_FUNC_OFFSET(11403, glGetProgramParameterdvNV, glGetProgramParameterdvNV, NULL, _gloffset_GetProgramParameterdvNV),
+    NAME_FUNC_OFFSET(11429, glGetProgramParameterfvNV, glGetProgramParameterfvNV, NULL, _gloffset_GetProgramParameterfvNV),
+    NAME_FUNC_OFFSET(11455, glGetProgramStringNV, glGetProgramStringNV, NULL, _gloffset_GetProgramStringNV),
+    NAME_FUNC_OFFSET(11476, glGetProgramivNV, glGetProgramivNV, NULL, _gloffset_GetProgramivNV),
+    NAME_FUNC_OFFSET(11493, glGetTrackMatrixivNV, glGetTrackMatrixivNV, NULL, _gloffset_GetTrackMatrixivNV),
+    NAME_FUNC_OFFSET(11514, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
+    NAME_FUNC_OFFSET(11542, glGetVertexAttribdvNV, glGetVertexAttribdvNV, NULL, _gloffset_GetVertexAttribdvNV),
+    NAME_FUNC_OFFSET(11564, glGetVertexAttribfvNV, glGetVertexAttribfvNV, NULL, _gloffset_GetVertexAttribfvNV),
+    NAME_FUNC_OFFSET(11586, glGetVertexAttribivNV, glGetVertexAttribivNV, NULL, _gloffset_GetVertexAttribivNV),
+    NAME_FUNC_OFFSET(11608, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
+    NAME_FUNC_OFFSET(11622, glLoadProgramNV, glLoadProgramNV, NULL, _gloffset_LoadProgramNV),
+    NAME_FUNC_OFFSET(11638, glProgramParameters4dvNV, glProgramParameters4dvNV, NULL, _gloffset_ProgramParameters4dvNV),
+    NAME_FUNC_OFFSET(11663, glProgramParameters4fvNV, glProgramParameters4fvNV, NULL, _gloffset_ProgramParameters4fvNV),
+    NAME_FUNC_OFFSET(11688, glRequestResidentProgramsNV, glRequestResidentProgramsNV, NULL, _gloffset_RequestResidentProgramsNV),
+    NAME_FUNC_OFFSET(11716, glTrackMatrixNV, glTrackMatrixNV, NULL, _gloffset_TrackMatrixNV),
+    NAME_FUNC_OFFSET(11732, glVertexAttrib1dNV, glVertexAttrib1dNV, NULL, _gloffset_VertexAttrib1dNV),
+    NAME_FUNC_OFFSET(11751, glVertexAttrib1dvNV, glVertexAttrib1dvNV, NULL, _gloffset_VertexAttrib1dvNV),
+    NAME_FUNC_OFFSET(11771, glVertexAttrib1fNV, glVertexAttrib1fNV, NULL, _gloffset_VertexAttrib1fNV),
+    NAME_FUNC_OFFSET(11790, glVertexAttrib1fvNV, glVertexAttrib1fvNV, NULL, _gloffset_VertexAttrib1fvNV),
+    NAME_FUNC_OFFSET(11810, glVertexAttrib1sNV, glVertexAttrib1sNV, NULL, _gloffset_VertexAttrib1sNV),
+    NAME_FUNC_OFFSET(11829, glVertexAttrib1svNV, glVertexAttrib1svNV, NULL, _gloffset_VertexAttrib1svNV),
+    NAME_FUNC_OFFSET(11849, glVertexAttrib2dNV, glVertexAttrib2dNV, NULL, _gloffset_VertexAttrib2dNV),
+    NAME_FUNC_OFFSET(11868, glVertexAttrib2dvNV, glVertexAttrib2dvNV, NULL, _gloffset_VertexAttrib2dvNV),
+    NAME_FUNC_OFFSET(11888, glVertexAttrib2fNV, glVertexAttrib2fNV, NULL, _gloffset_VertexAttrib2fNV),
+    NAME_FUNC_OFFSET(11907, glVertexAttrib2fvNV, glVertexAttrib2fvNV, NULL, _gloffset_VertexAttrib2fvNV),
+    NAME_FUNC_OFFSET(11927, glVertexAttrib2sNV, glVertexAttrib2sNV, NULL, _gloffset_VertexAttrib2sNV),
+    NAME_FUNC_OFFSET(11946, glVertexAttrib2svNV, glVertexAttrib2svNV, NULL, _gloffset_VertexAttrib2svNV),
+    NAME_FUNC_OFFSET(11966, glVertexAttrib3dNV, glVertexAttrib3dNV, NULL, _gloffset_VertexAttrib3dNV),
+    NAME_FUNC_OFFSET(11985, glVertexAttrib3dvNV, glVertexAttrib3dvNV, NULL, _gloffset_VertexAttrib3dvNV),
+    NAME_FUNC_OFFSET(12005, glVertexAttrib3fNV, glVertexAttrib3fNV, NULL, _gloffset_VertexAttrib3fNV),
+    NAME_FUNC_OFFSET(12024, glVertexAttrib3fvNV, glVertexAttrib3fvNV, NULL, _gloffset_VertexAttrib3fvNV),
+    NAME_FUNC_OFFSET(12044, glVertexAttrib3sNV, glVertexAttrib3sNV, NULL, _gloffset_VertexAttrib3sNV),
+    NAME_FUNC_OFFSET(12063, glVertexAttrib3svNV, glVertexAttrib3svNV, NULL, _gloffset_VertexAttrib3svNV),
+    NAME_FUNC_OFFSET(12083, glVertexAttrib4dNV, glVertexAttrib4dNV, NULL, _gloffset_VertexAttrib4dNV),
+    NAME_FUNC_OFFSET(12102, glVertexAttrib4dvNV, glVertexAttrib4dvNV, NULL, _gloffset_VertexAttrib4dvNV),
+    NAME_FUNC_OFFSET(12122, glVertexAttrib4fNV, glVertexAttrib4fNV, NULL, _gloffset_VertexAttrib4fNV),
+    NAME_FUNC_OFFSET(12141, glVertexAttrib4fvNV, glVertexAttrib4fvNV, NULL, _gloffset_VertexAttrib4fvNV),
+    NAME_FUNC_OFFSET(12161, glVertexAttrib4sNV, glVertexAttrib4sNV, NULL, _gloffset_VertexAttrib4sNV),
+    NAME_FUNC_OFFSET(12180, glVertexAttrib4svNV, glVertexAttrib4svNV, NULL, _gloffset_VertexAttrib4svNV),
+    NAME_FUNC_OFFSET(12200, glVertexAttrib4ubNV, glVertexAttrib4ubNV, NULL, _gloffset_VertexAttrib4ubNV),
+    NAME_FUNC_OFFSET(12220, glVertexAttrib4ubvNV, glVertexAttrib4ubvNV, NULL, _gloffset_VertexAttrib4ubvNV),
+    NAME_FUNC_OFFSET(12241, glVertexAttribPointerNV, glVertexAttribPointerNV, NULL, _gloffset_VertexAttribPointerNV),
+    NAME_FUNC_OFFSET(12265, glVertexAttribs1dvNV, glVertexAttribs1dvNV, NULL, _gloffset_VertexAttribs1dvNV),
+    NAME_FUNC_OFFSET(12286, glVertexAttribs1fvNV, glVertexAttribs1fvNV, NULL, _gloffset_VertexAttribs1fvNV),
+    NAME_FUNC_OFFSET(12307, glVertexAttribs1svNV, glVertexAttribs1svNV, NULL, _gloffset_VertexAttribs1svNV),
+    NAME_FUNC_OFFSET(12328, glVertexAttribs2dvNV, glVertexAttribs2dvNV, NULL, _gloffset_VertexAttribs2dvNV),
+    NAME_FUNC_OFFSET(12349, glVertexAttribs2fvNV, glVertexAttribs2fvNV, NULL, _gloffset_VertexAttribs2fvNV),
+    NAME_FUNC_OFFSET(12370, glVertexAttribs2svNV, glVertexAttribs2svNV, NULL, _gloffset_VertexAttribs2svNV),
+    NAME_FUNC_OFFSET(12391, glVertexAttribs3dvNV, glVertexAttribs3dvNV, NULL, _gloffset_VertexAttribs3dvNV),
+    NAME_FUNC_OFFSET(12412, glVertexAttribs3fvNV, glVertexAttribs3fvNV, NULL, _gloffset_VertexAttribs3fvNV),
+    NAME_FUNC_OFFSET(12433, glVertexAttribs3svNV, glVertexAttribs3svNV, NULL, _gloffset_VertexAttribs3svNV),
+    NAME_FUNC_OFFSET(12454, glVertexAttribs4dvNV, glVertexAttribs4dvNV, NULL, _gloffset_VertexAttribs4dvNV),
+    NAME_FUNC_OFFSET(12475, glVertexAttribs4fvNV, glVertexAttribs4fvNV, NULL, _gloffset_VertexAttribs4fvNV),
+    NAME_FUNC_OFFSET(12496, glVertexAttribs4svNV, glVertexAttribs4svNV, NULL, _gloffset_VertexAttribs4svNV),
+    NAME_FUNC_OFFSET(12517, glVertexAttribs4ubvNV, glVertexAttribs4ubvNV, NULL, _gloffset_VertexAttribs4ubvNV),
+    NAME_FUNC_OFFSET(12539, glGetTexBumpParameterfvATI, glGetTexBumpParameterfvATI, NULL, _gloffset_GetTexBumpParameterfvATI),
+    NAME_FUNC_OFFSET(12566, glGetTexBumpParameterivATI, glGetTexBumpParameterivATI, NULL, _gloffset_GetTexBumpParameterivATI),
+    NAME_FUNC_OFFSET(12593, glTexBumpParameterfvATI, glTexBumpParameterfvATI, NULL, _gloffset_TexBumpParameterfvATI),
+    NAME_FUNC_OFFSET(12617, glTexBumpParameterivATI, glTexBumpParameterivATI, NULL, _gloffset_TexBumpParameterivATI),
+    NAME_FUNC_OFFSET(12641, glAlphaFragmentOp1ATI, glAlphaFragmentOp1ATI, NULL, _gloffset_AlphaFragmentOp1ATI),
+    NAME_FUNC_OFFSET(12663, glAlphaFragmentOp2ATI, glAlphaFragmentOp2ATI, NULL, _gloffset_AlphaFragmentOp2ATI),
+    NAME_FUNC_OFFSET(12685, glAlphaFragmentOp3ATI, glAlphaFragmentOp3ATI, NULL, _gloffset_AlphaFragmentOp3ATI),
+    NAME_FUNC_OFFSET(12707, glBeginFragmentShaderATI, glBeginFragmentShaderATI, NULL, _gloffset_BeginFragmentShaderATI),
+    NAME_FUNC_OFFSET(12732, glBindFragmentShaderATI, glBindFragmentShaderATI, NULL, _gloffset_BindFragmentShaderATI),
+    NAME_FUNC_OFFSET(12756, glColorFragmentOp1ATI, glColorFragmentOp1ATI, NULL, _gloffset_ColorFragmentOp1ATI),
+    NAME_FUNC_OFFSET(12778, glColorFragmentOp2ATI, glColorFragmentOp2ATI, NULL, _gloffset_ColorFragmentOp2ATI),
+    NAME_FUNC_OFFSET(12800, glColorFragmentOp3ATI, glColorFragmentOp3ATI, NULL, _gloffset_ColorFragmentOp3ATI),
+    NAME_FUNC_OFFSET(12822, glDeleteFragmentShaderATI, glDeleteFragmentShaderATI, NULL, _gloffset_DeleteFragmentShaderATI),
+    NAME_FUNC_OFFSET(12848, glEndFragmentShaderATI, glEndFragmentShaderATI, NULL, _gloffset_EndFragmentShaderATI),
+    NAME_FUNC_OFFSET(12871, glGenFragmentShadersATI, glGenFragmentShadersATI, NULL, _gloffset_GenFragmentShadersATI),
+    NAME_FUNC_OFFSET(12895, glPassTexCoordATI, glPassTexCoordATI, NULL, _gloffset_PassTexCoordATI),
+    NAME_FUNC_OFFSET(12913, glSampleMapATI, glSampleMapATI, NULL, _gloffset_SampleMapATI),
+    NAME_FUNC_OFFSET(12928, glSetFragmentShaderConstantATI, glSetFragmentShaderConstantATI, NULL, _gloffset_SetFragmentShaderConstantATI),
+    NAME_FUNC_OFFSET(12959, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
+    NAME_FUNC_OFFSET(12979, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
+    NAME_FUNC_OFFSET(13000, gl_dispatch_stub_753, gl_dispatch_stub_753, NULL, _gloffset_ActiveStencilFaceEXT),
+    NAME_FUNC_OFFSET(13023, gl_dispatch_stub_754, gl_dispatch_stub_754, NULL, _gloffset_BindVertexArrayAPPLE),
+    NAME_FUNC_OFFSET(13046, gl_dispatch_stub_755, gl_dispatch_stub_755, NULL, _gloffset_DeleteVertexArraysAPPLE),
+    NAME_FUNC_OFFSET(13072, gl_dispatch_stub_756, gl_dispatch_stub_756, NULL, _gloffset_GenVertexArraysAPPLE),
+    NAME_FUNC_OFFSET(13095, gl_dispatch_stub_757, gl_dispatch_stub_757, NULL, _gloffset_IsVertexArrayAPPLE),
+    NAME_FUNC_OFFSET(13116, glGetProgramNamedParameterdvNV, glGetProgramNamedParameterdvNV, NULL, _gloffset_GetProgramNamedParameterdvNV),
+    NAME_FUNC_OFFSET(13147, glGetProgramNamedParameterfvNV, glGetProgramNamedParameterfvNV, NULL, _gloffset_GetProgramNamedParameterfvNV),
+    NAME_FUNC_OFFSET(13178, glProgramNamedParameter4dNV, glProgramNamedParameter4dNV, NULL, _gloffset_ProgramNamedParameter4dNV),
+    NAME_FUNC_OFFSET(13206, glProgramNamedParameter4dvNV, glProgramNamedParameter4dvNV, NULL, _gloffset_ProgramNamedParameter4dvNV),
+    NAME_FUNC_OFFSET(13235, glProgramNamedParameter4fNV, glProgramNamedParameter4fNV, NULL, _gloffset_ProgramNamedParameter4fNV),
+    NAME_FUNC_OFFSET(13263, glProgramNamedParameter4fvNV, glProgramNamedParameter4fvNV, NULL, _gloffset_ProgramNamedParameter4fvNV),
+    NAME_FUNC_OFFSET(13292, gl_dispatch_stub_764, gl_dispatch_stub_764, NULL, _gloffset_DepthBoundsEXT),
+    NAME_FUNC_OFFSET(13309, gl_dispatch_stub_765, gl_dispatch_stub_765, NULL, _gloffset_BlendEquationSeparateEXT),
+    NAME_FUNC_OFFSET(13336, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
+    NAME_FUNC_OFFSET(13357, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
+    NAME_FUNC_OFFSET(13379, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
+    NAME_FUNC_OFFSET(13407, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
+    NAME_FUNC_OFFSET(13431, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
+    NAME_FUNC_OFFSET(13456, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
+    NAME_FUNC_OFFSET(13485, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
+    NAME_FUNC_OFFSET(13511, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
+    NAME_FUNC_OFFSET(13537, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
+    NAME_FUNC_OFFSET(13563, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
+    NAME_FUNC_OFFSET(13584, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
+    NAME_FUNC_OFFSET(13606, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
+    NAME_FUNC_OFFSET(13626, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
+    NAME_FUNC_OFFSET(13667, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
+    NAME_FUNC_OFFSET(13699, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
+    NAME_FUNC_OFFSET(13718, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
+    NAME_FUNC_OFFSET(13738, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
+    NAME_FUNC_OFFSET(13763, gl_dispatch_stub_783, gl_dispatch_stub_783, NULL, _gloffset_BlitFramebufferEXT),
+    NAME_FUNC_OFFSET(13784, gl_dispatch_stub_784, gl_dispatch_stub_784, NULL, _gloffset_BufferParameteriAPPLE),
+    NAME_FUNC_OFFSET(13808, gl_dispatch_stub_785, gl_dispatch_stub_785, NULL, _gloffset_FlushMappedBufferRangeAPPLE),
+    NAME_FUNC_OFFSET(13838, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
+    NAME_FUNC_OFFSET(13867, glProvokingVertexEXT, glProvokingVertexEXT, NULL, _gloffset_ProvokingVertexEXT),
+    NAME_FUNC_OFFSET(13888, gl_dispatch_stub_788, gl_dispatch_stub_788, NULL, _gloffset_GetTexParameterPointervAPPLE),
+    NAME_FUNC_OFFSET(13919, gl_dispatch_stub_789, gl_dispatch_stub_789, NULL, _gloffset_TextureRangeAPPLE),
+    NAME_FUNC_OFFSET(13939, gl_dispatch_stub_790, gl_dispatch_stub_790, NULL, _gloffset_StencilFuncSeparateATI),
+    NAME_FUNC_OFFSET(13964, gl_dispatch_stub_791, gl_dispatch_stub_791, NULL, _gloffset_ProgramEnvParameters4fvEXT),
+    NAME_FUNC_OFFSET(13993, gl_dispatch_stub_792, gl_dispatch_stub_792, NULL, _gloffset_ProgramLocalParameters4fvEXT),
+    NAME_FUNC_OFFSET(14024, gl_dispatch_stub_793, gl_dispatch_stub_793, NULL, _gloffset_GetQueryObjecti64vEXT),
+    NAME_FUNC_OFFSET(14048, gl_dispatch_stub_794, gl_dispatch_stub_794, NULL, _gloffset_GetQueryObjectui64vEXT),
+    NAME_FUNC_OFFSET(14073, glArrayElement, glArrayElement, NULL, _gloffset_ArrayElement),
+    NAME_FUNC_OFFSET(14091, glBindTexture, glBindTexture, NULL, _gloffset_BindTexture),
+    NAME_FUNC_OFFSET(14108, glDrawArrays, glDrawArrays, NULL, _gloffset_DrawArrays),
+    NAME_FUNC_OFFSET(14124, glAreTexturesResident, glAreTexturesResidentEXT, glAreTexturesResidentEXT, _gloffset_AreTexturesResident),
+    NAME_FUNC_OFFSET(14149, glCopyTexImage1D, glCopyTexImage1D, NULL, _gloffset_CopyTexImage1D),
+    NAME_FUNC_OFFSET(14169, glCopyTexImage2D, glCopyTexImage2D, NULL, _gloffset_CopyTexImage2D),
+    NAME_FUNC_OFFSET(14189, glCopyTexSubImage1D, glCopyTexSubImage1D, NULL, _gloffset_CopyTexSubImage1D),
+    NAME_FUNC_OFFSET(14212, glCopyTexSubImage2D, glCopyTexSubImage2D, NULL, _gloffset_CopyTexSubImage2D),
+    NAME_FUNC_OFFSET(14235, glDeleteTextures, glDeleteTexturesEXT, glDeleteTexturesEXT, _gloffset_DeleteTextures),
+    NAME_FUNC_OFFSET(14255, glGenTextures, glGenTexturesEXT, glGenTexturesEXT, _gloffset_GenTextures),
+    NAME_FUNC_OFFSET(14272, glGetPointerv, glGetPointerv, NULL, _gloffset_GetPointerv),
+    NAME_FUNC_OFFSET(14289, glIsTexture, glIsTextureEXT, glIsTextureEXT, _gloffset_IsTexture),
+    NAME_FUNC_OFFSET(14304, glPrioritizeTextures, glPrioritizeTextures, NULL, _gloffset_PrioritizeTextures),
+    NAME_FUNC_OFFSET(14328, glTexSubImage1D, glTexSubImage1D, NULL, _gloffset_TexSubImage1D),
+    NAME_FUNC_OFFSET(14347, glTexSubImage2D, glTexSubImage2D, NULL, _gloffset_TexSubImage2D),
+    NAME_FUNC_OFFSET(14366, glBlendColor, glBlendColor, NULL, _gloffset_BlendColor),
+    NAME_FUNC_OFFSET(14382, glBlendEquation, glBlendEquation, NULL, _gloffset_BlendEquation),
+    NAME_FUNC_OFFSET(14401, glDrawRangeElements, glDrawRangeElements, NULL, _gloffset_DrawRangeElements),
+    NAME_FUNC_OFFSET(14424, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
+    NAME_FUNC_OFFSET(14440, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
+    NAME_FUNC_OFFSET(14456, glColorTableParameterfv, glColorTableParameterfv, NULL, _gloffset_ColorTableParameterfv),
+    NAME_FUNC_OFFSET(14483, glColorTableParameteriv, glColorTableParameteriv, NULL, _gloffset_ColorTableParameteriv),
+    NAME_FUNC_OFFSET(14510, glCopyColorTable, glCopyColorTable, NULL, _gloffset_CopyColorTable),
+    NAME_FUNC_OFFSET(14530, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
+    NAME_FUNC_OFFSET(14549, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
+    NAME_FUNC_OFFSET(14568, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
+    NAME_FUNC_OFFSET(14598, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
+    NAME_FUNC_OFFSET(14628, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
+    NAME_FUNC_OFFSET(14658, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
+    NAME_FUNC_OFFSET(14688, glColorSubTable, glColorSubTable, NULL, _gloffset_ColorSubTable),
+    NAME_FUNC_OFFSET(14707, glCopyColorSubTable, glCopyColorSubTable, NULL, _gloffset_CopyColorSubTable),
+    NAME_FUNC_OFFSET(14730, glConvolutionFilter1D, glConvolutionFilter1D, NULL, _gloffset_ConvolutionFilter1D),
+    NAME_FUNC_OFFSET(14755, glConvolutionFilter2D, glConvolutionFilter2D, NULL, _gloffset_ConvolutionFilter2D),
+    NAME_FUNC_OFFSET(14780, glConvolutionParameterf, glConvolutionParameterf, NULL, _gloffset_ConvolutionParameterf),
+    NAME_FUNC_OFFSET(14807, glConvolutionParameterfv, glConvolutionParameterfv, NULL, _gloffset_ConvolutionParameterfv),
+    NAME_FUNC_OFFSET(14835, glConvolutionParameteri, glConvolutionParameteri, NULL, _gloffset_ConvolutionParameteri),
+    NAME_FUNC_OFFSET(14862, glConvolutionParameteriv, glConvolutionParameteriv, NULL, _gloffset_ConvolutionParameteriv),
+    NAME_FUNC_OFFSET(14890, glCopyConvolutionFilter1D, glCopyConvolutionFilter1D, NULL, _gloffset_CopyConvolutionFilter1D),
+    NAME_FUNC_OFFSET(14919, glCopyConvolutionFilter2D, glCopyConvolutionFilter2D, NULL, _gloffset_CopyConvolutionFilter2D),
+    NAME_FUNC_OFFSET(14948, glGetConvolutionFilter, gl_dispatch_stub_356, gl_dispatch_stub_356, _gloffset_GetConvolutionFilter),
+    NAME_FUNC_OFFSET(14974, glGetConvolutionParameterfv, gl_dispatch_stub_357, gl_dispatch_stub_357, _gloffset_GetConvolutionParameterfv),
+    NAME_FUNC_OFFSET(15005, glGetConvolutionParameteriv, gl_dispatch_stub_358, gl_dispatch_stub_358, _gloffset_GetConvolutionParameteriv),
+    NAME_FUNC_OFFSET(15036, glGetSeparableFilter, gl_dispatch_stub_359, gl_dispatch_stub_359, _gloffset_GetSeparableFilter),
+    NAME_FUNC_OFFSET(15060, glSeparableFilter2D, glSeparableFilter2D, NULL, _gloffset_SeparableFilter2D),
+    NAME_FUNC_OFFSET(15083, glGetHistogram, gl_dispatch_stub_361, gl_dispatch_stub_361, _gloffset_GetHistogram),
+    NAME_FUNC_OFFSET(15101, glGetHistogramParameterfv, gl_dispatch_stub_362, gl_dispatch_stub_362, _gloffset_GetHistogramParameterfv),
+    NAME_FUNC_OFFSET(15130, glGetHistogramParameteriv, gl_dispatch_stub_363, gl_dispatch_stub_363, _gloffset_GetHistogramParameteriv),
+    NAME_FUNC_OFFSET(15159, glGetMinmax, gl_dispatch_stub_364, gl_dispatch_stub_364, _gloffset_GetMinmax),
+    NAME_FUNC_OFFSET(15174, glGetMinmaxParameterfv, gl_dispatch_stub_365, gl_dispatch_stub_365, _gloffset_GetMinmaxParameterfv),
+    NAME_FUNC_OFFSET(15200, glGetMinmaxParameteriv, gl_dispatch_stub_366, gl_dispatch_stub_366, _gloffset_GetMinmaxParameteriv),
+    NAME_FUNC_OFFSET(15226, glHistogram, glHistogram, NULL, _gloffset_Histogram),
+    NAME_FUNC_OFFSET(15241, glMinmax, glMinmax, NULL, _gloffset_Minmax),
+    NAME_FUNC_OFFSET(15253, glResetHistogram, glResetHistogram, NULL, _gloffset_ResetHistogram),
+    NAME_FUNC_OFFSET(15273, glResetMinmax, glResetMinmax, NULL, _gloffset_ResetMinmax),
+    NAME_FUNC_OFFSET(15290, glTexImage3D, glTexImage3D, NULL, _gloffset_TexImage3D),
+    NAME_FUNC_OFFSET(15306, glTexSubImage3D, glTexSubImage3D, NULL, _gloffset_TexSubImage3D),
+    NAME_FUNC_OFFSET(15325, glCopyTexSubImage3D, glCopyTexSubImage3D, NULL, _gloffset_CopyTexSubImage3D),
+    NAME_FUNC_OFFSET(15348, glActiveTextureARB, glActiveTextureARB, NULL, _gloffset_ActiveTextureARB),
+    NAME_FUNC_OFFSET(15364, glClientActiveTextureARB, glClientActiveTextureARB, NULL, _gloffset_ClientActiveTextureARB),
+    NAME_FUNC_OFFSET(15386, glMultiTexCoord1dARB, glMultiTexCoord1dARB, NULL, _gloffset_MultiTexCoord1dARB),
+    NAME_FUNC_OFFSET(15404, glMultiTexCoord1dvARB, glMultiTexCoord1dvARB, NULL, _gloffset_MultiTexCoord1dvARB),
+    NAME_FUNC_OFFSET(15423, glMultiTexCoord1fARB, glMultiTexCoord1fARB, NULL, _gloffset_MultiTexCoord1fARB),
+    NAME_FUNC_OFFSET(15441, glMultiTexCoord1fvARB, glMultiTexCoord1fvARB, NULL, _gloffset_MultiTexCoord1fvARB),
+    NAME_FUNC_OFFSET(15460, glMultiTexCoord1iARB, glMultiTexCoord1iARB, NULL, _gloffset_MultiTexCoord1iARB),
+    NAME_FUNC_OFFSET(15478, glMultiTexCoord1ivARB, glMultiTexCoord1ivARB, NULL, _gloffset_MultiTexCoord1ivARB),
+    NAME_FUNC_OFFSET(15497, glMultiTexCoord1sARB, glMultiTexCoord1sARB, NULL, _gloffset_MultiTexCoord1sARB),
+    NAME_FUNC_OFFSET(15515, glMultiTexCoord1svARB, glMultiTexCoord1svARB, NULL, _gloffset_MultiTexCoord1svARB),
+    NAME_FUNC_OFFSET(15534, glMultiTexCoord2dARB, glMultiTexCoord2dARB, NULL, _gloffset_MultiTexCoord2dARB),
+    NAME_FUNC_OFFSET(15552, glMultiTexCoord2dvARB, glMultiTexCoord2dvARB, NULL, _gloffset_MultiTexCoord2dvARB),
+    NAME_FUNC_OFFSET(15571, glMultiTexCoord2fARB, glMultiTexCoord2fARB, NULL, _gloffset_MultiTexCoord2fARB),
+    NAME_FUNC_OFFSET(15589, glMultiTexCoord2fvARB, glMultiTexCoord2fvARB, NULL, _gloffset_MultiTexCoord2fvARB),
+    NAME_FUNC_OFFSET(15608, glMultiTexCoord2iARB, glMultiTexCoord2iARB, NULL, _gloffset_MultiTexCoord2iARB),
+    NAME_FUNC_OFFSET(15626, glMultiTexCoord2ivARB, glMultiTexCoord2ivARB, NULL, _gloffset_MultiTexCoord2ivARB),
+    NAME_FUNC_OFFSET(15645, glMultiTexCoord2sARB, glMultiTexCoord2sARB, NULL, _gloffset_MultiTexCoord2sARB),
+    NAME_FUNC_OFFSET(15663, glMultiTexCoord2svARB, glMultiTexCoord2svARB, NULL, _gloffset_MultiTexCoord2svARB),
+    NAME_FUNC_OFFSET(15682, glMultiTexCoord3dARB, glMultiTexCoord3dARB, NULL, _gloffset_MultiTexCoord3dARB),
+    NAME_FUNC_OFFSET(15700, glMultiTexCoord3dvARB, glMultiTexCoord3dvARB, NULL, _gloffset_MultiTexCoord3dvARB),
+    NAME_FUNC_OFFSET(15719, glMultiTexCoord3fARB, glMultiTexCoord3fARB, NULL, _gloffset_MultiTexCoord3fARB),
+    NAME_FUNC_OFFSET(15737, glMultiTexCoord3fvARB, glMultiTexCoord3fvARB, NULL, _gloffset_MultiTexCoord3fvARB),
+    NAME_FUNC_OFFSET(15756, glMultiTexCoord3iARB, glMultiTexCoord3iARB, NULL, _gloffset_MultiTexCoord3iARB),
+    NAME_FUNC_OFFSET(15774, glMultiTexCoord3ivARB, glMultiTexCoord3ivARB, NULL, _gloffset_MultiTexCoord3ivARB),
+    NAME_FUNC_OFFSET(15793, glMultiTexCoord3sARB, glMultiTexCoord3sARB, NULL, _gloffset_MultiTexCoord3sARB),
+    NAME_FUNC_OFFSET(15811, glMultiTexCoord3svARB, glMultiTexCoord3svARB, NULL, _gloffset_MultiTexCoord3svARB),
+    NAME_FUNC_OFFSET(15830, glMultiTexCoord4dARB, glMultiTexCoord4dARB, NULL, _gloffset_MultiTexCoord4dARB),
+    NAME_FUNC_OFFSET(15848, glMultiTexCoord4dvARB, glMultiTexCoord4dvARB, NULL, _gloffset_MultiTexCoord4dvARB),
+    NAME_FUNC_OFFSET(15867, glMultiTexCoord4fARB, glMultiTexCoord4fARB, NULL, _gloffset_MultiTexCoord4fARB),
+    NAME_FUNC_OFFSET(15885, glMultiTexCoord4fvARB, glMultiTexCoord4fvARB, NULL, _gloffset_MultiTexCoord4fvARB),
+    NAME_FUNC_OFFSET(15904, glMultiTexCoord4iARB, glMultiTexCoord4iARB, NULL, _gloffset_MultiTexCoord4iARB),
+    NAME_FUNC_OFFSET(15922, glMultiTexCoord4ivARB, glMultiTexCoord4ivARB, NULL, _gloffset_MultiTexCoord4ivARB),
+    NAME_FUNC_OFFSET(15941, glMultiTexCoord4sARB, glMultiTexCoord4sARB, NULL, _gloffset_MultiTexCoord4sARB),
+    NAME_FUNC_OFFSET(15959, glMultiTexCoord4svARB, glMultiTexCoord4svARB, NULL, _gloffset_MultiTexCoord4svARB),
+    NAME_FUNC_OFFSET(15978, glStencilOpSeparate, glStencilOpSeparate, NULL, _gloffset_StencilOpSeparate),
+    NAME_FUNC_OFFSET(16001, glLoadTransposeMatrixdARB, glLoadTransposeMatrixdARB, NULL, _gloffset_LoadTransposeMatrixdARB),
+    NAME_FUNC_OFFSET(16024, glLoadTransposeMatrixfARB, glLoadTransposeMatrixfARB, NULL, _gloffset_LoadTransposeMatrixfARB),
+    NAME_FUNC_OFFSET(16047, glMultTransposeMatrixdARB, glMultTransposeMatrixdARB, NULL, _gloffset_MultTransposeMatrixdARB),
+    NAME_FUNC_OFFSET(16070, glMultTransposeMatrixfARB, glMultTransposeMatrixfARB, NULL, _gloffset_MultTransposeMatrixfARB),
+    NAME_FUNC_OFFSET(16093, glSampleCoverageARB, glSampleCoverageARB, NULL, _gloffset_SampleCoverageARB),
+    NAME_FUNC_OFFSET(16110, glCompressedTexImage1DARB, glCompressedTexImage1DARB, NULL, _gloffset_CompressedTexImage1DARB),
+    NAME_FUNC_OFFSET(16133, glCompressedTexImage2DARB, glCompressedTexImage2DARB, NULL, _gloffset_CompressedTexImage2DARB),
+    NAME_FUNC_OFFSET(16156, glCompressedTexImage3DARB, glCompressedTexImage3DARB, NULL, _gloffset_CompressedTexImage3DARB),
+    NAME_FUNC_OFFSET(16179, glCompressedTexSubImage1DARB, glCompressedTexSubImage1DARB, NULL, _gloffset_CompressedTexSubImage1DARB),
+    NAME_FUNC_OFFSET(16205, glCompressedTexSubImage2DARB, glCompressedTexSubImage2DARB, NULL, _gloffset_CompressedTexSubImage2DARB),
+    NAME_FUNC_OFFSET(16231, glCompressedTexSubImage3DARB, glCompressedTexSubImage3DARB, NULL, _gloffset_CompressedTexSubImage3DARB),
+    NAME_FUNC_OFFSET(16257, glGetCompressedTexImageARB, glGetCompressedTexImageARB, NULL, _gloffset_GetCompressedTexImageARB),
+    NAME_FUNC_OFFSET(16281, glDisableVertexAttribArrayARB, glDisableVertexAttribArrayARB, NULL, _gloffset_DisableVertexAttribArrayARB),
+    NAME_FUNC_OFFSET(16308, glEnableVertexAttribArrayARB, glEnableVertexAttribArrayARB, NULL, _gloffset_EnableVertexAttribArrayARB),
+    NAME_FUNC_OFFSET(16334, glGetVertexAttribdvARB, glGetVertexAttribdvARB, NULL, _gloffset_GetVertexAttribdvARB),
+    NAME_FUNC_OFFSET(16354, glGetVertexAttribfvARB, glGetVertexAttribfvARB, NULL, _gloffset_GetVertexAttribfvARB),
+    NAME_FUNC_OFFSET(16374, glGetVertexAttribivARB, glGetVertexAttribivARB, NULL, _gloffset_GetVertexAttribivARB),
+    NAME_FUNC_OFFSET(16394, glProgramEnvParameter4dARB, glProgramEnvParameter4dARB, NULL, _gloffset_ProgramEnvParameter4dARB),
+    NAME_FUNC_OFFSET(16417, glProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB, NULL, _gloffset_ProgramEnvParameter4dvARB),
+    NAME_FUNC_OFFSET(16441, glProgramEnvParameter4fARB, glProgramEnvParameter4fARB, NULL, _gloffset_ProgramEnvParameter4fARB),
+    NAME_FUNC_OFFSET(16464, glProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB, NULL, _gloffset_ProgramEnvParameter4fvARB),
+    NAME_FUNC_OFFSET(16488, glVertexAttrib1dARB, glVertexAttrib1dARB, NULL, _gloffset_VertexAttrib1dARB),
+    NAME_FUNC_OFFSET(16505, glVertexAttrib1dvARB, glVertexAttrib1dvARB, NULL, _gloffset_VertexAttrib1dvARB),
+    NAME_FUNC_OFFSET(16523, glVertexAttrib1fARB, glVertexAttrib1fARB, NULL, _gloffset_VertexAttrib1fARB),
+    NAME_FUNC_OFFSET(16540, glVertexAttrib1fvARB, glVertexAttrib1fvARB, NULL, _gloffset_VertexAttrib1fvARB),
+    NAME_FUNC_OFFSET(16558, glVertexAttrib1sARB, glVertexAttrib1sARB, NULL, _gloffset_VertexAttrib1sARB),
+    NAME_FUNC_OFFSET(16575, glVertexAttrib1svARB, glVertexAttrib1svARB, NULL, _gloffset_VertexAttrib1svARB),
+    NAME_FUNC_OFFSET(16593, glVertexAttrib2dARB, glVertexAttrib2dARB, NULL, _gloffset_VertexAttrib2dARB),
+    NAME_FUNC_OFFSET(16610, glVertexAttrib2dvARB, glVertexAttrib2dvARB, NULL, _gloffset_VertexAttrib2dvARB),
+    NAME_FUNC_OFFSET(16628, glVertexAttrib2fARB, glVertexAttrib2fARB, NULL, _gloffset_VertexAttrib2fARB),
+    NAME_FUNC_OFFSET(16645, glVertexAttrib2fvARB, glVertexAttrib2fvARB, NULL, _gloffset_VertexAttrib2fvARB),
+    NAME_FUNC_OFFSET(16663, glVertexAttrib2sARB, glVertexAttrib2sARB, NULL, _gloffset_VertexAttrib2sARB),
+    NAME_FUNC_OFFSET(16680, glVertexAttrib2svARB, glVertexAttrib2svARB, NULL, _gloffset_VertexAttrib2svARB),
+    NAME_FUNC_OFFSET(16698, glVertexAttrib3dARB, glVertexAttrib3dARB, NULL, _gloffset_VertexAttrib3dARB),
+    NAME_FUNC_OFFSET(16715, glVertexAttrib3dvARB, glVertexAttrib3dvARB, NULL, _gloffset_VertexAttrib3dvARB),
+    NAME_FUNC_OFFSET(16733, glVertexAttrib3fARB, glVertexAttrib3fARB, NULL, _gloffset_VertexAttrib3fARB),
+    NAME_FUNC_OFFSET(16750, glVertexAttrib3fvARB, glVertexAttrib3fvARB, NULL, _gloffset_VertexAttrib3fvARB),
+    NAME_FUNC_OFFSET(16768, glVertexAttrib3sARB, glVertexAttrib3sARB, NULL, _gloffset_VertexAttrib3sARB),
+    NAME_FUNC_OFFSET(16785, glVertexAttrib3svARB, glVertexAttrib3svARB, NULL, _gloffset_VertexAttrib3svARB),
+    NAME_FUNC_OFFSET(16803, glVertexAttrib4NbvARB, glVertexAttrib4NbvARB, NULL, _gloffset_VertexAttrib4NbvARB),
+    NAME_FUNC_OFFSET(16822, glVertexAttrib4NivARB, glVertexAttrib4NivARB, NULL, _gloffset_VertexAttrib4NivARB),
+    NAME_FUNC_OFFSET(16841, glVertexAttrib4NsvARB, glVertexAttrib4NsvARB, NULL, _gloffset_VertexAttrib4NsvARB),
+    NAME_FUNC_OFFSET(16860, glVertexAttrib4NubARB, glVertexAttrib4NubARB, NULL, _gloffset_VertexAttrib4NubARB),
+    NAME_FUNC_OFFSET(16879, glVertexAttrib4NubvARB, glVertexAttrib4NubvARB, NULL, _gloffset_VertexAttrib4NubvARB),
+    NAME_FUNC_OFFSET(16899, glVertexAttrib4NuivARB, glVertexAttrib4NuivARB, NULL, _gloffset_VertexAttrib4NuivARB),
+    NAME_FUNC_OFFSET(16919, glVertexAttrib4NusvARB, glVertexAttrib4NusvARB, NULL, _gloffset_VertexAttrib4NusvARB),
+    NAME_FUNC_OFFSET(16939, glVertexAttrib4bvARB, glVertexAttrib4bvARB, NULL, _gloffset_VertexAttrib4bvARB),
+    NAME_FUNC_OFFSET(16957, glVertexAttrib4dARB, glVertexAttrib4dARB, NULL, _gloffset_VertexAttrib4dARB),
+    NAME_FUNC_OFFSET(16974, glVertexAttrib4dvARB, glVertexAttrib4dvARB, NULL, _gloffset_VertexAttrib4dvARB),
+    NAME_FUNC_OFFSET(16992, glVertexAttrib4fARB, glVertexAttrib4fARB, NULL, _gloffset_VertexAttrib4fARB),
+    NAME_FUNC_OFFSET(17009, glVertexAttrib4fvARB, glVertexAttrib4fvARB, NULL, _gloffset_VertexAttrib4fvARB),
+    NAME_FUNC_OFFSET(17027, glVertexAttrib4ivARB, glVertexAttrib4ivARB, NULL, _gloffset_VertexAttrib4ivARB),
+    NAME_FUNC_OFFSET(17045, glVertexAttrib4sARB, glVertexAttrib4sARB, NULL, _gloffset_VertexAttrib4sARB),
+    NAME_FUNC_OFFSET(17062, glVertexAttrib4svARB, glVertexAttrib4svARB, NULL, _gloffset_VertexAttrib4svARB),
+    NAME_FUNC_OFFSET(17080, glVertexAttrib4ubvARB, glVertexAttrib4ubvARB, NULL, _gloffset_VertexAttrib4ubvARB),
+    NAME_FUNC_OFFSET(17099, glVertexAttrib4uivARB, glVertexAttrib4uivARB, NULL, _gloffset_VertexAttrib4uivARB),
+    NAME_FUNC_OFFSET(17118, glVertexAttrib4usvARB, glVertexAttrib4usvARB, NULL, _gloffset_VertexAttrib4usvARB),
+    NAME_FUNC_OFFSET(17137, glVertexAttribPointerARB, glVertexAttribPointerARB, NULL, _gloffset_VertexAttribPointerARB),
+    NAME_FUNC_OFFSET(17159, glBindBufferARB, glBindBufferARB, NULL, _gloffset_BindBufferARB),
+    NAME_FUNC_OFFSET(17172, glBufferDataARB, glBufferDataARB, NULL, _gloffset_BufferDataARB),
+    NAME_FUNC_OFFSET(17185, glBufferSubDataARB, glBufferSubDataARB, NULL, _gloffset_BufferSubDataARB),
+    NAME_FUNC_OFFSET(17201, glDeleteBuffersARB, glDeleteBuffersARB, NULL, _gloffset_DeleteBuffersARB),
+    NAME_FUNC_OFFSET(17217, glGenBuffersARB, glGenBuffersARB, NULL, _gloffset_GenBuffersARB),
+    NAME_FUNC_OFFSET(17230, glGetBufferParameterivARB, glGetBufferParameterivARB, NULL, _gloffset_GetBufferParameterivARB),
+    NAME_FUNC_OFFSET(17253, glGetBufferPointervARB, glGetBufferPointervARB, NULL, _gloffset_GetBufferPointervARB),
+    NAME_FUNC_OFFSET(17273, glGetBufferSubDataARB, glGetBufferSubDataARB, NULL, _gloffset_GetBufferSubDataARB),
+    NAME_FUNC_OFFSET(17292, glIsBufferARB, glIsBufferARB, NULL, _gloffset_IsBufferARB),
+    NAME_FUNC_OFFSET(17303, glMapBufferARB, glMapBufferARB, NULL, _gloffset_MapBufferARB),
+    NAME_FUNC_OFFSET(17315, glUnmapBufferARB, glUnmapBufferARB, NULL, _gloffset_UnmapBufferARB),
+    NAME_FUNC_OFFSET(17329, glBeginQueryARB, glBeginQueryARB, NULL, _gloffset_BeginQueryARB),
+    NAME_FUNC_OFFSET(17342, glDeleteQueriesARB, glDeleteQueriesARB, NULL, _gloffset_DeleteQueriesARB),
+    NAME_FUNC_OFFSET(17358, glEndQueryARB, glEndQueryARB, NULL, _gloffset_EndQueryARB),
+    NAME_FUNC_OFFSET(17369, glGenQueriesARB, glGenQueriesARB, NULL, _gloffset_GenQueriesARB),
+    NAME_FUNC_OFFSET(17382, glGetQueryObjectivARB, glGetQueryObjectivARB, NULL, _gloffset_GetQueryObjectivARB),
+    NAME_FUNC_OFFSET(17401, glGetQueryObjectuivARB, glGetQueryObjectuivARB, NULL, _gloffset_GetQueryObjectuivARB),
+    NAME_FUNC_OFFSET(17421, glGetQueryivARB, glGetQueryivARB, NULL, _gloffset_GetQueryivARB),
+    NAME_FUNC_OFFSET(17434, glIsQueryARB, glIsQueryARB, NULL, _gloffset_IsQueryARB),
+    NAME_FUNC_OFFSET(17444, glCompileShaderARB, glCompileShaderARB, NULL, _gloffset_CompileShaderARB),
+    NAME_FUNC_OFFSET(17460, glGetActiveUniformARB, glGetActiveUniformARB, NULL, _gloffset_GetActiveUniformARB),
+    NAME_FUNC_OFFSET(17479, glGetShaderSourceARB, glGetShaderSourceARB, NULL, _gloffset_GetShaderSourceARB),
+    NAME_FUNC_OFFSET(17497, glGetUniformLocationARB, glGetUniformLocationARB, NULL, _gloffset_GetUniformLocationARB),
+    NAME_FUNC_OFFSET(17518, glGetUniformfvARB, glGetUniformfvARB, NULL, _gloffset_GetUniformfvARB),
+    NAME_FUNC_OFFSET(17533, glGetUniformivARB, glGetUniformivARB, NULL, _gloffset_GetUniformivARB),
+    NAME_FUNC_OFFSET(17548, glLinkProgramARB, glLinkProgramARB, NULL, _gloffset_LinkProgramARB),
+    NAME_FUNC_OFFSET(17562, glShaderSourceARB, glShaderSourceARB, NULL, _gloffset_ShaderSourceARB),
+    NAME_FUNC_OFFSET(17577, glUniform1fARB, glUniform1fARB, NULL, _gloffset_Uniform1fARB),
+    NAME_FUNC_OFFSET(17589, glUniform1fvARB, glUniform1fvARB, NULL, _gloffset_Uniform1fvARB),
+    NAME_FUNC_OFFSET(17602, glUniform1iARB, glUniform1iARB, NULL, _gloffset_Uniform1iARB),
+    NAME_FUNC_OFFSET(17614, glUniform1ivARB, glUniform1ivARB, NULL, _gloffset_Uniform1ivARB),
+    NAME_FUNC_OFFSET(17627, glUniform2fARB, glUniform2fARB, NULL, _gloffset_Uniform2fARB),
+    NAME_FUNC_OFFSET(17639, glUniform2fvARB, glUniform2fvARB, NULL, _gloffset_Uniform2fvARB),
+    NAME_FUNC_OFFSET(17652, glUniform2iARB, glUniform2iARB, NULL, _gloffset_Uniform2iARB),
+    NAME_FUNC_OFFSET(17664, glUniform2ivARB, glUniform2ivARB, NULL, _gloffset_Uniform2ivARB),
+    NAME_FUNC_OFFSET(17677, glUniform3fARB, glUniform3fARB, NULL, _gloffset_Uniform3fARB),
+    NAME_FUNC_OFFSET(17689, glUniform3fvARB, glUniform3fvARB, NULL, _gloffset_Uniform3fvARB),
+    NAME_FUNC_OFFSET(17702, glUniform3iARB, glUniform3iARB, NULL, _gloffset_Uniform3iARB),
+    NAME_FUNC_OFFSET(17714, glUniform3ivARB, glUniform3ivARB, NULL, _gloffset_Uniform3ivARB),
+    NAME_FUNC_OFFSET(17727, glUniform4fARB, glUniform4fARB, NULL, _gloffset_Uniform4fARB),
+    NAME_FUNC_OFFSET(17739, glUniform4fvARB, glUniform4fvARB, NULL, _gloffset_Uniform4fvARB),
+    NAME_FUNC_OFFSET(17752, glUniform4iARB, glUniform4iARB, NULL, _gloffset_Uniform4iARB),
+    NAME_FUNC_OFFSET(17764, glUniform4ivARB, glUniform4ivARB, NULL, _gloffset_Uniform4ivARB),
+    NAME_FUNC_OFFSET(17777, glUniformMatrix2fvARB, glUniformMatrix2fvARB, NULL, _gloffset_UniformMatrix2fvARB),
+    NAME_FUNC_OFFSET(17796, glUniformMatrix3fvARB, glUniformMatrix3fvARB, NULL, _gloffset_UniformMatrix3fvARB),
+    NAME_FUNC_OFFSET(17815, glUniformMatrix4fvARB, glUniformMatrix4fvARB, NULL, _gloffset_UniformMatrix4fvARB),
+    NAME_FUNC_OFFSET(17834, glUseProgramObjectARB, glUseProgramObjectARB, NULL, _gloffset_UseProgramObjectARB),
+    NAME_FUNC_OFFSET(17847, glValidateProgramARB, glValidateProgramARB, NULL, _gloffset_ValidateProgramARB),
+    NAME_FUNC_OFFSET(17865, glBindAttribLocationARB, glBindAttribLocationARB, NULL, _gloffset_BindAttribLocationARB),
+    NAME_FUNC_OFFSET(17886, glGetActiveAttribARB, glGetActiveAttribARB, NULL, _gloffset_GetActiveAttribARB),
+    NAME_FUNC_OFFSET(17904, glGetAttribLocationARB, glGetAttribLocationARB, NULL, _gloffset_GetAttribLocationARB),
+    NAME_FUNC_OFFSET(17924, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
+    NAME_FUNC_OFFSET(17938, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
+    NAME_FUNC_OFFSET(17955, gl_dispatch_stub_584, gl_dispatch_stub_584, NULL, _gloffset_SampleMaskSGIS),
+    NAME_FUNC_OFFSET(17971, gl_dispatch_stub_585, gl_dispatch_stub_585, NULL, _gloffset_SamplePatternSGIS),
+    NAME_FUNC_OFFSET(17990, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+    NAME_FUNC_OFFSET(18008, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+    NAME_FUNC_OFFSET(18029, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+    NAME_FUNC_OFFSET(18051, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+    NAME_FUNC_OFFSET(18070, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+    NAME_FUNC_OFFSET(18092, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+    NAME_FUNC_OFFSET(18115, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
+    NAME_FUNC_OFFSET(18134, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
+    NAME_FUNC_OFFSET(18154, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
+    NAME_FUNC_OFFSET(18173, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
+    NAME_FUNC_OFFSET(18193, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
+    NAME_FUNC_OFFSET(18212, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
+    NAME_FUNC_OFFSET(18232, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
+    NAME_FUNC_OFFSET(18251, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
+    NAME_FUNC_OFFSET(18271, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
+    NAME_FUNC_OFFSET(18290, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
+    NAME_FUNC_OFFSET(18310, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
+    NAME_FUNC_OFFSET(18330, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
+    NAME_FUNC_OFFSET(18351, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
+    NAME_FUNC_OFFSET(18371, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
+    NAME_FUNC_OFFSET(18392, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
+    NAME_FUNC_OFFSET(18412, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
+    NAME_FUNC_OFFSET(18433, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
+    NAME_FUNC_OFFSET(18457, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
+    NAME_FUNC_OFFSET(18475, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
+    NAME_FUNC_OFFSET(18495, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
+    NAME_FUNC_OFFSET(18513, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
+    NAME_FUNC_OFFSET(18525, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
+    NAME_FUNC_OFFSET(18538, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
+    NAME_FUNC_OFFSET(18550, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
+    NAME_FUNC_OFFSET(18563, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
+    NAME_FUNC_OFFSET(18583, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
+    NAME_FUNC_OFFSET(18607, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
+    NAME_FUNC_OFFSET(18621, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
+    NAME_FUNC_OFFSET(18638, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
+    NAME_FUNC_OFFSET(18653, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
+    NAME_FUNC_OFFSET(18671, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
+    NAME_FUNC_OFFSET(18685, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
+    NAME_FUNC_OFFSET(18702, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
+    NAME_FUNC_OFFSET(18717, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
+    NAME_FUNC_OFFSET(18735, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
+    NAME_FUNC_OFFSET(18749, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
+    NAME_FUNC_OFFSET(18766, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
+    NAME_FUNC_OFFSET(18781, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
+    NAME_FUNC_OFFSET(18799, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
+    NAME_FUNC_OFFSET(18813, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
+    NAME_FUNC_OFFSET(18830, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
+    NAME_FUNC_OFFSET(18845, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
+    NAME_FUNC_OFFSET(18863, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
+    NAME_FUNC_OFFSET(18877, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
+    NAME_FUNC_OFFSET(18894, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
+    NAME_FUNC_OFFSET(18909, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
+    NAME_FUNC_OFFSET(18927, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
+    NAME_FUNC_OFFSET(18941, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
+    NAME_FUNC_OFFSET(18958, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
+    NAME_FUNC_OFFSET(18973, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
+    NAME_FUNC_OFFSET(18991, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
+    NAME_FUNC_OFFSET(19005, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
+    NAME_FUNC_OFFSET(19022, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
+    NAME_FUNC_OFFSET(19037, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
+    NAME_FUNC_OFFSET(19055, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
+    NAME_FUNC_OFFSET(19069, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
+    NAME_FUNC_OFFSET(19086, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
+    NAME_FUNC_OFFSET(19101, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
+    NAME_FUNC_OFFSET(19119, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
+    NAME_FUNC_OFFSET(19136, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
+    NAME_FUNC_OFFSET(19156, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
+    NAME_FUNC_OFFSET(19173, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
+    NAME_FUNC_OFFSET(19199, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
+    NAME_FUNC_OFFSET(19228, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
+    NAME_FUNC_OFFSET(19243, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
+    NAME_FUNC_OFFSET(19261, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
+    NAME_FUNC_OFFSET(19280, gl_dispatch_stub_755, gl_dispatch_stub_755, NULL, _gloffset_DeleteVertexArraysAPPLE),
+    NAME_FUNC_OFFSET(19301, gl_dispatch_stub_757, gl_dispatch_stub_757, NULL, _gloffset_IsVertexArrayAPPLE),
+    NAME_FUNC_OFFSET(19317, gl_dispatch_stub_765, gl_dispatch_stub_765, NULL, _gloffset_BlendEquationSeparateEXT),
+    NAME_FUNC_OFFSET(19341, gl_dispatch_stub_765, gl_dispatch_stub_765, NULL, _gloffset_BlendEquationSeparateEXT),
+    NAME_FUNC_OFFSET(19368, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
+    NAME_FUNC_OFFSET(19386, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
+    NAME_FUNC_OFFSET(19405, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
+    NAME_FUNC_OFFSET(19430, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
+    NAME_FUNC_OFFSET(19451, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
+    NAME_FUNC_OFFSET(19473, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
+    NAME_FUNC_OFFSET(19499, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
+    NAME_FUNC_OFFSET(19522, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
+    NAME_FUNC_OFFSET(19545, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
+    NAME_FUNC_OFFSET(19568, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
+    NAME_FUNC_OFFSET(19586, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
+    NAME_FUNC_OFFSET(19605, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
+    NAME_FUNC_OFFSET(19622, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
+    NAME_FUNC_OFFSET(19660, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
+    NAME_FUNC_OFFSET(19689, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
+    NAME_FUNC_OFFSET(19705, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
+    NAME_FUNC_OFFSET(19722, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
+    NAME_FUNC_OFFSET(19744, gl_dispatch_stub_783, gl_dispatch_stub_783, NULL, _gloffset_BlitFramebufferEXT),
+    NAME_FUNC_OFFSET(19762, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
+    NAME_FUNC_OFFSET(19788, glProvokingVertexEXT, glProvokingVertexEXT, NULL, _gloffset_ProvokingVertexEXT),
     NAME_FUNC_OFFSET(-1, NULL, NULL, NULL, 0)
 };
 
diff --git a/src/mesa/glapi/mesadef.py b/src/mesa/glapi/mesadef.py
index 0f410fc482..342c9cde46 100644
--- a/src/mesa/glapi/mesadef.py
+++ b/src/mesa/glapi/mesadef.py
@@ -155,6 +155,15 @@ def PrintTail():
 	print '\t_mesa_strcmp'
 	print '\t_mesa_test_proxy_teximage'
 	print '\t_mesa_Viewport'
+	print '\t_mesa_meta_CopyColorSubTable'
+	print '\t_mesa_meta_CopyColorTable'
+	print '\t_mesa_meta_CopyConvolutionFilter1D'
+	print '\t_mesa_meta_CopyConvolutionFilter2D'
+	print '\t_mesa_meta_CopyTexImage1D'
+	print '\t_mesa_meta_CopyTexImage2D'
+	print '\t_mesa_meta_CopyTexSubImage1D'
+	print '\t_mesa_meta_CopyTexSubImage2D'
+	print '\t_mesa_meta_CopyTexSubImage3D'
 	print '\t_swrast_Accum'
 	print '\t_swrast_alloc_buffers'
 	print '\t_swrast_Bitmap'
@@ -164,15 +173,6 @@ def PrintTail():
 	print '\t_swrast_Clear'
 	print '\t_swrast_choose_line'
 	print '\t_swrast_choose_triangle'
-	print '\t_swrast_CopyColorSubTable'
-	print '\t_swrast_CopyColorTable'
-	print '\t_swrast_CopyConvolutionFilter1D'
-	print '\t_swrast_CopyConvolutionFilter2D'
-	print '\t_swrast_copy_teximage1d'
-	print '\t_swrast_copy_teximage2d'
-	print '\t_swrast_copy_texsubimage1d'
-	print '\t_swrast_copy_texsubimage2d'
-	print '\t_swrast_copy_texsubimage3d'
 	print '\t_swrast_CreateContext'
 	print '\t_swrast_DestroyContext'
 	print '\t_swrast_InvalidateState'
diff --git a/src/mesa/main/api_noop.c b/src/mesa/main/api_noop.c
index 09ba7e5062..0b669e7e7f 100644
--- a/src/mesa/main/api_noop.c
+++ b/src/mesa/main/api_noop.c
@@ -731,7 +731,7 @@ _mesa_noop_DrawElements(GLenum mode, GLsizei count, GLenum type,
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
 
-   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
       return;
 
    CALL_Begin(GET_DISPATCH(), (mode));
@@ -757,6 +757,43 @@ _mesa_noop_DrawElements(GLenum mode, GLsizei count, GLenum type,
    CALL_End(GET_DISPATCH(), ());
 }
 
+static void GLAPIENTRY
+_mesa_noop_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+				  const GLvoid *indices, GLint basevertex)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint i;
+
+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices,
+				     basevertex ))
+      return;
+
+   CALL_Begin(GET_DISPATCH(), (mode));
+
+   switch (type) {
+   case GL_UNSIGNED_BYTE:
+      for (i = 0 ; i < count ; i++)
+	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] +
+					      basevertex));
+      break;
+   case GL_UNSIGNED_SHORT:
+      for (i = 0 ; i < count ; i++)
+	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] +
+					      basevertex ));
+      break;
+   case GL_UNSIGNED_INT:
+      for (i = 0 ; i < count ; i++)
+	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] +
+					      basevertex ));
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElementsBaseVertex(type)" );
+      break;
+   }
+
+   CALL_End(GET_DISPATCH(), ());
+}
+
 
 static void GLAPIENTRY
 _mesa_noop_DrawRangeElements(GLenum mode,
@@ -768,7 +805,7 @@ _mesa_noop_DrawRangeElements(GLenum mode,
 
    if (_mesa_validate_DrawRangeElements( ctx, mode,
 					 start, end,
-					 count, type, indices ))
+					 count, type, indices, 0 ))
        CALL_DrawElements(GET_DISPATCH(), (mode, count, type, indices));
 }
 
@@ -786,6 +823,40 @@ _mesa_noop_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
    }
 }
 
+static void GLAPIENTRY
+_mesa_noop_DrawRangeElementsBaseVertex(GLenum mode,
+				       GLuint start, GLuint end,
+				       GLsizei count, GLenum type,
+				       const GLvoid *indices, GLint basevertex)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (_mesa_validate_DrawRangeElements( ctx, mode,
+					 start, end,
+					 count, type, indices, basevertex ))
+      CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count, type, indices,
+						   basevertex));
+}
+
+/* GL_EXT_multi_draw_arrays */
+void GLAPIENTRY
+_mesa_noop_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
+				       GLenum type,
+				       const GLvoid **indices,
+				       GLsizei primcount,
+				       const GLint *basevertex)
+{
+   GLsizei i;
+
+   for (i = 0; i < primcount; i++) {
+      if (count[i] > 0) {
+	 CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count[i], type,
+						      indices[i],
+						      basevertex[i]));
+      }
+   }
+}
+
 /*
  * Eval Mesh
  */
@@ -995,6 +1066,9 @@ _mesa_noop_vtxfmt_init( GLvertexformat *vfmt )
    vfmt->DrawElements = _mesa_noop_DrawElements;
    vfmt->DrawRangeElements = _mesa_noop_DrawRangeElements;
    vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
+   vfmt->DrawElementsBaseVertex = _mesa_noop_DrawElementsBaseVertex;
+   vfmt->DrawRangeElementsBaseVertex = _mesa_noop_DrawRangeElementsBaseVertex;
+   vfmt->MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
    vfmt->EvalMesh1 = _mesa_noop_EvalMesh1;
    vfmt->EvalMesh2 = _mesa_noop_EvalMesh2;
 }
diff --git a/src/mesa/main/api_noop.h b/src/mesa/main/api_noop.h
index a7956d00b3..1150984d64 100644
--- a/src/mesa/main/api_noop.h
+++ b/src/mesa/main/api_noop.h
@@ -44,6 +44,13 @@ extern void GLAPIENTRY
 _mesa_noop_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
 			     const GLvoid **indices, GLsizei primcount);
 
+extern void GLAPIENTRY
+_mesa_noop_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
+				       GLenum type,
+				       const GLvoid **indices,
+				       GLsizei primcount,
+				       const GLint *basevertex);
+
 extern void
 _mesa_noop_vtxfmt_init(GLvertexformat *vfmt);
 
diff --git a/src/mesa/main/api_validate.c b/src/mesa/main/api_validate.c
index 2df4f17389..4a1448deee 100644
--- a/src/mesa/main/api_validate.c
+++ b/src/mesa/main/api_validate.c
@@ -29,7 +29,7 @@
 #include "imports.h"
 #include "mtypes.h"
 #include "state.h"
-
+#include "vbo/vbo.h"
 
 
 /**
@@ -52,51 +52,6 @@ index_bytes(GLenum type, GLsizei count)
 
 
 /**
- * Find the max index in the given element/index buffer
- */
-static GLuint
-max_buffer_index(GLcontext *ctx, GLuint count, GLenum type,
-                 const void *indices,
-                 struct gl_buffer_object *elementBuf)
-{
-   const GLubyte *map = NULL;
-   GLuint max = 0;
-   GLuint i;
-
-   if (_mesa_is_bufferobj(elementBuf)) {
-      /* elements are in a user-defined buffer object.  need to map it */
-      map = ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER,
-                                  GL_READ_ONLY, elementBuf);
-      /* Actual address is the sum of pointers */
-      indices = (const GLvoid *) ADD_POINTERS(map, (const GLubyte *) indices);
-   }
-
-   if (type == GL_UNSIGNED_INT) {
-      for (i = 0; i < count; i++)
-         if (((GLuint *) indices)[i] > max)
-            max = ((GLuint *) indices)[i];
-   }
-   else if (type == GL_UNSIGNED_SHORT) {
-      for (i = 0; i < count; i++)
-         if (((GLushort *) indices)[i] > max)
-            max = ((GLushort *) indices)[i];
-   }
-   else {
-      ASSERT(type == GL_UNSIGNED_BYTE);
-      for (i = 0; i < count; i++)
-         if (((GLubyte *) indices)[i] > max)
-            max = ((GLubyte *) indices)[i];
-   }
-
-   if (map) {
-      ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, elementBuf);
-   }
-
-   return max;
-}
-
-
-/**
  * Check if OK to draw arrays/elements.
  */
 static GLboolean
@@ -124,6 +79,40 @@ check_valid_to_render(GLcontext *ctx, const char *function)
    return GL_TRUE;
 }
 
+static GLboolean
+check_index_bounds(GLcontext *ctx, GLsizei count, GLenum type,
+		   const GLvoid *indices, GLint basevertex)
+{
+   struct _mesa_prim prim;
+   struct _mesa_index_buffer ib;
+   GLuint min, max;
+
+   /* Only the X Server needs to do this -- otherwise, accessing outside
+    * array/BO bounds allows application termination.
+    */
+   if (!ctx->Const.CheckArrayBounds)
+      return GL_TRUE;
+
+   memset(&prim, 0, sizeof(prim));
+   prim.count = count;
+
+   memset(&ib, 0, sizeof(ib));
+   ib.type = type;
+   ib.ptr = indices;
+   ib.obj = ctx->Array.ElementArrayBufferObj;
+
+   vbo_get_minmax_index(ctx, &prim, &ib, &min, &max);
+
+   if (min + basevertex < 0 ||
+       max + basevertex > ctx->Array.ArrayObj->_MaxElement) {
+      /* the max element is out of bounds of one or more enabled arrays */
+      _mesa_warning(ctx, "glDrawElements() index=%u is "
+		    "out of bounds (max=%u)", max, ctx->Array.ArrayObj->_MaxElement);
+      return GL_FALSE;
+   }
+
+   return GL_TRUE;
+}
 
 /**
  * Error checking for glDrawElements().  Includes parameter checking
@@ -133,7 +122,7 @@ check_valid_to_render(GLcontext *ctx, const char *function)
 GLboolean
 _mesa_validate_DrawElements(GLcontext *ctx,
 			    GLenum mode, GLsizei count, GLenum type,
-			    const GLvoid *indices)
+			    const GLvoid *indices, GLint basevertex)
 {
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx,  GL_FALSE);
 
@@ -177,17 +166,8 @@ _mesa_validate_DrawElements(GLcontext *ctx,
          return GL_FALSE;
    }
 
-   if (ctx->Const.CheckArrayBounds) {
-      /* find max array index */
-      GLuint max = max_buffer_index(ctx, count, type, indices,
-                                    ctx->Array.ElementArrayBufferObj);
-      if (max >= ctx->Array.ArrayObj->_MaxElement) {
-         /* the max element is out of bounds of one or more enabled arrays */
-         _mesa_warning(ctx, "glDrawElements() index=%u is "
-                       "out of bounds (max=%u)", max, ctx->Array.ArrayObj->_MaxElement);
-         return GL_FALSE;
-      }
-   }
+   if (!check_index_bounds(ctx, count, type, indices, basevertex))
+      return GL_FALSE;
 
    return GL_TRUE;
 }
@@ -202,7 +182,7 @@ GLboolean
 _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
 				 GLuint start, GLuint end,
 				 GLsizei count, GLenum type,
-				 const GLvoid *indices)
+				 const GLvoid *indices, GLint basevertex)
 {
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 
@@ -250,14 +230,8 @@ _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
          return GL_FALSE;
    }
 
-   if (ctx->Const.CheckArrayBounds) {
-      GLuint max = max_buffer_index(ctx, count, type, indices,
-                                    ctx->Array.ElementArrayBufferObj);
-      if (max >= ctx->Array.ArrayObj->_MaxElement) {
-         /* the max element is out of bounds of one or more enabled arrays */
-         return GL_FALSE;
-      }
-   }
+   if (!check_index_bounds(ctx, count, type, indices, basevertex))
+      return GL_FALSE;
 
    return GL_TRUE;
 }
diff --git a/src/mesa/main/api_validate.h b/src/mesa/main/api_validate.h
index 10f0c34e66..1d3ae157d7 100644
--- a/src/mesa/main/api_validate.h
+++ b/src/mesa/main/api_validate.h
@@ -37,13 +37,13 @@ _mesa_validate_DrawArrays(GLcontext *ctx,
 extern GLboolean
 _mesa_validate_DrawElements(GLcontext *ctx,
 			    GLenum mode, GLsizei count, GLenum type,
-			    const GLvoid *indices);
+			    const GLvoid *indices, GLint basevertex);
 
 extern GLboolean
 _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
 				 GLuint start, GLuint end,
 				 GLsizei count, GLenum type,
-				 const GLvoid *indices);
+				 const GLvoid *indices, GLint basevertex);
 
 
 #endif
diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c
index ab99ca1c64..0fb8fa3bba 100644
--- a/src/mesa/main/attrib.c
+++ b/src/mesa/main/attrib.c
@@ -74,6 +74,7 @@ struct gl_enable_attrib
    GLboolean Convolution2D;
    GLboolean Separable2D;
    GLboolean CullFace;
+   GLboolean DepthClamp;
    GLboolean DepthTest;
    GLboolean Dither;
    GLboolean Fog;
@@ -265,6 +266,7 @@ _mesa_PushAttrib(GLbitfield mask)
       attr->Convolution2D = ctx->Pixel.Convolution2DEnabled;
       attr->Separable2D = ctx->Pixel.Separable2DEnabled;
       attr->CullFace = ctx->Polygon.CullFlag;
+      attr->DepthClamp = ctx->Transform.DepthClamp;
       attr->DepthTest = ctx->Depth.Test;
       attr->Dither = ctx->Color.DitherFlag;
       attr->Fog = ctx->Fog.Enabled;
@@ -514,6 +516,8 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable)
                    enable->ColorTable[COLORTABLE_POSTCOLORMATRIX],
                    GL_POST_COLOR_MATRIX_COLOR_TABLE);
    TEST_AND_UPDATE(ctx->Polygon.CullFlag, enable->CullFace, GL_CULL_FACE);
+   TEST_AND_UPDATE(ctx->Transform.DepthClamp, enable->DepthClamp,
+		   GL_DEPTH_CLAMP);
    TEST_AND_UPDATE(ctx->Depth.Test, enable->DepthTest, GL_DEPTH_TEST);
    TEST_AND_UPDATE(ctx->Color.DitherFlag, enable->Dither, GL_DITHER);
    TEST_AND_UPDATE(ctx->Pixel.Convolution1DEnabled, enable->Convolution1D,
@@ -1221,6 +1225,9 @@ _mesa_PopAttrib(void)
                if (xform->RescaleNormals != ctx->Transform.RescaleNormals)
                   _mesa_set_enable(ctx, GL_RESCALE_NORMAL_EXT,
                                    ctx->Transform.RescaleNormals);
+               if (xform->DepthClamp != ctx->Transform.DepthClamp)
+                  _mesa_set_enable(ctx, GL_DEPTH_CLAMP,
+                                   ctx->Transform.DepthClamp);
             }
             break;
          case GL_TEXTURE_BIT:
diff --git a/src/mesa/main/colortab.c b/src/mesa/main/colortab.c
index 5a7de5f209..5447eb18ef 100644
--- a/src/mesa/main/colortab.c
+++ b/src/mesa/main/colortab.c
@@ -31,6 +31,7 @@
 #include "macros.h"
 #include "state.h"
 #include "teximage.h"
+#include "texstate.h"
 
 
 /**
@@ -278,7 +279,7 @@ _mesa_ColorTable( GLenum target, GLenum internalFormat,
    static const GLfloat one[4] = { 1.0, 1.0, 1.0, 1.0 };
    static const GLfloat zero[4] = { 0.0, 0.0, 0.0, 0.0 };
    GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
    struct gl_texture_object *texObj = NULL;
    struct gl_color_table *table = NULL;
    GLboolean proxy = GL_FALSE;
@@ -443,7 +444,7 @@ _mesa_ColorSubTable( GLenum target, GLsizei start,
    static const GLfloat one[4] = { 1.0, 1.0, 1.0, 1.0 };
    static const GLfloat zero[4] = { 0.0, 0.0, 0.0, 0.0 };
    GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
    struct gl_texture_object *texObj = NULL;
    struct gl_color_table *table = NULL;
    const GLfloat *scale = one, *bias = zero;
@@ -542,7 +543,10 @@ _mesa_CopyColorTable(GLenum target, GLenum internalformat,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   /* Select buffer to read from */
+   if (!ctx->ReadBuffer->_ColorReadBuffer) {
+      return;      /* no readbuffer - OK */
+   }
+
    ctx->Driver.CopyColorTable( ctx, target, internalformat, x, y, width );
 }
 
@@ -555,6 +559,10 @@ _mesa_CopyColorSubTable(GLenum target, GLsizei start,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
+   if (!ctx->ReadBuffer->_ColorReadBuffer) {
+      return;      /* no readbuffer - OK */
+   }
+
    ctx->Driver.CopyColorSubTable( ctx, target, start, x, y, width );
 }
 
@@ -565,7 +573,7 @@ _mesa_GetColorTable( GLenum target, GLenum format,
                      GLenum type, GLvoid *data )
 {
    GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
    struct gl_color_table *table = NULL;
    GLfloat rgba[MAX_COLOR_TABLE_SIZE][4];
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
@@ -766,7 +774,7 @@ void GLAPIENTRY
 _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )
 {
    GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
    struct gl_color_table *table = NULL;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
@@ -893,7 +901,7 @@ void GLAPIENTRY
 _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
 {
    GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
    struct gl_color_table *table = NULL;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
diff --git a/src/mesa/main/convolve.c b/src/mesa/main/convolve.c
index 70951112a1..bf6f6619d4 100644
--- a/src/mesa/main/convolve.c
+++ b/src/mesa/main/convolve.c
@@ -482,6 +482,10 @@ _mesa_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat, GLint x, GLi
       return;
    }
 
+   if (!ctx->ReadBuffer->_ColorReadBuffer) {
+      return;      /* no readbuffer - OK */
+   }
+
    ctx->Driver.CopyConvolutionFilter1D( ctx, target, 
 					internalFormat, x, y, width);
 }
@@ -514,6 +518,10 @@ _mesa_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat, GLint x, GLi
       return;
    }
 
+   if (!ctx->ReadBuffer->_ColorReadBuffer) {
+      return;      /* no readbuffer - OK */
+   }
+
    ctx->Driver.CopyConvolutionFilter2D( ctx, target, internalFormat, x, y, 
 					width, height );
 }
diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h
index 4a700b5cb4..ce5e158626 100644
--- a/src/mesa/main/dd.h
+++ b/src/mesa/main/dd.h
@@ -1172,7 +1172,22 @@ typedef struct {
 					    GLenum type,
 					    const GLvoid **indices,
 					    GLsizei primcount);
-  /*@}*/
+   void (GLAPIENTRYP DrawElementsBaseVertex)( GLenum mode, GLsizei count,
+					      GLenum type,
+					      const GLvoid *indices,
+					      GLint basevertex );
+   void (GLAPIENTRYP DrawRangeElementsBaseVertex)( GLenum mode, GLuint start,
+						   GLuint end, GLsizei count,
+						   GLenum type,
+						   const GLvoid *indices,
+						   GLint basevertex);
+   void (GLAPIENTRYP MultiDrawElementsBaseVertex)( GLenum mode,
+						   const GLsizei *count,
+						   GLenum type,
+						   const GLvoid **indices,
+						   GLsizei primcount,
+						   const GLint *basevertex);
+   /*@}*/
 
    /**
     * \name Eval
diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c
index 8cff9ea64a..9c25de4187 100644
--- a/src/mesa/main/dlist.c
+++ b/src/mesa/main/dlist.c
@@ -329,6 +329,34 @@ typedef enum
    OPCODE_STENCIL_OP_SEPARATE,
    OPCODE_STENCIL_MASK_SEPARATE,
 
+   /* GL_ARB_shader_objects */
+   OPCODE_USE_PROGRAM,
+   OPCODE_UNIFORM_1F,
+   OPCODE_UNIFORM_2F,
+   OPCODE_UNIFORM_3F,
+   OPCODE_UNIFORM_4F,
+   OPCODE_UNIFORM_1FV,
+   OPCODE_UNIFORM_2FV,
+   OPCODE_UNIFORM_3FV,
+   OPCODE_UNIFORM_4FV,
+   OPCODE_UNIFORM_1I,
+   OPCODE_UNIFORM_2I,
+   OPCODE_UNIFORM_3I,
+   OPCODE_UNIFORM_4I,
+   OPCODE_UNIFORM_1IV,
+   OPCODE_UNIFORM_2IV,
+   OPCODE_UNIFORM_3IV,
+   OPCODE_UNIFORM_4IV,
+   OPCODE_UNIFORM_MATRIX22,
+   OPCODE_UNIFORM_MATRIX33,
+   OPCODE_UNIFORM_MATRIX44,
+   OPCODE_UNIFORM_MATRIX23,
+   OPCODE_UNIFORM_MATRIX32,
+   OPCODE_UNIFORM_MATRIX24,
+   OPCODE_UNIFORM_MATRIX42,
+   OPCODE_UNIFORM_MATRIX34,
+   OPCODE_UNIFORM_MATRIX43,
+
    /* GL_EXT_framebuffer_blit */
    OPCODE_BLIT_FRAMEBUFFER,
 
@@ -576,6 +604,30 @@ _mesa_delete_list(GLcontext *ctx, struct gl_display_list *dlist)
             n += InstSize[n[0].opcode];
             break;
 #endif
+         case OPCODE_UNIFORM_1FV:
+         case OPCODE_UNIFORM_2FV:
+         case OPCODE_UNIFORM_3FV:
+         case OPCODE_UNIFORM_4FV:
+         case OPCODE_UNIFORM_1IV:
+         case OPCODE_UNIFORM_2IV:
+         case OPCODE_UNIFORM_3IV:
+         case OPCODE_UNIFORM_4IV:
+            _mesa_free(n[3].data);
+            n += InstSize[n[0].opcode];
+            break;
+         case OPCODE_UNIFORM_MATRIX22:
+         case OPCODE_UNIFORM_MATRIX33:
+         case OPCODE_UNIFORM_MATRIX44:
+         case OPCODE_UNIFORM_MATRIX24:
+         case OPCODE_UNIFORM_MATRIX42:
+         case OPCODE_UNIFORM_MATRIX23:
+         case OPCODE_UNIFORM_MATRIX32:
+         case OPCODE_UNIFORM_MATRIX34:
+         case OPCODE_UNIFORM_MATRIX43:
+            _mesa_free(n[4].data);
+            n += InstSize[n[0].opcode];
+            break;
+
          case OPCODE_CONTINUE:
             n = (Node *) n[1].next;
             _mesa_free(block);
@@ -5804,6 +5856,493 @@ save_ProvokingVertexEXT(GLenum mode)
 }
 
 
+/* aka UseProgram() */
+static void GLAPIENTRY
+save_UseProgramObjectARB(GLhandleARB program)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_USE_PROGRAM, 1);
+   if (n) {
+      n[1].ui = program;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UseProgramObjectARB(ctx->Exec, (program));
+   }
+}
+
+
+static void GLAPIENTRY
+save_Uniform1fARB(GLint location, GLfloat x)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_1F, 2);
+   if (n) {
+      n[1].i = location;
+      n[2].f = x;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform1fARB(ctx->Exec, (location, x));
+   }
+}
+
+
+static void GLAPIENTRY
+save_Uniform2fARB(GLint location, GLfloat x, GLfloat y)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_2F, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].f = x;
+      n[3].f = y;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform2fARB(ctx->Exec, (location, x, y));
+   }
+}
+
+
+static void GLAPIENTRY
+save_Uniform3fARB(GLint location, GLfloat x, GLfloat y, GLfloat z)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_3F, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].f = x;
+      n[3].f = y;
+      n[4].f = z;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform3fARB(ctx->Exec, (location, x, y, z));
+   }
+}
+
+
+static void GLAPIENTRY
+save_Uniform4fARB(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_4F, 5);
+   if (n) {
+      n[1].i = location;
+      n[2].f = x;
+      n[3].f = y;
+      n[4].f = z;
+      n[5].f = w;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform4fARB(ctx->Exec, (location, x, y, z, w));
+   }
+}
+
+
+/** Return copy of memory */
+static void *
+memdup(const void *src, GLsizei bytes)
+{
+   void *b = bytes >= 0 ? _mesa_malloc(bytes) : NULL;
+   if (b)
+      _mesa_memcpy(b, src, bytes);
+   return b;
+}
+
+
+static void GLAPIENTRY
+save_Uniform1fvARB(GLint location, GLsizei count, const GLfloat *v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_1FV, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].data = memdup(v, count * 1 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform1fvARB(ctx->Exec, (location, count, v));
+   }
+}
+
+static void GLAPIENTRY
+save_Uniform2fvARB(GLint location, GLsizei count, const GLfloat *v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_2FV, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].data = memdup(v, count * 2 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform2fvARB(ctx->Exec, (location, count, v));
+   }
+}
+
+static void GLAPIENTRY
+save_Uniform3fvARB(GLint location, GLsizei count, const GLfloat *v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_3FV, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].data = memdup(v, count * 3 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform3fvARB(ctx->Exec, (location, count, v));
+   }
+}
+
+static void GLAPIENTRY
+save_Uniform4fvARB(GLint location, GLsizei count, const GLfloat *v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_4FV, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].data = memdup(v, count * 4 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform4fvARB(ctx->Exec, (location, count, v));
+   }
+}
+
+
+static void GLAPIENTRY
+save_Uniform1iARB(GLint location, GLint x)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_1I, 2);
+   if (n) {
+      n[1].i = location;
+      n[2].i = x;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform1iARB(ctx->Exec, (location, x));
+   }
+}
+
+static void GLAPIENTRY
+save_Uniform2iARB(GLint location, GLint x, GLint y)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_2I, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].i = x;
+      n[3].i = y;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform2iARB(ctx->Exec, (location, x, y));
+   }
+}
+
+static void GLAPIENTRY
+save_Uniform3iARB(GLint location, GLint x, GLint y, GLint z)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_3I, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = x;
+      n[3].i = y;
+      n[4].i = z;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform3iARB(ctx->Exec, (location, x, y, z));
+   }
+}
+
+static void GLAPIENTRY
+save_Uniform4iARB(GLint location, GLint x, GLint y, GLint z, GLint w)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_4I, 5);
+   if (n) {
+      n[1].i = location;
+      n[2].i = x;
+      n[3].i = y;
+      n[4].i = z;
+      n[5].i = w;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform4iARB(ctx->Exec, (location, x, y, z, w));
+   }
+}
+
+
+
+static void GLAPIENTRY
+save_Uniform1ivARB(GLint location, GLsizei count, const GLint *v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_1IV, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].data = memdup(v, count * 1 * sizeof(GLint));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform1ivARB(ctx->Exec, (location, count, v));
+   }
+}
+
+static void GLAPIENTRY
+save_Uniform2ivARB(GLint location, GLsizei count, const GLint *v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_2IV, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].data = memdup(v, count * 2 * sizeof(GLint));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform2ivARB(ctx->Exec, (location, count, v));
+   }
+}
+
+static void GLAPIENTRY
+save_Uniform3ivARB(GLint location, GLsizei count, const GLint *v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_3IV, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].data = memdup(v, count * 3 * sizeof(GLint));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform3ivARB(ctx->Exec, (location, count, v));
+   }
+}
+
+static void GLAPIENTRY
+save_Uniform4ivARB(GLint location, GLsizei count, const GLint *v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_4IV, 3);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].data = memdup(v, count * 4 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_Uniform4ivARB(ctx->Exec, (location, count, v));
+   }
+}
+
+
+static void GLAPIENTRY
+save_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
+                         const GLfloat *m)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_MATRIX22, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].b = transpose;
+      n[4].data = memdup(m, count * 2 * 2 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UniformMatrix2fvARB(ctx->Exec, (location, count, transpose, m));
+   }
+}
+
+static void GLAPIENTRY
+save_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
+                         const GLfloat *m)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_MATRIX33, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].b = transpose;
+      n[4].data = memdup(m, count * 3 * 3 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UniformMatrix3fvARB(ctx->Exec, (location, count, transpose, m));
+   }
+}
+
+static void GLAPIENTRY
+save_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
+                         const GLfloat *m)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_MATRIX44, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].b = transpose;
+      n[4].data = memdup(m, count * 4 * 4 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UniformMatrix4fvARB(ctx->Exec, (location, count, transpose, m));
+   }
+}
+
+
+static void GLAPIENTRY
+save_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
+                        const GLfloat *m)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_MATRIX23, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].b = transpose;
+      n[4].data = memdup(m, count * 2 * 3 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UniformMatrix2x3fv(ctx->Exec, (location, count, transpose, m));
+   }
+}
+
+static void GLAPIENTRY
+save_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
+                        const GLfloat *m)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_MATRIX32, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].b = transpose;
+      n[4].data = memdup(m, count * 3 * 2 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UniformMatrix3x2fv(ctx->Exec, (location, count, transpose, m));
+   }
+}
+
+
+static void GLAPIENTRY
+save_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
+                        const GLfloat *m)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_MATRIX24, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].b = transpose;
+      n[4].data = memdup(m, count * 2 * 4 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UniformMatrix2x4fv(ctx->Exec, (location, count, transpose, m));
+   }
+}
+
+static void GLAPIENTRY
+save_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
+                        const GLfloat *m)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_MATRIX42, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].b = transpose;
+      n[4].data = memdup(m, count * 4 * 2 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UniformMatrix4x2fv(ctx->Exec, (location, count, transpose, m));
+   }
+}
+
+
+static void GLAPIENTRY
+save_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
+                        const GLfloat *m)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_MATRIX34, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].b = transpose;
+      n[4].data = memdup(m, count * 3 * 4 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UniformMatrix3x4fv(ctx->Exec, (location, count, transpose, m));
+   }
+}
+
+static void GLAPIENTRY
+save_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
+                        const GLfloat *m)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_UNIFORM_MATRIX43, 4);
+   if (n) {
+      n[1].i = location;
+      n[2].i = count;
+      n[3].b = transpose;
+      n[4].data = memdup(m, count * 4 * 3 * sizeof(GLfloat));
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_UniformMatrix4x3fv(ctx->Exec, (location, count, transpose, m));
+   }
+}
+
+
 
 /**
  * Save an error-generating command into display list.
@@ -6640,6 +7179,98 @@ execute_list(GLcontext *ctx, GLuint list)
                                                 n[9].i, n[10].e));
 	    break;
 #endif
+
+	 case OPCODE_USE_PROGRAM:
+	    CALL_UseProgramObjectARB(ctx->Exec, (n[1].ui));
+	    break;
+	 case OPCODE_UNIFORM_1F:
+	    CALL_Uniform1fARB(ctx->Exec, (n[1].i, n[2].f));
+	    break;
+	 case OPCODE_UNIFORM_2F:
+	    CALL_Uniform2fARB(ctx->Exec, (n[1].i, n[2].f, n[3].f));
+	    break;
+	 case OPCODE_UNIFORM_3F:
+	    CALL_Uniform3fARB(ctx->Exec, (n[1].i, n[2].f, n[3].f, n[4].f));
+	    break;
+	 case OPCODE_UNIFORM_4F:
+	    CALL_Uniform4fARB(ctx->Exec,
+                              (n[1].i, n[2].f, n[3].f, n[4].f, n[5].f));
+	    break;
+	 case OPCODE_UNIFORM_1FV:
+	    CALL_Uniform1fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
+	    break;
+	 case OPCODE_UNIFORM_2FV:
+	    CALL_Uniform2fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
+	    break;
+	 case OPCODE_UNIFORM_3FV:
+	    CALL_Uniform3fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
+	    break;
+	 case OPCODE_UNIFORM_4FV:
+	    CALL_Uniform4fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
+	    break;
+	 case OPCODE_UNIFORM_1I:
+	    CALL_Uniform1iARB(ctx->Exec, (n[1].i, n[2].i));
+	    break;
+	 case OPCODE_UNIFORM_2I:
+	    CALL_Uniform2iARB(ctx->Exec, (n[1].i, n[2].i, n[3].i));
+	    break;
+	 case OPCODE_UNIFORM_3I:
+	    CALL_Uniform3iARB(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
+	    break;
+	 case OPCODE_UNIFORM_4I:
+	    CALL_Uniform4iARB(ctx->Exec,
+                              (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i));
+	    break;
+	 case OPCODE_UNIFORM_1IV:
+	    CALL_Uniform1ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
+	    break;
+	 case OPCODE_UNIFORM_2IV:
+	    CALL_Uniform2ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
+	    break;
+	 case OPCODE_UNIFORM_3IV:
+	    CALL_Uniform3ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
+	    break;
+	 case OPCODE_UNIFORM_4IV:
+	    CALL_Uniform4ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
+	    break;
+
+	 case OPCODE_UNIFORM_MATRIX22:
+	    CALL_UniformMatrix2fvARB(ctx->Exec,
+                                     (n[1].i, n[2].i, n[3].b, n[4].data));
+	    break;
+	 case OPCODE_UNIFORM_MATRIX33:
+	    CALL_UniformMatrix3fvARB(ctx->Exec,
+                                     (n[1].i, n[2].i, n[3].b, n[4].data));
+	    break;
+	 case OPCODE_UNIFORM_MATRIX44:
+	    CALL_UniformMatrix4fvARB(ctx->Exec,
+                                     (n[1].i, n[2].i, n[3].b, n[4].data));
+	    break;
+	 case OPCODE_UNIFORM_MATRIX23:
+	    CALL_UniformMatrix2x3fv(ctx->Exec,
+                                    (n[1].i, n[2].i, n[3].b, n[4].data));
+	    break;
+	 case OPCODE_UNIFORM_MATRIX32:
+	    CALL_UniformMatrix3x2fv(ctx->Exec,
+                                    (n[1].i, n[2].i, n[3].b, n[4].data));
+	    break;
+	 case OPCODE_UNIFORM_MATRIX24:
+	    CALL_UniformMatrix2x4fv(ctx->Exec,
+                                    (n[1].i, n[2].i, n[3].b, n[4].data));
+	    break;
+	 case OPCODE_UNIFORM_MATRIX42:
+	    CALL_UniformMatrix4x2fv(ctx->Exec,
+                                    (n[1].i, n[2].i, n[3].b, n[4].data));
+	    break;
+	 case OPCODE_UNIFORM_MATRIX34:
+	    CALL_UniformMatrix3x4fv(ctx->Exec,
+                                    (n[1].i, n[2].i, n[3].b, n[4].data));
+	    break;
+	 case OPCODE_UNIFORM_MATRIX43:
+	    CALL_UniformMatrix4x3fv(ctx->Exec,
+                                    (n[1].i, n[2].i, n[3].b, n[4].data));
+	    break;
+
          case OPCODE_TEX_BUMP_PARAMETER_ATI:
             {
                GLfloat values[4];
@@ -8309,6 +8940,34 @@ _mesa_init_dlist_table(struct _glapi_table *table)
    SET_BlitFramebufferEXT(table, save_BlitFramebufferEXT);
 #endif
 
+   /* GL_ARB_shader_objects */
+   SET_UseProgramObjectARB(table, save_UseProgramObjectARB);
+   SET_Uniform1fARB(table, save_Uniform1fARB);
+   SET_Uniform2fARB(table, save_Uniform2fARB);
+   SET_Uniform3fARB(table, save_Uniform3fARB);
+   SET_Uniform4fARB(table, save_Uniform4fARB);
+   SET_Uniform1fvARB(table, save_Uniform1fvARB);
+   SET_Uniform2fvARB(table, save_Uniform2fvARB);
+   SET_Uniform3fvARB(table, save_Uniform3fvARB);
+   SET_Uniform4fvARB(table, save_Uniform4fvARB);
+   SET_Uniform1iARB(table, save_Uniform1iARB);
+   SET_Uniform2iARB(table, save_Uniform2iARB);
+   SET_Uniform3iARB(table, save_Uniform3iARB);
+   SET_Uniform4iARB(table, save_Uniform4iARB);
+   SET_Uniform1ivARB(table, save_Uniform1ivARB);
+   SET_Uniform2ivARB(table, save_Uniform2ivARB);
+   SET_Uniform3ivARB(table, save_Uniform3ivARB);
+   SET_Uniform4ivARB(table, save_Uniform4ivARB);
+   SET_UniformMatrix2fvARB(table, save_UniformMatrix2fvARB);
+   SET_UniformMatrix3fvARB(table, save_UniformMatrix3fvARB);
+   SET_UniformMatrix4fvARB(table, save_UniformMatrix4fvARB);
+   SET_UniformMatrix2x3fv(table, save_UniformMatrix2x3fv);
+   SET_UniformMatrix3x2fv(table, save_UniformMatrix3x2fv);
+   SET_UniformMatrix2x4fv(table, save_UniformMatrix2x4fv);
+   SET_UniformMatrix4x2fv(table, save_UniformMatrix4x2fv);
+   SET_UniformMatrix3x4fv(table, save_UniformMatrix3x4fv);
+   SET_UniformMatrix4x3fv(table, save_UniformMatrix4x3fv);
+
    /* ARB 30/31/32. GL_ARB_shader_objects, GL_ARB_vertex/fragment_shader */
    SET_BindAttribLocationARB(table, exec_BindAttribLocationARB);
    SET_GetAttribLocationARB(table, exec_GetAttribLocationARB);
@@ -8711,6 +9370,9 @@ _mesa_save_vtxfmt_init(GLvertexformat * vfmt)
    vfmt->DrawElements = 0;
    vfmt->DrawRangeElements = 0;
    vfmt->MultiDrawElemementsEXT = 0;
+   vfmt->DrawElementsBaseVertex = 0;
+   vfmt->DrawRangeElementsBaseVertex = 0;
+   vfmt->MultiDrawElemementsBaseVertex = 0;
 #endif
 }
 
diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c
index 4bc54771e9..4c1f46102d 100644
--- a/src/mesa/main/enable.c
+++ b/src/mesa/main/enable.c
@@ -36,7 +36,6 @@
 #include "simple_list.h"
 #include "mtypes.h"
 #include "enums.h"
-#include "math/m_matrix.h"
 #include "api_arrayelt.h"
 
 
@@ -947,6 +946,14 @@ _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state)
          ctx->Depth.BoundsTest = state;
          break;
 
+      case GL_DEPTH_CLAMP:
+         if (ctx->Transform.DepthClamp == state)
+            return;
+	 CHECK_EXTENSION(ARB_depth_clamp, cap);
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+	 ctx->Transform.DepthClamp = state;
+	 break;
+
 #if FEATURE_ATI_fragment_shader
       case GL_FRAGMENT_SHADER_ATI:
         CHECK_EXTENSION(ATI_fragment_shader, cap);
@@ -1395,6 +1402,11 @@ _mesa_IsEnabled( GLenum cap )
          CHECK_EXTENSION(EXT_depth_bounds_test);
          return ctx->Depth.BoundsTest;
 
+      /* GL_ARB_depth_clamp */
+      case GL_DEPTH_CLAMP:
+         CHECK_EXTENSION(ARB_depth_clamp);
+         return ctx->Transform.DepthClamp;
+
 #if FEATURE_ATI_fragment_shader
       case GL_FRAGMENT_SHADER_ATI:
 	 CHECK_EXTENSION(ATI_fragment_shader);
diff --git a/src/mesa/main/enums.c b/src/mesa/main/enums.c
index 9f650dadd3..606d50c59a 100644
--- a/src/mesa/main/enums.c
+++ b/src/mesa/main/enums.c
@@ -391,6 +391,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_DEPTH_BOUNDS_EXT\0"
    "GL_DEPTH_BOUNDS_TEST_EXT\0"
    "GL_DEPTH_BUFFER_BIT\0"
+   "GL_DEPTH_CLAMP\0"
    "GL_DEPTH_CLAMP_NV\0"
    "GL_DEPTH_CLEAR_VALUE\0"
    "GL_DEPTH_COMPONENT\0"
@@ -518,6 +519,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_FEEDBACK_BUFFER_SIZE\0"
    "GL_FEEDBACK_BUFFER_TYPE\0"
    "GL_FILL\0"
+   "GL_FIRST_VERTEX_CONVENTION\0"
    "GL_FIRST_VERTEX_CONVENTION_EXT\0"
    "GL_FLAT\0"
    "GL_FLOAT\0"
@@ -701,6 +703,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_INVERSE_TRANSPOSE_NV\0"
    "GL_INVERT\0"
    "GL_KEEP\0"
+   "GL_LAST_VERTEX_CONVENTION\0"
    "GL_LAST_VERTEX_CONVENTION_EXT\0"
    "GL_LEFT\0"
    "GL_LEQUAL\0"
@@ -1287,6 +1290,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_PROJECTION\0"
    "GL_PROJECTION_MATRIX\0"
    "GL_PROJECTION_STACK_DEPTH\0"
+   "GL_PROVOKING_VERTEX\0"
    "GL_PROVOKING_VERTEX_EXT\0"
    "GL_PROXY_COLOR_TABLE\0"
    "GL_PROXY_HISTOGRAM\0"
@@ -1308,6 +1312,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_Q\0"
    "GL_QUADRATIC_ATTENUATION\0"
    "GL_QUADS\0"
+   "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION\0"
    "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT\0"
    "GL_QUAD_MESH_SUN\0"
    "GL_QUAD_STRIP\0"
@@ -1895,7 +1900,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_ZOOM_Y\0"
    ;
 
-static const enum_elt all_enums[1857] =
+static const enum_elt all_enums[1862] =
 {
    {     0, 0x00000600 }, /* GL_2D */
    {     6, 0x00001407 }, /* GL_2_BYTES */
@@ -2252,1588 +2257,1593 @@ static const enum_elt all_enums[1857] =
    {  7262, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */
    {  7282, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */
    {  7307, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */
-   {  7327, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */
-   {  7345, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */
-   {  7366, 0x00001902 }, /* GL_DEPTH_COMPONENT */
-   {  7385, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */
-   {  7406, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */
-   {  7431, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */
-   {  7457, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */
-   {  7478, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */
-   {  7503, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */
-   {  7529, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */
-   {  7550, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */
-   {  7575, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */
-   {  7601, 0x00000B74 }, /* GL_DEPTH_FUNC */
-   {  7615, 0x00000B70 }, /* GL_DEPTH_RANGE */
-   {  7630, 0x00000D1E }, /* GL_DEPTH_SCALE */
-   {  7645, 0x000084F9 }, /* GL_DEPTH_STENCIL */
-   {  7662, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */
-   {  7690, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */
-   {  7710, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
-   {  7738, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
-   {  7766, 0x00000B71 }, /* GL_DEPTH_TEST */
-   {  7780, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */
-   {  7802, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */
-   {  7828, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */
-   {  7847, 0x00001201 }, /* GL_DIFFUSE */
-   {  7858, 0x00000BD0 }, /* GL_DITHER */
-   {  7868, 0x00000A02 }, /* GL_DOMAIN */
-   {  7878, 0x00001100 }, /* GL_DONT_CARE */
-   {  7891, 0x000086AE }, /* GL_DOT3_RGB */
-   {  7903, 0x000086AF }, /* GL_DOT3_RGBA */
-   {  7916, 0x000086AF }, /* GL_DOT3_RGBA_ARB */
-   {  7933, 0x00008741 }, /* GL_DOT3_RGBA_EXT */
-   {  7950, 0x000086AE }, /* GL_DOT3_RGB_ARB */
-   {  7966, 0x00008740 }, /* GL_DOT3_RGB_EXT */
-   {  7982, 0x0000140A }, /* GL_DOUBLE */
-   {  7992, 0x00000C32 }, /* GL_DOUBLEBUFFER */
-   {  8008, 0x00000C01 }, /* GL_DRAW_BUFFER */
-   {  8023, 0x00008825 }, /* GL_DRAW_BUFFER0 */
-   {  8039, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */
-   {  8059, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */
-   {  8079, 0x00008826 }, /* GL_DRAW_BUFFER1 */
-   {  8095, 0x0000882F }, /* GL_DRAW_BUFFER10 */
-   {  8112, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */
-   {  8133, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */
-   {  8154, 0x00008830 }, /* GL_DRAW_BUFFER11 */
-   {  8171, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */
-   {  8192, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */
-   {  8213, 0x00008831 }, /* GL_DRAW_BUFFER12 */
-   {  8230, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */
-   {  8251, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */
-   {  8272, 0x00008832 }, /* GL_DRAW_BUFFER13 */
-   {  8289, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */
-   {  8310, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */
-   {  8331, 0x00008833 }, /* GL_DRAW_BUFFER14 */
-   {  8348, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */
-   {  8369, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */
-   {  8390, 0x00008834 }, /* GL_DRAW_BUFFER15 */
-   {  8407, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */
-   {  8428, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */
-   {  8449, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */
-   {  8469, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */
-   {  8489, 0x00008827 }, /* GL_DRAW_BUFFER2 */
-   {  8505, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */
-   {  8525, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */
-   {  8545, 0x00008828 }, /* GL_DRAW_BUFFER3 */
-   {  8561, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */
-   {  8581, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */
-   {  8601, 0x00008829 }, /* GL_DRAW_BUFFER4 */
-   {  8617, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */
-   {  8637, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */
-   {  8657, 0x0000882A }, /* GL_DRAW_BUFFER5 */
-   {  8673, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */
-   {  8693, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */
-   {  8713, 0x0000882B }, /* GL_DRAW_BUFFER6 */
-   {  8729, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */
-   {  8749, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */
-   {  8769, 0x0000882C }, /* GL_DRAW_BUFFER7 */
-   {  8785, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */
-   {  8805, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */
-   {  8825, 0x0000882D }, /* GL_DRAW_BUFFER8 */
-   {  8841, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */
-   {  8861, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */
-   {  8881, 0x0000882E }, /* GL_DRAW_BUFFER9 */
-   {  8897, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */
-   {  8917, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */
-   {  8937, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */
-   {  8957, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
-   {  8989, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */
-   {  9013, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */
-   {  9033, 0x00000304 }, /* GL_DST_ALPHA */
-   {  9046, 0x00000306 }, /* GL_DST_COLOR */
-   {  9059, 0x0000877A }, /* GL_DU8DV8_ATI */
-   {  9073, 0x00008779 }, /* GL_DUDV_ATI */
-   {  9085, 0x000088EA }, /* GL_DYNAMIC_COPY */
-   {  9101, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */
-   {  9121, 0x000088E8 }, /* GL_DYNAMIC_DRAW */
-   {  9137, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */
-   {  9157, 0x000088E9 }, /* GL_DYNAMIC_READ */
-   {  9173, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */
-   {  9193, 0x00000B43 }, /* GL_EDGE_FLAG */
-   {  9206, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */
-   {  9225, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-   {  9259, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */
-   {  9297, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */
-   {  9324, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-   {  9350, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */
-   {  9374, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-   {  9406, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */
-   {  9442, 0x00001600 }, /* GL_EMISSION */
-   {  9454, 0x00002000 }, /* GL_ENABLE_BIT */
-   {  9468, 0x00000202 }, /* GL_EQUAL */
-   {  9477, 0x00001509 }, /* GL_EQUIV */
-   {  9486, 0x00010000 }, /* GL_EVAL_BIT */
-   {  9498, 0x00000800 }, /* GL_EXP */
-   {  9505, 0x00000801 }, /* GL_EXP2 */
-   {  9513, 0x00001F03 }, /* GL_EXTENSIONS */
-   {  9527, 0x00002400 }, /* GL_EYE_LINEAR */
-   {  9541, 0x00002502 }, /* GL_EYE_PLANE */
-   {  9554, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */
-   {  9579, 0x0000855B }, /* GL_EYE_RADIAL_NV */
-   {  9596, 0x00000000 }, /* GL_FALSE */
-   {  9605, 0x00001101 }, /* GL_FASTEST */
-   {  9616, 0x00001C01 }, /* GL_FEEDBACK */
-   {  9628, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */
-   {  9655, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */
-   {  9679, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */
-   {  9703, 0x00001B02 }, /* GL_FILL */
-   {  9711, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION_EXT */
-   {  9742, 0x00001D00 }, /* GL_FLAT */
-   {  9750, 0x00001406 }, /* GL_FLOAT */
-   {  9759, 0x00008B5A }, /* GL_FLOAT_MAT2 */
-   {  9773, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */
-   {  9791, 0x00008B65 }, /* GL_FLOAT_MAT2x3 */
-   {  9807, 0x00008B66 }, /* GL_FLOAT_MAT2x4 */
-   {  9823, 0x00008B5B }, /* GL_FLOAT_MAT3 */
-   {  9837, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */
-   {  9855, 0x00008B67 }, /* GL_FLOAT_MAT3x2 */
-   {  9871, 0x00008B68 }, /* GL_FLOAT_MAT3x4 */
-   {  9887, 0x00008B5C }, /* GL_FLOAT_MAT4 */
-   {  9901, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */
-   {  9919, 0x00008B69 }, /* GL_FLOAT_MAT4x2 */
-   {  9935, 0x00008B6A }, /* GL_FLOAT_MAT4x3 */
-   {  9951, 0x00008B50 }, /* GL_FLOAT_VEC2 */
-   {  9965, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */
-   {  9983, 0x00008B51 }, /* GL_FLOAT_VEC3 */
-   {  9997, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */
-   { 10015, 0x00008B52 }, /* GL_FLOAT_VEC4 */
-   { 10029, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */
-   { 10047, 0x00000B60 }, /* GL_FOG */
-   { 10054, 0x00000080 }, /* GL_FOG_BIT */
-   { 10065, 0x00000B66 }, /* GL_FOG_COLOR */
-   { 10078, 0x00008451 }, /* GL_FOG_COORD */
-   { 10091, 0x00008451 }, /* GL_FOG_COORDINATE */
-   { 10109, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */
-   { 10133, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-   { 10172, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */
-   { 10215, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */
-   { 10247, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
-   { 10278, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */
-   { 10307, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */
-   { 10332, 0x00008457 }, /* GL_FOG_COORD_ARRAY */
-   { 10351, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */
-   { 10385, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */
-   { 10412, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */
-   { 10438, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */
-   { 10462, 0x00008450 }, /* GL_FOG_COORD_SRC */
-   { 10479, 0x00000B62 }, /* GL_FOG_DENSITY */
-   { 10494, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */
-   { 10518, 0x00000B64 }, /* GL_FOG_END */
-   { 10529, 0x00000C54 }, /* GL_FOG_HINT */
-   { 10541, 0x00000B61 }, /* GL_FOG_INDEX */
-   { 10554, 0x00000B65 }, /* GL_FOG_MODE */
-   { 10566, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */
-   { 10585, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */
-   { 10610, 0x00000B63 }, /* GL_FOG_START */
-   { 10623, 0x00008452 }, /* GL_FRAGMENT_DEPTH */
-   { 10641, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */
-   { 10665, 0x00008B30 }, /* GL_FRAGMENT_SHADER */
-   { 10684, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */
-   { 10707, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
-   { 10742, 0x00008D40 }, /* GL_FRAMEBUFFER */
-   { 10757, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
-   { 10794, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
-   { 10830, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
-   { 10871, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
-   { 10912, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
-   { 10949, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
-   { 10986, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
-   { 11024, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
-   { 11066, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
-   { 11104, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
-   { 11146, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
-   { 11181, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
-   { 11220, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
-   { 11269, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
-   { 11317, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
-   { 11369, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
-   { 11409, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
-   { 11453, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
-   { 11493, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
-   { 11537, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */
-   { 11564, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */
-   { 11588, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */
-   { 11616, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */
-   { 11639, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */
-   { 11658, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
-   { 11695, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
-   { 11736, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
-   { 11777, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
-   { 11819, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
-   { 11870, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
-   { 11908, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
-   { 11953, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
-   { 12002, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
-   { 12040, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
-   { 12082, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
-   { 12114, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */
-   { 12139, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */
-   { 12166, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
-   { 12197, 0x00000404 }, /* GL_FRONT */
-   { 12206, 0x00000408 }, /* GL_FRONT_AND_BACK */
-   { 12224, 0x00000B46 }, /* GL_FRONT_FACE */
-   { 12238, 0x00000400 }, /* GL_FRONT_LEFT */
-   { 12252, 0x00000401 }, /* GL_FRONT_RIGHT */
-   { 12267, 0x00008006 }, /* GL_FUNC_ADD */
-   { 12279, 0x00008006 }, /* GL_FUNC_ADD_EXT */
-   { 12295, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */
-   { 12320, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */
-   { 12349, 0x0000800A }, /* GL_FUNC_SUBTRACT */
-   { 12366, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */
-   { 12387, 0x00008191 }, /* GL_GENERATE_MIPMAP */
-   { 12406, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */
-   { 12430, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */
-   { 12459, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */
-   { 12483, 0x00000206 }, /* GL_GEQUAL */
-   { 12493, 0x00000204 }, /* GL_GREATER */
-   { 12504, 0x00001904 }, /* GL_GREEN */
-   { 12513, 0x00000D19 }, /* GL_GREEN_BIAS */
-   { 12527, 0x00000D53 }, /* GL_GREEN_BITS */
-   { 12541, 0x00000D18 }, /* GL_GREEN_SCALE */
-   { 12556, 0x00008000 }, /* GL_HINT_BIT */
-   { 12568, 0x00008024 }, /* GL_HISTOGRAM */
-   { 12581, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */
-   { 12605, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */
-   { 12633, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */
-   { 12656, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */
-   { 12683, 0x00008024 }, /* GL_HISTOGRAM_EXT */
-   { 12700, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */
-   { 12720, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */
-   { 12744, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */
-   { 12768, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */
-   { 12796, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */
-   { 12824, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
-   { 12856, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
-   { 12878, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
-   { 12904, 0x0000802D }, /* GL_HISTOGRAM_SINK */
-   { 12922, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
-   { 12944, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
-   { 12963, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
-   { 12986, 0x0000862A }, /* GL_IDENTITY_NV */
-   { 13001, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
-   { 13021, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-   { 13061, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
-   { 13099, 0x00001E02 }, /* GL_INCR */
-   { 13107, 0x00008507 }, /* GL_INCR_WRAP */
-   { 13120, 0x00008507 }, /* GL_INCR_WRAP_EXT */
-   { 13137, 0x00008222 }, /* GL_INDEX */
-   { 13146, 0x00008077 }, /* GL_INDEX_ARRAY */
-   { 13161, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-   { 13191, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
-   { 13225, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
-   { 13248, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
-   { 13270, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
-   { 13290, 0x00000D51 }, /* GL_INDEX_BITS */
-   { 13304, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
-   { 13325, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
-   { 13343, 0x00000C30 }, /* GL_INDEX_MODE */
-   { 13357, 0x00000D13 }, /* GL_INDEX_OFFSET */
-   { 13373, 0x00000D12 }, /* GL_INDEX_SHIFT */
-   { 13388, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
-   { 13407, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */
-   { 13426, 0x00001404 }, /* GL_INT */
-   { 13433, 0x00008049 }, /* GL_INTENSITY */
-   { 13446, 0x0000804C }, /* GL_INTENSITY12 */
-   { 13461, 0x0000804C }, /* GL_INTENSITY12_EXT */
-   { 13480, 0x0000804D }, /* GL_INTENSITY16 */
-   { 13495, 0x0000804D }, /* GL_INTENSITY16_EXT */
-   { 13514, 0x0000804A }, /* GL_INTENSITY4 */
-   { 13528, 0x0000804A }, /* GL_INTENSITY4_EXT */
-   { 13546, 0x0000804B }, /* GL_INTENSITY8 */
-   { 13560, 0x0000804B }, /* GL_INTENSITY8_EXT */
-   { 13578, 0x00008049 }, /* GL_INTENSITY_EXT */
-   { 13595, 0x00008575 }, /* GL_INTERPOLATE */
-   { 13610, 0x00008575 }, /* GL_INTERPOLATE_ARB */
-   { 13629, 0x00008575 }, /* GL_INTERPOLATE_EXT */
-   { 13648, 0x00008B53 }, /* GL_INT_VEC2 */
-   { 13660, 0x00008B53 }, /* GL_INT_VEC2_ARB */
-   { 13676, 0x00008B54 }, /* GL_INT_VEC3 */
-   { 13688, 0x00008B54 }, /* GL_INT_VEC3_ARB */
-   { 13704, 0x00008B55 }, /* GL_INT_VEC4 */
-   { 13716, 0x00008B55 }, /* GL_INT_VEC4_ARB */
-   { 13732, 0x00000500 }, /* GL_INVALID_ENUM */
-   { 13748, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */
-   { 13781, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
-   { 13818, 0x00000502 }, /* GL_INVALID_OPERATION */
-   { 13839, 0x00000501 }, /* GL_INVALID_VALUE */
-   { 13856, 0x0000862B }, /* GL_INVERSE_NV */
-   { 13870, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
-   { 13894, 0x0000150A }, /* GL_INVERT */
-   { 13904, 0x00001E00 }, /* GL_KEEP */
-   { 13912, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */
-   { 13942, 0x00000406 }, /* GL_LEFT */
-   { 13950, 0x00000203 }, /* GL_LEQUAL */
-   { 13960, 0x00000201 }, /* GL_LESS */
-   { 13968, 0x00004000 }, /* GL_LIGHT0 */
-   { 13978, 0x00004001 }, /* GL_LIGHT1 */
-   { 13988, 0x00004002 }, /* GL_LIGHT2 */
-   { 13998, 0x00004003 }, /* GL_LIGHT3 */
-   { 14008, 0x00004004 }, /* GL_LIGHT4 */
-   { 14018, 0x00004005 }, /* GL_LIGHT5 */
-   { 14028, 0x00004006 }, /* GL_LIGHT6 */
-   { 14038, 0x00004007 }, /* GL_LIGHT7 */
-   { 14048, 0x00000B50 }, /* GL_LIGHTING */
-   { 14060, 0x00000040 }, /* GL_LIGHTING_BIT */
-   { 14076, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
-   { 14099, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-   { 14128, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
-   { 14161, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-   { 14189, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
-   { 14213, 0x00001B01 }, /* GL_LINE */
-   { 14221, 0x00002601 }, /* GL_LINEAR */
-   { 14231, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
-   { 14253, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-   { 14283, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-   { 14314, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
-   { 14338, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
-   { 14363, 0x00000001 }, /* GL_LINES */
-   { 14372, 0x00000004 }, /* GL_LINE_BIT */
-   { 14384, 0x00000002 }, /* GL_LINE_LOOP */
-   { 14397, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
-   { 14417, 0x00000B20 }, /* GL_LINE_SMOOTH */
-   { 14432, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
-   { 14452, 0x00000B24 }, /* GL_LINE_STIPPLE */
-   { 14468, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
-   { 14492, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
-   { 14515, 0x00000003 }, /* GL_LINE_STRIP */
-   { 14529, 0x00000702 }, /* GL_LINE_TOKEN */
-   { 14543, 0x00000B21 }, /* GL_LINE_WIDTH */
-   { 14557, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
-   { 14583, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
-   { 14603, 0x00008B82 }, /* GL_LINK_STATUS */
-   { 14618, 0x00000B32 }, /* GL_LIST_BASE */
-   { 14631, 0x00020000 }, /* GL_LIST_BIT */
-   { 14643, 0x00000B33 }, /* GL_LIST_INDEX */
-   { 14657, 0x00000B30 }, /* GL_LIST_MODE */
-   { 14670, 0x00000101 }, /* GL_LOAD */
-   { 14678, 0x00000BF1 }, /* GL_LOGIC_OP */
-   { 14690, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
-   { 14707, 0x00008CA1 }, /* GL_LOWER_LEFT */
-   { 14721, 0x00001909 }, /* GL_LUMINANCE */
-   { 14734, 0x00008041 }, /* GL_LUMINANCE12 */
-   { 14749, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
-   { 14772, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
-   { 14799, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
-   { 14821, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
-   { 14847, 0x00008041 }, /* GL_LUMINANCE12_EXT */
-   { 14866, 0x00008042 }, /* GL_LUMINANCE16 */
-   { 14881, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
-   { 14904, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
-   { 14931, 0x00008042 }, /* GL_LUMINANCE16_EXT */
-   { 14950, 0x0000803F }, /* GL_LUMINANCE4 */
-   { 14964, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
-   { 14985, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
-   { 15010, 0x0000803F }, /* GL_LUMINANCE4_EXT */
-   { 15028, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
-   { 15049, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
-   { 15074, 0x00008040 }, /* GL_LUMINANCE8 */
-   { 15088, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
-   { 15109, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
-   { 15134, 0x00008040 }, /* GL_LUMINANCE8_EXT */
-   { 15152, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
-   { 15171, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
-   { 15187, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
-   { 15207, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
-   { 15229, 0x00000D91 }, /* GL_MAP1_INDEX */
-   { 15243, 0x00000D92 }, /* GL_MAP1_NORMAL */
-   { 15258, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
-   { 15282, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
-   { 15306, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
-   { 15330, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
-   { 15354, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
-   { 15371, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
-   { 15388, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-   { 15416, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-   { 15445, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-   { 15474, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-   { 15503, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-   { 15532, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-   { 15561, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-   { 15590, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-   { 15618, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-   { 15646, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-   { 15674, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-   { 15702, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-   { 15730, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-   { 15758, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-   { 15786, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-   { 15814, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-   { 15842, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
-   { 15858, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
-   { 15878, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
-   { 15900, 0x00000DB1 }, /* GL_MAP2_INDEX */
-   { 15914, 0x00000DB2 }, /* GL_MAP2_NORMAL */
-   { 15929, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
-   { 15953, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
-   { 15977, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
-   { 16001, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
-   { 16025, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
-   { 16042, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
-   { 16059, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-   { 16087, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-   { 16116, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-   { 16145, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-   { 16174, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-   { 16203, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-   { 16232, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-   { 16261, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-   { 16289, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-   { 16317, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-   { 16345, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-   { 16373, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-   { 16401, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-   { 16429, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
-   { 16457, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-   { 16485, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-   { 16513, 0x00000D10 }, /* GL_MAP_COLOR */
-   { 16526, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */
-   { 16552, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */
-   { 16581, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */
-   { 16609, 0x00000001 }, /* GL_MAP_READ_BIT */
-   { 16625, 0x00000D11 }, /* GL_MAP_STENCIL */
-   { 16640, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */
-   { 16666, 0x00000002 }, /* GL_MAP_WRITE_BIT */
-   { 16683, 0x000088C0 }, /* GL_MATRIX0_ARB */
-   { 16698, 0x00008630 }, /* GL_MATRIX0_NV */
-   { 16712, 0x000088CA }, /* GL_MATRIX10_ARB */
-   { 16728, 0x000088CB }, /* GL_MATRIX11_ARB */
-   { 16744, 0x000088CC }, /* GL_MATRIX12_ARB */
-   { 16760, 0x000088CD }, /* GL_MATRIX13_ARB */
-   { 16776, 0x000088CE }, /* GL_MATRIX14_ARB */
-   { 16792, 0x000088CF }, /* GL_MATRIX15_ARB */
-   { 16808, 0x000088D0 }, /* GL_MATRIX16_ARB */
-   { 16824, 0x000088D1 }, /* GL_MATRIX17_ARB */
-   { 16840, 0x000088D2 }, /* GL_MATRIX18_ARB */
-   { 16856, 0x000088D3 }, /* GL_MATRIX19_ARB */
-   { 16872, 0x000088C1 }, /* GL_MATRIX1_ARB */
-   { 16887, 0x00008631 }, /* GL_MATRIX1_NV */
-   { 16901, 0x000088D4 }, /* GL_MATRIX20_ARB */
-   { 16917, 0x000088D5 }, /* GL_MATRIX21_ARB */
-   { 16933, 0x000088D6 }, /* GL_MATRIX22_ARB */
-   { 16949, 0x000088D7 }, /* GL_MATRIX23_ARB */
-   { 16965, 0x000088D8 }, /* GL_MATRIX24_ARB */
-   { 16981, 0x000088D9 }, /* GL_MATRIX25_ARB */
-   { 16997, 0x000088DA }, /* GL_MATRIX26_ARB */
-   { 17013, 0x000088DB }, /* GL_MATRIX27_ARB */
-   { 17029, 0x000088DC }, /* GL_MATRIX28_ARB */
-   { 17045, 0x000088DD }, /* GL_MATRIX29_ARB */
-   { 17061, 0x000088C2 }, /* GL_MATRIX2_ARB */
-   { 17076, 0x00008632 }, /* GL_MATRIX2_NV */
-   { 17090, 0x000088DE }, /* GL_MATRIX30_ARB */
-   { 17106, 0x000088DF }, /* GL_MATRIX31_ARB */
-   { 17122, 0x000088C3 }, /* GL_MATRIX3_ARB */
-   { 17137, 0x00008633 }, /* GL_MATRIX3_NV */
-   { 17151, 0x000088C4 }, /* GL_MATRIX4_ARB */
-   { 17166, 0x00008634 }, /* GL_MATRIX4_NV */
-   { 17180, 0x000088C5 }, /* GL_MATRIX5_ARB */
-   { 17195, 0x00008635 }, /* GL_MATRIX5_NV */
-   { 17209, 0x000088C6 }, /* GL_MATRIX6_ARB */
-   { 17224, 0x00008636 }, /* GL_MATRIX6_NV */
-   { 17238, 0x000088C7 }, /* GL_MATRIX7_ARB */
-   { 17253, 0x00008637 }, /* GL_MATRIX7_NV */
-   { 17267, 0x000088C8 }, /* GL_MATRIX8_ARB */
-   { 17282, 0x000088C9 }, /* GL_MATRIX9_ARB */
-   { 17297, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
-   { 17323, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-   { 17357, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-   { 17388, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-   { 17421, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-   { 17452, 0x00000BA0 }, /* GL_MATRIX_MODE */
-   { 17467, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
-   { 17489, 0x00008008 }, /* GL_MAX */
-   { 17496, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
-   { 17519, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-   { 17551, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
-   { 17577, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-   { 17610, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-   { 17636, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-   { 17670, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
-   { 17689, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
-   { 17718, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-   { 17750, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
-   { 17786, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-   { 17822, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
-   { 17862, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
-   { 17888, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
-   { 17918, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
-   { 17943, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
-   { 17972, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-   { 18001, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
-   { 18034, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
-   { 18054, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
-   { 18078, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
-   { 18102, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
-   { 18126, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
-   { 18151, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
-   { 18169, 0x00008008 }, /* GL_MAX_EXT */
-   { 18180, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-   { 18215, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
-   { 18254, 0x00000D31 }, /* GL_MAX_LIGHTS */
-   { 18268, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
-   { 18288, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-   { 18326, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-   { 18355, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
-   { 18379, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
-   { 18407, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
-   { 18430, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-   { 18467, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-   { 18503, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-   { 18530, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-   { 18559, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-   { 18593, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
-   { 18629, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-   { 18656, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-   { 18688, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-   { 18724, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-   { 18753, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-   { 18782, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
-   { 18810, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-   { 18848, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-   { 18892, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-   { 18935, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-   { 18969, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-   { 19008, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-   { 19045, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-   { 19083, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-   { 19126, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-   { 19169, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-   { 19199, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-   { 19230, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-   { 19266, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-   { 19302, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
-   { 19332, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-   { 19366, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
-   { 19399, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
-   { 19428, 0x00008D57 }, /* GL_MAX_SAMPLES */
-   { 19443, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */
-   { 19470, 0x00008504 }, /* GL_MAX_SHININESS_NV */
-   { 19490, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
-   { 19514, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
-   { 19536, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
-   { 19562, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-   { 19589, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
-   { 19620, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
-   { 19644, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-   { 19678, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
-   { 19698, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
-   { 19725, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
-   { 19746, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
-   { 19771, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
-   { 19796, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
-   { 19831, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
-   { 19853, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
-   { 19879, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
-   { 19901, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
-   { 19927, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-   { 19961, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
-   { 19999, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-   { 20032, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
-   { 20069, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
-   { 20093, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
-   { 20114, 0x00008007 }, /* GL_MIN */
-   { 20121, 0x0000802E }, /* GL_MINMAX */
-   { 20131, 0x0000802E }, /* GL_MINMAX_EXT */
-   { 20145, 0x0000802F }, /* GL_MINMAX_FORMAT */
-   { 20162, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
-   { 20183, 0x00008030 }, /* GL_MINMAX_SINK */
-   { 20198, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
-   { 20217, 0x00008007 }, /* GL_MIN_EXT */
-   { 20228, 0x00008370 }, /* GL_MIRRORED_REPEAT */
-   { 20247, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
-   { 20270, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
-   { 20293, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
-   { 20313, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
-   { 20333, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-   { 20363, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
-   { 20391, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-   { 20419, 0x00001700 }, /* GL_MODELVIEW */
-   { 20432, 0x00001700 }, /* GL_MODELVIEW0_ARB */
-   { 20450, 0x0000872A }, /* GL_MODELVIEW10_ARB */
-   { 20469, 0x0000872B }, /* GL_MODELVIEW11_ARB */
-   { 20488, 0x0000872C }, /* GL_MODELVIEW12_ARB */
-   { 20507, 0x0000872D }, /* GL_MODELVIEW13_ARB */
-   { 20526, 0x0000872E }, /* GL_MODELVIEW14_ARB */
-   { 20545, 0x0000872F }, /* GL_MODELVIEW15_ARB */
-   { 20564, 0x00008730 }, /* GL_MODELVIEW16_ARB */
-   { 20583, 0x00008731 }, /* GL_MODELVIEW17_ARB */
-   { 20602, 0x00008732 }, /* GL_MODELVIEW18_ARB */
-   { 20621, 0x00008733 }, /* GL_MODELVIEW19_ARB */
-   { 20640, 0x0000850A }, /* GL_MODELVIEW1_ARB */
-   { 20658, 0x00008734 }, /* GL_MODELVIEW20_ARB */
-   { 20677, 0x00008735 }, /* GL_MODELVIEW21_ARB */
-   { 20696, 0x00008736 }, /* GL_MODELVIEW22_ARB */
-   { 20715, 0x00008737 }, /* GL_MODELVIEW23_ARB */
-   { 20734, 0x00008738 }, /* GL_MODELVIEW24_ARB */
-   { 20753, 0x00008739 }, /* GL_MODELVIEW25_ARB */
-   { 20772, 0x0000873A }, /* GL_MODELVIEW26_ARB */
-   { 20791, 0x0000873B }, /* GL_MODELVIEW27_ARB */
-   { 20810, 0x0000873C }, /* GL_MODELVIEW28_ARB */
-   { 20829, 0x0000873D }, /* GL_MODELVIEW29_ARB */
-   { 20848, 0x00008722 }, /* GL_MODELVIEW2_ARB */
-   { 20866, 0x0000873E }, /* GL_MODELVIEW30_ARB */
-   { 20885, 0x0000873F }, /* GL_MODELVIEW31_ARB */
-   { 20904, 0x00008723 }, /* GL_MODELVIEW3_ARB */
-   { 20922, 0x00008724 }, /* GL_MODELVIEW4_ARB */
-   { 20940, 0x00008725 }, /* GL_MODELVIEW5_ARB */
-   { 20958, 0x00008726 }, /* GL_MODELVIEW6_ARB */
-   { 20976, 0x00008727 }, /* GL_MODELVIEW7_ARB */
-   { 20994, 0x00008728 }, /* GL_MODELVIEW8_ARB */
-   { 21012, 0x00008729 }, /* GL_MODELVIEW9_ARB */
-   { 21030, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
-   { 21050, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
-   { 21077, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
-   { 21102, 0x00002100 }, /* GL_MODULATE */
-   { 21114, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
-   { 21134, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
-   { 21161, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
-   { 21186, 0x00000103 }, /* GL_MULT */
-   { 21194, 0x0000809D }, /* GL_MULTISAMPLE */
-   { 21209, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
-   { 21229, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
-   { 21248, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
-   { 21267, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
-   { 21291, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
-   { 21314, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-   { 21344, 0x00002A25 }, /* GL_N3F_V3F */
-   { 21355, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
-   { 21375, 0x0000150E }, /* GL_NAND */
-   { 21383, 0x00002600 }, /* GL_NEAREST */
-   { 21394, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-   { 21425, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-   { 21457, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
-   { 21482, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
-   { 21508, 0x00000200 }, /* GL_NEVER */
-   { 21517, 0x00001102 }, /* GL_NICEST */
-   { 21527, 0x00000000 }, /* GL_NONE */
-   { 21535, 0x00001505 }, /* GL_NOOP */
-   { 21543, 0x00001508 }, /* GL_NOR */
-   { 21550, 0x00000BA1 }, /* GL_NORMALIZE */
-   { 21563, 0x00008075 }, /* GL_NORMAL_ARRAY */
-   { 21579, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
-   { 21610, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
-   { 21645, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
-   { 21669, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
-   { 21692, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
-   { 21713, 0x00008511 }, /* GL_NORMAL_MAP */
-   { 21727, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
-   { 21745, 0x00008511 }, /* GL_NORMAL_MAP_NV */
-   { 21762, 0x00000205 }, /* GL_NOTEQUAL */
-   { 21774, 0x00000000 }, /* GL_NO_ERROR */
-   { 21786, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
-   { 21820, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
-   { 21858, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
-   { 21890, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
-   { 21932, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
-   { 21962, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
-   { 22002, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
-   { 22033, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
-   { 22062, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
-   { 22090, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
-   { 22120, 0x00002401 }, /* GL_OBJECT_LINEAR */
-   { 22137, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
-   { 22163, 0x00002501 }, /* GL_OBJECT_PLANE */
-   { 22179, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
-   { 22214, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
-   { 22236, 0x00009112 }, /* GL_OBJECT_TYPE */
-   { 22251, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
-   { 22270, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
-   { 22300, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
-   { 22321, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
-   { 22349, 0x00000001 }, /* GL_ONE */
-   { 22356, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
-   { 22384, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
-   { 22416, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
-   { 22444, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
-   { 22476, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
-   { 22499, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
-   { 22522, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
-   { 22545, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
-   { 22568, 0x00008598 }, /* GL_OPERAND0_ALPHA */
-   { 22586, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
-   { 22608, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
-   { 22630, 0x00008590 }, /* GL_OPERAND0_RGB */
-   { 22646, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
-   { 22666, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
-   { 22686, 0x00008599 }, /* GL_OPERAND1_ALPHA */
-   { 22704, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
-   { 22726, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
-   { 22748, 0x00008591 }, /* GL_OPERAND1_RGB */
-   { 22764, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
-   { 22784, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
-   { 22804, 0x0000859A }, /* GL_OPERAND2_ALPHA */
-   { 22822, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
-   { 22844, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
-   { 22866, 0x00008592 }, /* GL_OPERAND2_RGB */
-   { 22882, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
-   { 22902, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
-   { 22922, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
-   { 22943, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
-   { 22962, 0x00001507 }, /* GL_OR */
-   { 22968, 0x00000A01 }, /* GL_ORDER */
-   { 22977, 0x0000150D }, /* GL_OR_INVERTED */
-   { 22992, 0x0000150B }, /* GL_OR_REVERSE */
-   { 23006, 0x00000505 }, /* GL_OUT_OF_MEMORY */
-   { 23023, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
-   { 23041, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
-   { 23062, 0x00008758 }, /* GL_PACK_INVERT_MESA */
-   { 23082, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
-   { 23100, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
-   { 23119, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
-   { 23139, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
-   { 23159, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
-   { 23177, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
-   { 23196, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
-   { 23221, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
-   { 23245, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
-   { 23266, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
-   { 23288, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
-   { 23310, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
-   { 23335, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
-   { 23359, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
-   { 23380, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
-   { 23402, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
-   { 23424, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
-   { 23446, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
-   { 23477, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
-   { 23497, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-   { 23522, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
-   { 23542, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-   { 23567, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
-   { 23587, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-   { 23612, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
-   { 23632, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-   { 23657, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
-   { 23677, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-   { 23702, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
-   { 23722, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-   { 23747, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
-   { 23767, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-   { 23792, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
-   { 23812, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-   { 23837, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
-   { 23857, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-   { 23882, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
-   { 23902, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-   { 23927, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
-   { 23945, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */
-   { 23966, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */
-   { 23995, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
-   { 24028, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
-   { 24053, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */
-   { 24076, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
-   { 24107, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
-   { 24142, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
-   { 24169, 0x00001B00 }, /* GL_POINT */
-   { 24178, 0x00000000 }, /* GL_POINTS */
-   { 24188, 0x00000002 }, /* GL_POINT_BIT */
-   { 24201, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
-   { 24231, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
-   { 24265, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
-   { 24299, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
-   { 24334, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
-   { 24363, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
-   { 24396, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
-   { 24429, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
-   { 24463, 0x00000B11 }, /* GL_POINT_SIZE */
-   { 24477, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
-   { 24503, 0x00008127 }, /* GL_POINT_SIZE_MAX */
-   { 24521, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
-   { 24543, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
-   { 24565, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
-   { 24588, 0x00008126 }, /* GL_POINT_SIZE_MIN */
-   { 24606, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
-   { 24628, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
-   { 24650, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
-   { 24673, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
-   { 24693, 0x00000B10 }, /* GL_POINT_SMOOTH */
-   { 24709, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
-   { 24730, 0x00008861 }, /* GL_POINT_SPRITE */
-   { 24746, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
-   { 24766, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
-   { 24795, 0x00008861 }, /* GL_POINT_SPRITE_NV */
-   { 24814, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
-   { 24840, 0x00000701 }, /* GL_POINT_TOKEN */
-   { 24855, 0x00000009 }, /* GL_POLYGON */
-   { 24866, 0x00000008 }, /* GL_POLYGON_BIT */
-   { 24881, 0x00000B40 }, /* GL_POLYGON_MODE */
-   { 24897, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
-   { 24920, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
-   { 24945, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
-   { 24968, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
-   { 24991, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
-   { 25015, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
-   { 25039, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
-   { 25057, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
-   { 25080, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
-   { 25099, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
-   { 25122, 0x00000703 }, /* GL_POLYGON_TOKEN */
-   { 25139, 0x00001203 }, /* GL_POSITION */
-   { 25151, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-   { 25183, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
-   { 25219, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-   { 25252, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
-   { 25289, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-   { 25320, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
-   { 25355, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-   { 25387, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
-   { 25423, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-   { 25456, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-   { 25488, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
-   { 25524, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-   { 25557, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
-   { 25594, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-   { 25624, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
-   { 25658, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-   { 25689, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
-   { 25724, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-   { 25755, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
-   { 25790, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-   { 25822, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
-   { 25858, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-   { 25888, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
-   { 25922, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-   { 25953, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
-   { 25988, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-   { 26020, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-   { 26051, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
-   { 26086, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-   { 26118, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
-   { 26154, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
-   { 26183, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
-   { 26216, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
-   { 26246, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
-   { 26280, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-   { 26319, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-   { 26352, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-   { 26392, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-   { 26426, 0x00008578 }, /* GL_PREVIOUS */
-   { 26438, 0x00008578 }, /* GL_PREVIOUS_ARB */
-   { 26454, 0x00008578 }, /* GL_PREVIOUS_EXT */
-   { 26470, 0x00008577 }, /* GL_PRIMARY_COLOR */
-   { 26487, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
-   { 26508, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
-   { 26529, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-   { 26562, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-   { 26594, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
-   { 26617, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
-   { 26640, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
-   { 26670, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
-   { 26699, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
-   { 26727, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
-   { 26749, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-   { 26777, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-   { 26805, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
-   { 26827, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
-   { 26848, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-   { 26888, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-   { 26927, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-   { 26957, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-   { 26992, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-   { 27025, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-   { 27059, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-   { 27098, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-   { 27137, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
-   { 27159, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
-   { 27185, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
-   { 27209, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
-   { 27232, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
-   { 27254, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
-   { 27275, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
-   { 27296, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
-   { 27323, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-   { 27355, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-   { 27387, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-   { 27422, 0x00001701 }, /* GL_PROJECTION */
-   { 27436, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
-   { 27457, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
-   { 27483, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */
-   { 27507, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
-   { 27528, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
-   { 27547, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
-   { 27570, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
-   { 27609, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-   { 27647, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
-   { 27667, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-   { 27697, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
-   { 27721, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
-   { 27741, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-   { 27771, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
-   { 27795, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
-   { 27815, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-   { 27848, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
-   { 27874, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
-   { 27904, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-   { 27935, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
-   { 27965, 0x00002003 }, /* GL_Q */
-   { 27970, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
-   { 27995, 0x00000007 }, /* GL_QUADS */
-   { 28004, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
-   { 28052, 0x00008614 }, /* GL_QUAD_MESH_SUN */
-   { 28069, 0x00000008 }, /* GL_QUAD_STRIP */
-   { 28083, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
-   { 28105, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
-   { 28131, 0x00008866 }, /* GL_QUERY_RESULT */
-   { 28147, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
-   { 28167, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
-   { 28193, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
-   { 28223, 0x00002002 }, /* GL_R */
-   { 28228, 0x00002A10 }, /* GL_R3_G3_B2 */
-   { 28240, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-   { 28273, 0x00000C02 }, /* GL_READ_BUFFER */
-   { 28288, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */
-   { 28308, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
-   { 28340, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
-   { 28364, 0x000088B8 }, /* GL_READ_ONLY */
-   { 28377, 0x000088B8 }, /* GL_READ_ONLY_ARB */
-   { 28394, 0x000088BA }, /* GL_READ_WRITE */
-   { 28408, 0x000088BA }, /* GL_READ_WRITE_ARB */
-   { 28426, 0x00001903 }, /* GL_RED */
-   { 28433, 0x00008016 }, /* GL_REDUCE */
-   { 28443, 0x00008016 }, /* GL_REDUCE_EXT */
-   { 28457, 0x00000D15 }, /* GL_RED_BIAS */
-   { 28469, 0x00000D52 }, /* GL_RED_BITS */
-   { 28481, 0x00000D14 }, /* GL_RED_SCALE */
-   { 28494, 0x00008512 }, /* GL_REFLECTION_MAP */
-   { 28512, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
-   { 28534, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
-   { 28555, 0x00001C00 }, /* GL_RENDER */
-   { 28565, 0x00008D41 }, /* GL_RENDERBUFFER */
-   { 28581, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */
-   { 28608, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
-   { 28636, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */
-   { 28662, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */
-   { 28689, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
-   { 28709, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */
-   { 28736, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */
-   { 28759, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
-   { 28786, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
-   { 28818, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-   { 28854, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */
-   { 28879, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */
-   { 28903, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */
-   { 28932, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */
-   { 28954, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
-   { 28980, 0x00001F01 }, /* GL_RENDERER */
-   { 28992, 0x00000C40 }, /* GL_RENDER_MODE */
-   { 29007, 0x00002901 }, /* GL_REPEAT */
-   { 29017, 0x00001E01 }, /* GL_REPLACE */
-   { 29028, 0x00008062 }, /* GL_REPLACE_EXT */
-   { 29043, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
-   { 29066, 0x0000803A }, /* GL_RESCALE_NORMAL */
-   { 29084, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
-   { 29106, 0x00000102 }, /* GL_RETURN */
-   { 29116, 0x00001907 }, /* GL_RGB */
-   { 29123, 0x00008052 }, /* GL_RGB10 */
-   { 29132, 0x00008059 }, /* GL_RGB10_A2 */
-   { 29144, 0x00008059 }, /* GL_RGB10_A2_EXT */
-   { 29160, 0x00008052 }, /* GL_RGB10_EXT */
-   { 29173, 0x00008053 }, /* GL_RGB12 */
-   { 29182, 0x00008053 }, /* GL_RGB12_EXT */
-   { 29195, 0x00008054 }, /* GL_RGB16 */
-   { 29204, 0x00008054 }, /* GL_RGB16_EXT */
-   { 29217, 0x0000804E }, /* GL_RGB2_EXT */
-   { 29229, 0x0000804F }, /* GL_RGB4 */
-   { 29237, 0x0000804F }, /* GL_RGB4_EXT */
-   { 29249, 0x000083A1 }, /* GL_RGB4_S3TC */
-   { 29262, 0x00008050 }, /* GL_RGB5 */
-   { 29270, 0x00008057 }, /* GL_RGB5_A1 */
-   { 29281, 0x00008057 }, /* GL_RGB5_A1_EXT */
-   { 29296, 0x00008050 }, /* GL_RGB5_EXT */
-   { 29308, 0x00008051 }, /* GL_RGB8 */
-   { 29316, 0x00008051 }, /* GL_RGB8_EXT */
-   { 29328, 0x00001908 }, /* GL_RGBA */
-   { 29336, 0x0000805A }, /* GL_RGBA12 */
-   { 29346, 0x0000805A }, /* GL_RGBA12_EXT */
-   { 29360, 0x0000805B }, /* GL_RGBA16 */
-   { 29370, 0x0000805B }, /* GL_RGBA16_EXT */
-   { 29384, 0x00008055 }, /* GL_RGBA2 */
-   { 29393, 0x00008055 }, /* GL_RGBA2_EXT */
-   { 29406, 0x00008056 }, /* GL_RGBA4 */
-   { 29415, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
-   { 29434, 0x00008056 }, /* GL_RGBA4_EXT */
-   { 29447, 0x000083A3 }, /* GL_RGBA4_S3TC */
-   { 29461, 0x00008058 }, /* GL_RGBA8 */
-   { 29470, 0x00008058 }, /* GL_RGBA8_EXT */
-   { 29483, 0x00008F97 }, /* GL_RGBA8_SNORM */
-   { 29498, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
-   { 29516, 0x00000C31 }, /* GL_RGBA_MODE */
-   { 29529, 0x000083A2 }, /* GL_RGBA_S3TC */
-   { 29542, 0x00008F93 }, /* GL_RGBA_SNORM */
-   { 29556, 0x000083A0 }, /* GL_RGB_S3TC */
-   { 29568, 0x00008573 }, /* GL_RGB_SCALE */
-   { 29581, 0x00008573 }, /* GL_RGB_SCALE_ARB */
-   { 29598, 0x00008573 }, /* GL_RGB_SCALE_EXT */
-   { 29615, 0x00000407 }, /* GL_RIGHT */
-   { 29624, 0x00002000 }, /* GL_S */
-   { 29629, 0x00008B5D }, /* GL_SAMPLER_1D */
-   { 29643, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
-   { 29664, 0x00008B5E }, /* GL_SAMPLER_2D */
-   { 29678, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
-   { 29699, 0x00008B5F }, /* GL_SAMPLER_3D */
-   { 29713, 0x00008B60 }, /* GL_SAMPLER_CUBE */
-   { 29729, 0x000080A9 }, /* GL_SAMPLES */
-   { 29740, 0x000086B4 }, /* GL_SAMPLES_3DFX */
-   { 29756, 0x000080A9 }, /* GL_SAMPLES_ARB */
-   { 29771, 0x00008914 }, /* GL_SAMPLES_PASSED */
-   { 29789, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
-   { 29811, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-   { 29839, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
-   { 29871, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
-   { 29894, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
-   { 29921, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
-   { 29939, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
-   { 29962, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
-   { 29984, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
-   { 30003, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
-   { 30026, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
-   { 30052, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
-   { 30082, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
-   { 30107, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
-   { 30136, 0x00080000 }, /* GL_SCISSOR_BIT */
-   { 30151, 0x00000C10 }, /* GL_SCISSOR_BOX */
-   { 30166, 0x00000C11 }, /* GL_SCISSOR_TEST */
-   { 30182, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
-   { 30207, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-   { 30247, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
-   { 30291, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-   { 30324, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-   { 30354, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-   { 30386, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-   { 30416, 0x00001C02 }, /* GL_SELECT */
-   { 30426, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
-   { 30454, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
-   { 30479, 0x00008012 }, /* GL_SEPARABLE_2D */
-   { 30495, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
-   { 30522, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
-   { 30553, 0x0000150F }, /* GL_SET */
-   { 30560, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
-   { 30581, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
-   { 30605, 0x00008B4F }, /* GL_SHADER_TYPE */
-   { 30620, 0x00000B54 }, /* GL_SHADE_MODEL */
-   { 30635, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
-   { 30663, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
-   { 30686, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-   { 30716, 0x00001601 }, /* GL_SHININESS */
-   { 30729, 0x00001402 }, /* GL_SHORT */
-   { 30738, 0x00009119 }, /* GL_SIGNALED */
-   { 30750, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */
-   { 30771, 0x000081F9 }, /* GL_SINGLE_COLOR */
-   { 30787, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
-   { 30807, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
-   { 30826, 0x00008C46 }, /* GL_SLUMINANCE */
-   { 30840, 0x00008C47 }, /* GL_SLUMINANCE8 */
-   { 30855, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */
-   { 30877, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */
-   { 30897, 0x00001D01 }, /* GL_SMOOTH */
-   { 30907, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
-   { 30940, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
-   { 30967, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
-   { 31000, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
-   { 31027, 0x00008588 }, /* GL_SOURCE0_ALPHA */
-   { 31044, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
-   { 31065, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
-   { 31086, 0x00008580 }, /* GL_SOURCE0_RGB */
-   { 31101, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
-   { 31120, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
-   { 31139, 0x00008589 }, /* GL_SOURCE1_ALPHA */
-   { 31156, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
-   { 31177, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
-   { 31198, 0x00008581 }, /* GL_SOURCE1_RGB */
-   { 31213, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
-   { 31232, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
-   { 31251, 0x0000858A }, /* GL_SOURCE2_ALPHA */
-   { 31268, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
-   { 31289, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
-   { 31310, 0x00008582 }, /* GL_SOURCE2_RGB */
-   { 31325, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
-   { 31344, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
-   { 31363, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
-   { 31383, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
-   { 31401, 0x00001202 }, /* GL_SPECULAR */
-   { 31413, 0x00002402 }, /* GL_SPHERE_MAP */
-   { 31427, 0x00001206 }, /* GL_SPOT_CUTOFF */
-   { 31442, 0x00001204 }, /* GL_SPOT_DIRECTION */
-   { 31460, 0x00001205 }, /* GL_SPOT_EXPONENT */
-   { 31477, 0x00008588 }, /* GL_SRC0_ALPHA */
-   { 31491, 0x00008580 }, /* GL_SRC0_RGB */
-   { 31503, 0x00008589 }, /* GL_SRC1_ALPHA */
-   { 31517, 0x00008581 }, /* GL_SRC1_RGB */
-   { 31529, 0x0000858A }, /* GL_SRC2_ALPHA */
-   { 31543, 0x00008582 }, /* GL_SRC2_RGB */
-   { 31555, 0x00000302 }, /* GL_SRC_ALPHA */
-   { 31568, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
-   { 31590, 0x00000300 }, /* GL_SRC_COLOR */
-   { 31603, 0x00008C40 }, /* GL_SRGB */
-   { 31611, 0x00008C41 }, /* GL_SRGB8 */
-   { 31620, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */
-   { 31636, 0x00008C42 }, /* GL_SRGB_ALPHA */
-   { 31650, 0x00000503 }, /* GL_STACK_OVERFLOW */
-   { 31668, 0x00000504 }, /* GL_STACK_UNDERFLOW */
-   { 31687, 0x000088E6 }, /* GL_STATIC_COPY */
-   { 31702, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
-   { 31721, 0x000088E4 }, /* GL_STATIC_DRAW */
-   { 31736, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
-   { 31755, 0x000088E5 }, /* GL_STATIC_READ */
-   { 31770, 0x000088E5 }, /* GL_STATIC_READ_ARB */
-   { 31789, 0x00001802 }, /* GL_STENCIL */
-   { 31800, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */
-   { 31822, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
-   { 31848, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
-   { 31869, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */
-   { 31894, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
-   { 31915, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */
-   { 31940, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-   { 31972, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */
-   { 32008, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
-   { 32040, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */
-   { 32076, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
-   { 32096, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
-   { 32123, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
-   { 32149, 0x00000D57 }, /* GL_STENCIL_BITS */
-   { 32165, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
-   { 32187, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
-   { 32210, 0x00000B94 }, /* GL_STENCIL_FAIL */
-   { 32226, 0x00000B92 }, /* GL_STENCIL_FUNC */
-   { 32242, 0x00001901 }, /* GL_STENCIL_INDEX */
-   { 32259, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
-   { 32282, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
-   { 32304, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
-   { 32326, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
-   { 32348, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
-   { 32369, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
-   { 32396, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
-   { 32423, 0x00000B97 }, /* GL_STENCIL_REF */
-   { 32438, 0x00000B90 }, /* GL_STENCIL_TEST */
-   { 32454, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
-   { 32483, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
-   { 32505, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
-   { 32526, 0x00000C33 }, /* GL_STEREO */
-   { 32536, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */
-   { 32560, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */
-   { 32585, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */
-   { 32609, 0x000088E2 }, /* GL_STREAM_COPY */
-   { 32624, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
-   { 32643, 0x000088E0 }, /* GL_STREAM_DRAW */
-   { 32658, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
-   { 32677, 0x000088E1 }, /* GL_STREAM_READ */
-   { 32692, 0x000088E1 }, /* GL_STREAM_READ_ARB */
-   { 32711, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
-   { 32728, 0x000084E7 }, /* GL_SUBTRACT */
-   { 32740, 0x000084E7 }, /* GL_SUBTRACT_ARB */
-   { 32756, 0x00009113 }, /* GL_SYNC_CONDITION */
-   { 32774, 0x00009116 }, /* GL_SYNC_FENCE */
-   { 32788, 0x00009115 }, /* GL_SYNC_FLAGS */
-   { 32802, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */
-   { 32829, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
-   { 32859, 0x00009114 }, /* GL_SYNC_STATUS */
-   { 32874, 0x00002001 }, /* GL_T */
-   { 32879, 0x00002A2A }, /* GL_T2F_C3F_V3F */
-   { 32894, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
-   { 32913, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
-   { 32929, 0x00002A2B }, /* GL_T2F_N3F_V3F */
-   { 32944, 0x00002A27 }, /* GL_T2F_V3F */
-   { 32955, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
-   { 32974, 0x00002A28 }, /* GL_T4F_V4F */
-   { 32985, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
-   { 33008, 0x00001702 }, /* GL_TEXTURE */
-   { 33019, 0x000084C0 }, /* GL_TEXTURE0 */
-   { 33031, 0x000084C0 }, /* GL_TEXTURE0_ARB */
-   { 33047, 0x000084C1 }, /* GL_TEXTURE1 */
-   { 33059, 0x000084CA }, /* GL_TEXTURE10 */
-   { 33072, 0x000084CA }, /* GL_TEXTURE10_ARB */
-   { 33089, 0x000084CB }, /* GL_TEXTURE11 */
-   { 33102, 0x000084CB }, /* GL_TEXTURE11_ARB */
-   { 33119, 0x000084CC }, /* GL_TEXTURE12 */
-   { 33132, 0x000084CC }, /* GL_TEXTURE12_ARB */
-   { 33149, 0x000084CD }, /* GL_TEXTURE13 */
-   { 33162, 0x000084CD }, /* GL_TEXTURE13_ARB */
-   { 33179, 0x000084CE }, /* GL_TEXTURE14 */
-   { 33192, 0x000084CE }, /* GL_TEXTURE14_ARB */
-   { 33209, 0x000084CF }, /* GL_TEXTURE15 */
-   { 33222, 0x000084CF }, /* GL_TEXTURE15_ARB */
-   { 33239, 0x000084D0 }, /* GL_TEXTURE16 */
-   { 33252, 0x000084D0 }, /* GL_TEXTURE16_ARB */
-   { 33269, 0x000084D1 }, /* GL_TEXTURE17 */
-   { 33282, 0x000084D1 }, /* GL_TEXTURE17_ARB */
-   { 33299, 0x000084D2 }, /* GL_TEXTURE18 */
-   { 33312, 0x000084D2 }, /* GL_TEXTURE18_ARB */
-   { 33329, 0x000084D3 }, /* GL_TEXTURE19 */
-   { 33342, 0x000084D3 }, /* GL_TEXTURE19_ARB */
-   { 33359, 0x000084C1 }, /* GL_TEXTURE1_ARB */
-   { 33375, 0x000084C2 }, /* GL_TEXTURE2 */
-   { 33387, 0x000084D4 }, /* GL_TEXTURE20 */
-   { 33400, 0x000084D4 }, /* GL_TEXTURE20_ARB */
-   { 33417, 0x000084D5 }, /* GL_TEXTURE21 */
-   { 33430, 0x000084D5 }, /* GL_TEXTURE21_ARB */
-   { 33447, 0x000084D6 }, /* GL_TEXTURE22 */
-   { 33460, 0x000084D6 }, /* GL_TEXTURE22_ARB */
-   { 33477, 0x000084D7 }, /* GL_TEXTURE23 */
-   { 33490, 0x000084D7 }, /* GL_TEXTURE23_ARB */
-   { 33507, 0x000084D8 }, /* GL_TEXTURE24 */
-   { 33520, 0x000084D8 }, /* GL_TEXTURE24_ARB */
-   { 33537, 0x000084D9 }, /* GL_TEXTURE25 */
-   { 33550, 0x000084D9 }, /* GL_TEXTURE25_ARB */
-   { 33567, 0x000084DA }, /* GL_TEXTURE26 */
-   { 33580, 0x000084DA }, /* GL_TEXTURE26_ARB */
-   { 33597, 0x000084DB }, /* GL_TEXTURE27 */
-   { 33610, 0x000084DB }, /* GL_TEXTURE27_ARB */
-   { 33627, 0x000084DC }, /* GL_TEXTURE28 */
-   { 33640, 0x000084DC }, /* GL_TEXTURE28_ARB */
-   { 33657, 0x000084DD }, /* GL_TEXTURE29 */
-   { 33670, 0x000084DD }, /* GL_TEXTURE29_ARB */
-   { 33687, 0x000084C2 }, /* GL_TEXTURE2_ARB */
-   { 33703, 0x000084C3 }, /* GL_TEXTURE3 */
-   { 33715, 0x000084DE }, /* GL_TEXTURE30 */
-   { 33728, 0x000084DE }, /* GL_TEXTURE30_ARB */
-   { 33745, 0x000084DF }, /* GL_TEXTURE31 */
-   { 33758, 0x000084DF }, /* GL_TEXTURE31_ARB */
-   { 33775, 0x000084C3 }, /* GL_TEXTURE3_ARB */
-   { 33791, 0x000084C4 }, /* GL_TEXTURE4 */
-   { 33803, 0x000084C4 }, /* GL_TEXTURE4_ARB */
-   { 33819, 0x000084C5 }, /* GL_TEXTURE5 */
-   { 33831, 0x000084C5 }, /* GL_TEXTURE5_ARB */
-   { 33847, 0x000084C6 }, /* GL_TEXTURE6 */
-   { 33859, 0x000084C6 }, /* GL_TEXTURE6_ARB */
-   { 33875, 0x000084C7 }, /* GL_TEXTURE7 */
-   { 33887, 0x000084C7 }, /* GL_TEXTURE7_ARB */
-   { 33903, 0x000084C8 }, /* GL_TEXTURE8 */
-   { 33915, 0x000084C8 }, /* GL_TEXTURE8_ARB */
-   { 33931, 0x000084C9 }, /* GL_TEXTURE9 */
-   { 33943, 0x000084C9 }, /* GL_TEXTURE9_ARB */
-   { 33959, 0x00000DE0 }, /* GL_TEXTURE_1D */
-   { 33973, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
-   { 33997, 0x00000DE1 }, /* GL_TEXTURE_2D */
-   { 34011, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
-   { 34035, 0x0000806F }, /* GL_TEXTURE_3D */
-   { 34049, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
-   { 34071, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
-   { 34097, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
-   { 34119, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
-   { 34141, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-   { 34173, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
-   { 34195, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-   { 34227, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
-   { 34249, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
-   { 34277, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
-   { 34309, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-   { 34342, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
-   { 34374, 0x00040000 }, /* GL_TEXTURE_BIT */
-   { 34389, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
-   { 34410, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
-   { 34435, 0x00001005 }, /* GL_TEXTURE_BORDER */
-   { 34453, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
-   { 34477, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-   { 34508, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-   { 34538, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-   { 34568, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-   { 34603, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-   { 34634, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-   { 34672, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
-   { 34699, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-   { 34731, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-   { 34765, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
-   { 34789, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
-   { 34817, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
-   { 34841, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
-   { 34869, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-   { 34902, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
-   { 34926, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
-   { 34948, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
-   { 34970, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
-   { 34996, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
-   { 35030, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-   { 35063, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
-   { 35100, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
-   { 35128, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
-   { 35160, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
-   { 35183, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-   { 35221, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
-   { 35263, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-   { 35294, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-   { 35322, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-   { 35352, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-   { 35380, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
-   { 35400, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
-   { 35424, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-   { 35455, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
-   { 35490, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-   { 35521, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
-   { 35556, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-   { 35587, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
-   { 35622, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-   { 35653, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
-   { 35688, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-   { 35719, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
-   { 35754, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-   { 35785, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
-   { 35820, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
-   { 35849, 0x00008071 }, /* GL_TEXTURE_DEPTH */
-   { 35866, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
-   { 35888, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
-   { 35914, 0x00002300 }, /* GL_TEXTURE_ENV */
-   { 35929, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
-   { 35950, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
-   { 35970, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
-   { 35996, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
-   { 36016, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
-   { 36033, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
-   { 36050, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
-   { 36067, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
-   { 36084, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
-   { 36109, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
-   { 36131, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
-   { 36157, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
-   { 36175, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
-   { 36201, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
-   { 36227, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
-   { 36257, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
-   { 36284, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
-   { 36309, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
-   { 36329, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
-   { 36353, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-   { 36380, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-   { 36407, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-   { 36434, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
-   { 36460, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
-   { 36490, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
-   { 36512, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
-   { 36530, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-   { 36560, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-   { 36588, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-   { 36616, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-   { 36644, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
-   { 36665, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
-   { 36684, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
-   { 36706, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
-   { 36725, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
-   { 36745, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
-   { 36775, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */
-   { 36806, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
-   { 36831, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
-   { 36855, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
-   { 36875, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
-   { 36899, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
-   { 36919, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
-   { 36942, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */
-   { 36966, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */
-   { 36996, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
-   { 37021, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
-   { 37055, 0x00001000 }, /* GL_TEXTURE_WIDTH */
-   { 37072, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
-   { 37090, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
-   { 37108, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
-   { 37126, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */
-   { 37145, 0xFFFFFFFFFFFFFFFF }, /* GL_TIMEOUT_IGNORED */
-   { 37164, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
-   { 37184, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
-   { 37203, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-   { 37232, 0x00001000 }, /* GL_TRANSFORM_BIT */
-   { 37249, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
-   { 37275, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
-   { 37305, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-   { 37337, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-   { 37367, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
-   { 37401, 0x0000862C }, /* GL_TRANSPOSE_NV */
-   { 37417, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-   { 37448, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
-   { 37483, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-   { 37511, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
-   { 37543, 0x00000004 }, /* GL_TRIANGLES */
-   { 37556, 0x00000006 }, /* GL_TRIANGLE_FAN */
-   { 37572, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
-   { 37593, 0x00000005 }, /* GL_TRIANGLE_STRIP */
-   { 37611, 0x00000001 }, /* GL_TRUE */
-   { 37619, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
-   { 37639, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
-   { 37662, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
-   { 37682, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
-   { 37703, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
-   { 37725, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
-   { 37747, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
-   { 37767, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
-   { 37788, 0x00009118 }, /* GL_UNSIGNALED */
-   { 37802, 0x00001401 }, /* GL_UNSIGNED_BYTE */
-   { 37819, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-   { 37846, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
-   { 37869, 0x00001405 }, /* GL_UNSIGNED_INT */
-   { 37885, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
-   { 37912, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */
-   { 37933, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
-   { 37957, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-   { 37988, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
-   { 38012, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-   { 38040, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */
-   { 38063, 0x00001403 }, /* GL_UNSIGNED_SHORT */
-   { 38081, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-   { 38111, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-   { 38137, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-   { 38167, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-   { 38193, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
-   { 38217, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-   { 38245, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-   { 38273, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
-   { 38300, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-   { 38332, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
-   { 38363, 0x00008CA2 }, /* GL_UPPER_LEFT */
-   { 38377, 0x00002A20 }, /* GL_V2F */
-   { 38384, 0x00002A21 }, /* GL_V3F */
-   { 38391, 0x00008B83 }, /* GL_VALIDATE_STATUS */
-   { 38410, 0x00001F00 }, /* GL_VENDOR */
-   { 38420, 0x00001F02 }, /* GL_VERSION */
-   { 38431, 0x00008074 }, /* GL_VERTEX_ARRAY */
-   { 38447, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */
-   { 38471, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
-   { 38501, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-   { 38532, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
-   { 38567, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
-   { 38591, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
-   { 38612, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
-   { 38635, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
-   { 38656, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-   { 38683, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-   { 38711, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-   { 38739, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-   { 38767, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-   { 38795, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-   { 38823, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-   { 38851, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-   { 38878, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-   { 38905, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-   { 38932, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-   { 38959, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-   { 38986, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-   { 39013, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-   { 39040, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-   { 39067, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-   { 39094, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-   { 39132, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
-   { 39174, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-   { 39205, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
-   { 39240, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
-   { 39274, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
-   { 39312, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-   { 39343, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
-   { 39378, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-   { 39406, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
-   { 39438, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-   { 39468, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
-   { 39502, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
-   { 39530, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
-   { 39562, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
-   { 39582, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
-   { 39604, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
-   { 39633, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
-   { 39654, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-   { 39683, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
-   { 39716, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
-   { 39748, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-   { 39775, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
-   { 39806, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
-   { 39836, 0x00008B31 }, /* GL_VERTEX_SHADER */
-   { 39853, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
-   { 39874, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
-   { 39901, 0x00000BA2 }, /* GL_VIEWPORT */
-   { 39913, 0x00000800 }, /* GL_VIEWPORT_BIT */
-   { 39929, 0x0000911D }, /* GL_WAIT_FAILED */
-   { 39944, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
-   { 39964, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-   { 39995, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
-   { 40030, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-   { 40058, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-   { 40083, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-   { 40110, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-   { 40135, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
-   { 40159, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
-   { 40178, 0x000088B9 }, /* GL_WRITE_ONLY */
-   { 40192, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
-   { 40210, 0x00001506 }, /* GL_XOR */
-   { 40217, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
-   { 40236, 0x00008757 }, /* GL_YCBCR_MESA */
-   { 40250, 0x00000000 }, /* GL_ZERO */
-   { 40258, 0x00000D16 }, /* GL_ZOOM_X */
-   { 40268, 0x00000D17 }, /* GL_ZOOM_Y */
+   {  7327, 0x0000864F }, /* GL_DEPTH_CLAMP */
+   {  7342, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */
+   {  7360, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */
+   {  7381, 0x00001902 }, /* GL_DEPTH_COMPONENT */
+   {  7400, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */
+   {  7421, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */
+   {  7446, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */
+   {  7472, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */
+   {  7493, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */
+   {  7518, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */
+   {  7544, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */
+   {  7565, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */
+   {  7590, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */
+   {  7616, 0x00000B74 }, /* GL_DEPTH_FUNC */
+   {  7630, 0x00000B70 }, /* GL_DEPTH_RANGE */
+   {  7645, 0x00000D1E }, /* GL_DEPTH_SCALE */
+   {  7660, 0x000084F9 }, /* GL_DEPTH_STENCIL */
+   {  7677, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */
+   {  7705, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */
+   {  7725, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
+   {  7753, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
+   {  7781, 0x00000B71 }, /* GL_DEPTH_TEST */
+   {  7795, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */
+   {  7817, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */
+   {  7843, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */
+   {  7862, 0x00001201 }, /* GL_DIFFUSE */
+   {  7873, 0x00000BD0 }, /* GL_DITHER */
+   {  7883, 0x00000A02 }, /* GL_DOMAIN */
+   {  7893, 0x00001100 }, /* GL_DONT_CARE */
+   {  7906, 0x000086AE }, /* GL_DOT3_RGB */
+   {  7918, 0x000086AF }, /* GL_DOT3_RGBA */
+   {  7931, 0x000086AF }, /* GL_DOT3_RGBA_ARB */
+   {  7948, 0x00008741 }, /* GL_DOT3_RGBA_EXT */
+   {  7965, 0x000086AE }, /* GL_DOT3_RGB_ARB */
+   {  7981, 0x00008740 }, /* GL_DOT3_RGB_EXT */
+   {  7997, 0x0000140A }, /* GL_DOUBLE */
+   {  8007, 0x00000C32 }, /* GL_DOUBLEBUFFER */
+   {  8023, 0x00000C01 }, /* GL_DRAW_BUFFER */
+   {  8038, 0x00008825 }, /* GL_DRAW_BUFFER0 */
+   {  8054, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */
+   {  8074, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */
+   {  8094, 0x00008826 }, /* GL_DRAW_BUFFER1 */
+   {  8110, 0x0000882F }, /* GL_DRAW_BUFFER10 */
+   {  8127, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */
+   {  8148, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */
+   {  8169, 0x00008830 }, /* GL_DRAW_BUFFER11 */
+   {  8186, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */
+   {  8207, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */
+   {  8228, 0x00008831 }, /* GL_DRAW_BUFFER12 */
+   {  8245, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */
+   {  8266, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */
+   {  8287, 0x00008832 }, /* GL_DRAW_BUFFER13 */
+   {  8304, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */
+   {  8325, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */
+   {  8346, 0x00008833 }, /* GL_DRAW_BUFFER14 */
+   {  8363, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */
+   {  8384, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */
+   {  8405, 0x00008834 }, /* GL_DRAW_BUFFER15 */
+   {  8422, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */
+   {  8443, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */
+   {  8464, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */
+   {  8484, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */
+   {  8504, 0x00008827 }, /* GL_DRAW_BUFFER2 */
+   {  8520, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */
+   {  8540, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */
+   {  8560, 0x00008828 }, /* GL_DRAW_BUFFER3 */
+   {  8576, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */
+   {  8596, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */
+   {  8616, 0x00008829 }, /* GL_DRAW_BUFFER4 */
+   {  8632, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */
+   {  8652, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */
+   {  8672, 0x0000882A }, /* GL_DRAW_BUFFER5 */
+   {  8688, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */
+   {  8708, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */
+   {  8728, 0x0000882B }, /* GL_DRAW_BUFFER6 */
+   {  8744, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */
+   {  8764, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */
+   {  8784, 0x0000882C }, /* GL_DRAW_BUFFER7 */
+   {  8800, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */
+   {  8820, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */
+   {  8840, 0x0000882D }, /* GL_DRAW_BUFFER8 */
+   {  8856, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */
+   {  8876, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */
+   {  8896, 0x0000882E }, /* GL_DRAW_BUFFER9 */
+   {  8912, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */
+   {  8932, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */
+   {  8952, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */
+   {  8972, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
+   {  9004, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */
+   {  9028, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */
+   {  9048, 0x00000304 }, /* GL_DST_ALPHA */
+   {  9061, 0x00000306 }, /* GL_DST_COLOR */
+   {  9074, 0x0000877A }, /* GL_DU8DV8_ATI */
+   {  9088, 0x00008779 }, /* GL_DUDV_ATI */
+   {  9100, 0x000088EA }, /* GL_DYNAMIC_COPY */
+   {  9116, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */
+   {  9136, 0x000088E8 }, /* GL_DYNAMIC_DRAW */
+   {  9152, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */
+   {  9172, 0x000088E9 }, /* GL_DYNAMIC_READ */
+   {  9188, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */
+   {  9208, 0x00000B43 }, /* GL_EDGE_FLAG */
+   {  9221, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */
+   {  9240, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
+   {  9274, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */
+   {  9312, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */
+   {  9339, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */
+   {  9365, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */
+   {  9389, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
+   {  9421, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */
+   {  9457, 0x00001600 }, /* GL_EMISSION */
+   {  9469, 0x00002000 }, /* GL_ENABLE_BIT */
+   {  9483, 0x00000202 }, /* GL_EQUAL */
+   {  9492, 0x00001509 }, /* GL_EQUIV */
+   {  9501, 0x00010000 }, /* GL_EVAL_BIT */
+   {  9513, 0x00000800 }, /* GL_EXP */
+   {  9520, 0x00000801 }, /* GL_EXP2 */
+   {  9528, 0x00001F03 }, /* GL_EXTENSIONS */
+   {  9542, 0x00002400 }, /* GL_EYE_LINEAR */
+   {  9556, 0x00002502 }, /* GL_EYE_PLANE */
+   {  9569, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */
+   {  9594, 0x0000855B }, /* GL_EYE_RADIAL_NV */
+   {  9611, 0x00000000 }, /* GL_FALSE */
+   {  9620, 0x00001101 }, /* GL_FASTEST */
+   {  9631, 0x00001C01 }, /* GL_FEEDBACK */
+   {  9643, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */
+   {  9670, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */
+   {  9694, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */
+   {  9718, 0x00001B02 }, /* GL_FILL */
+   {  9726, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION */
+   {  9753, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION_EXT */
+   {  9784, 0x00001D00 }, /* GL_FLAT */
+   {  9792, 0x00001406 }, /* GL_FLOAT */
+   {  9801, 0x00008B5A }, /* GL_FLOAT_MAT2 */
+   {  9815, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */
+   {  9833, 0x00008B65 }, /* GL_FLOAT_MAT2x3 */
+   {  9849, 0x00008B66 }, /* GL_FLOAT_MAT2x4 */
+   {  9865, 0x00008B5B }, /* GL_FLOAT_MAT3 */
+   {  9879, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */
+   {  9897, 0x00008B67 }, /* GL_FLOAT_MAT3x2 */
+   {  9913, 0x00008B68 }, /* GL_FLOAT_MAT3x4 */
+   {  9929, 0x00008B5C }, /* GL_FLOAT_MAT4 */
+   {  9943, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */
+   {  9961, 0x00008B69 }, /* GL_FLOAT_MAT4x2 */
+   {  9977, 0x00008B6A }, /* GL_FLOAT_MAT4x3 */
+   {  9993, 0x00008B50 }, /* GL_FLOAT_VEC2 */
+   { 10007, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */
+   { 10025, 0x00008B51 }, /* GL_FLOAT_VEC3 */
+   { 10039, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */
+   { 10057, 0x00008B52 }, /* GL_FLOAT_VEC4 */
+   { 10071, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */
+   { 10089, 0x00000B60 }, /* GL_FOG */
+   { 10096, 0x00000080 }, /* GL_FOG_BIT */
+   { 10107, 0x00000B66 }, /* GL_FOG_COLOR */
+   { 10120, 0x00008451 }, /* GL_FOG_COORD */
+   { 10133, 0x00008451 }, /* GL_FOG_COORDINATE */
+   { 10151, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */
+   { 10175, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
+   { 10214, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */
+   { 10257, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */
+   { 10289, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
+   { 10320, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */
+   { 10349, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */
+   { 10374, 0x00008457 }, /* GL_FOG_COORD_ARRAY */
+   { 10393, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */
+   { 10427, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */
+   { 10454, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */
+   { 10480, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */
+   { 10504, 0x00008450 }, /* GL_FOG_COORD_SRC */
+   { 10521, 0x00000B62 }, /* GL_FOG_DENSITY */
+   { 10536, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */
+   { 10560, 0x00000B64 }, /* GL_FOG_END */
+   { 10571, 0x00000C54 }, /* GL_FOG_HINT */
+   { 10583, 0x00000B61 }, /* GL_FOG_INDEX */
+   { 10596, 0x00000B65 }, /* GL_FOG_MODE */
+   { 10608, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */
+   { 10627, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */
+   { 10652, 0x00000B63 }, /* GL_FOG_START */
+   { 10665, 0x00008452 }, /* GL_FRAGMENT_DEPTH */
+   { 10683, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */
+   { 10707, 0x00008B30 }, /* GL_FRAGMENT_SHADER */
+   { 10726, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */
+   { 10749, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
+   { 10784, 0x00008D40 }, /* GL_FRAMEBUFFER */
+   { 10799, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
+   { 10836, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
+   { 10872, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
+   { 10913, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
+   { 10954, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
+   { 10991, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
+   { 11028, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
+   { 11066, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
+   { 11108, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
+   { 11146, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
+   { 11188, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
+   { 11223, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
+   { 11262, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
+   { 11311, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
+   { 11359, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
+   { 11411, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+   { 11451, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
+   { 11495, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
+   { 11535, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
+   { 11579, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */
+   { 11606, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */
+   { 11630, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */
+   { 11658, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */
+   { 11681, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */
+   { 11700, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
+   { 11737, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
+   { 11778, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
+   { 11819, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
+   { 11861, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
+   { 11912, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
+   { 11950, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
+   { 11995, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
+   { 12044, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
+   { 12082, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
+   { 12124, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
+   { 12156, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */
+   { 12181, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */
+   { 12208, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
+   { 12239, 0x00000404 }, /* GL_FRONT */
+   { 12248, 0x00000408 }, /* GL_FRONT_AND_BACK */
+   { 12266, 0x00000B46 }, /* GL_FRONT_FACE */
+   { 12280, 0x00000400 }, /* GL_FRONT_LEFT */
+   { 12294, 0x00000401 }, /* GL_FRONT_RIGHT */
+   { 12309, 0x00008006 }, /* GL_FUNC_ADD */
+   { 12321, 0x00008006 }, /* GL_FUNC_ADD_EXT */
+   { 12337, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */
+   { 12362, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */
+   { 12391, 0x0000800A }, /* GL_FUNC_SUBTRACT */
+   { 12408, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */
+   { 12429, 0x00008191 }, /* GL_GENERATE_MIPMAP */
+   { 12448, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */
+   { 12472, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */
+   { 12501, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */
+   { 12525, 0x00000206 }, /* GL_GEQUAL */
+   { 12535, 0x00000204 }, /* GL_GREATER */
+   { 12546, 0x00001904 }, /* GL_GREEN */
+   { 12555, 0x00000D19 }, /* GL_GREEN_BIAS */
+   { 12569, 0x00000D53 }, /* GL_GREEN_BITS */
+   { 12583, 0x00000D18 }, /* GL_GREEN_SCALE */
+   { 12598, 0x00008000 }, /* GL_HINT_BIT */
+   { 12610, 0x00008024 }, /* GL_HISTOGRAM */
+   { 12623, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */
+   { 12647, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */
+   { 12675, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */
+   { 12698, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */
+   { 12725, 0x00008024 }, /* GL_HISTOGRAM_EXT */
+   { 12742, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */
+   { 12762, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */
+   { 12786, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */
+   { 12810, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */
+   { 12838, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */
+   { 12866, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
+   { 12898, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
+   { 12920, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
+   { 12946, 0x0000802D }, /* GL_HISTOGRAM_SINK */
+   { 12964, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
+   { 12986, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
+   { 13005, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
+   { 13028, 0x0000862A }, /* GL_IDENTITY_NV */
+   { 13043, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
+   { 13063, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
+   { 13103, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
+   { 13141, 0x00001E02 }, /* GL_INCR */
+   { 13149, 0x00008507 }, /* GL_INCR_WRAP */
+   { 13162, 0x00008507 }, /* GL_INCR_WRAP_EXT */
+   { 13179, 0x00008222 }, /* GL_INDEX */
+   { 13188, 0x00008077 }, /* GL_INDEX_ARRAY */
+   { 13203, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
+   { 13233, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
+   { 13267, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
+   { 13290, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
+   { 13312, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
+   { 13332, 0x00000D51 }, /* GL_INDEX_BITS */
+   { 13346, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
+   { 13367, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
+   { 13385, 0x00000C30 }, /* GL_INDEX_MODE */
+   { 13399, 0x00000D13 }, /* GL_INDEX_OFFSET */
+   { 13415, 0x00000D12 }, /* GL_INDEX_SHIFT */
+   { 13430, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
+   { 13449, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */
+   { 13468, 0x00001404 }, /* GL_INT */
+   { 13475, 0x00008049 }, /* GL_INTENSITY */
+   { 13488, 0x0000804C }, /* GL_INTENSITY12 */
+   { 13503, 0x0000804C }, /* GL_INTENSITY12_EXT */
+   { 13522, 0x0000804D }, /* GL_INTENSITY16 */
+   { 13537, 0x0000804D }, /* GL_INTENSITY16_EXT */
+   { 13556, 0x0000804A }, /* GL_INTENSITY4 */
+   { 13570, 0x0000804A }, /* GL_INTENSITY4_EXT */
+   { 13588, 0x0000804B }, /* GL_INTENSITY8 */
+   { 13602, 0x0000804B }, /* GL_INTENSITY8_EXT */
+   { 13620, 0x00008049 }, /* GL_INTENSITY_EXT */
+   { 13637, 0x00008575 }, /* GL_INTERPOLATE */
+   { 13652, 0x00008575 }, /* GL_INTERPOLATE_ARB */
+   { 13671, 0x00008575 }, /* GL_INTERPOLATE_EXT */
+   { 13690, 0x00008B53 }, /* GL_INT_VEC2 */
+   { 13702, 0x00008B53 }, /* GL_INT_VEC2_ARB */
+   { 13718, 0x00008B54 }, /* GL_INT_VEC3 */
+   { 13730, 0x00008B54 }, /* GL_INT_VEC3_ARB */
+   { 13746, 0x00008B55 }, /* GL_INT_VEC4 */
+   { 13758, 0x00008B55 }, /* GL_INT_VEC4_ARB */
+   { 13774, 0x00000500 }, /* GL_INVALID_ENUM */
+   { 13790, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */
+   { 13823, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
+   { 13860, 0x00000502 }, /* GL_INVALID_OPERATION */
+   { 13881, 0x00000501 }, /* GL_INVALID_VALUE */
+   { 13898, 0x0000862B }, /* GL_INVERSE_NV */
+   { 13912, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
+   { 13936, 0x0000150A }, /* GL_INVERT */
+   { 13946, 0x00001E00 }, /* GL_KEEP */
+   { 13954, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION */
+   { 13980, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */
+   { 14010, 0x00000406 }, /* GL_LEFT */
+   { 14018, 0x00000203 }, /* GL_LEQUAL */
+   { 14028, 0x00000201 }, /* GL_LESS */
+   { 14036, 0x00004000 }, /* GL_LIGHT0 */
+   { 14046, 0x00004001 }, /* GL_LIGHT1 */
+   { 14056, 0x00004002 }, /* GL_LIGHT2 */
+   { 14066, 0x00004003 }, /* GL_LIGHT3 */
+   { 14076, 0x00004004 }, /* GL_LIGHT4 */
+   { 14086, 0x00004005 }, /* GL_LIGHT5 */
+   { 14096, 0x00004006 }, /* GL_LIGHT6 */
+   { 14106, 0x00004007 }, /* GL_LIGHT7 */
+   { 14116, 0x00000B50 }, /* GL_LIGHTING */
+   { 14128, 0x00000040 }, /* GL_LIGHTING_BIT */
+   { 14144, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
+   { 14167, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+   { 14196, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
+   { 14229, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+   { 14257, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
+   { 14281, 0x00001B01 }, /* GL_LINE */
+   { 14289, 0x00002601 }, /* GL_LINEAR */
+   { 14299, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
+   { 14321, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+   { 14351, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+   { 14382, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
+   { 14406, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
+   { 14431, 0x00000001 }, /* GL_LINES */
+   { 14440, 0x00000004 }, /* GL_LINE_BIT */
+   { 14452, 0x00000002 }, /* GL_LINE_LOOP */
+   { 14465, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
+   { 14485, 0x00000B20 }, /* GL_LINE_SMOOTH */
+   { 14500, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
+   { 14520, 0x00000B24 }, /* GL_LINE_STIPPLE */
+   { 14536, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
+   { 14560, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
+   { 14583, 0x00000003 }, /* GL_LINE_STRIP */
+   { 14597, 0x00000702 }, /* GL_LINE_TOKEN */
+   { 14611, 0x00000B21 }, /* GL_LINE_WIDTH */
+   { 14625, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
+   { 14651, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
+   { 14671, 0x00008B82 }, /* GL_LINK_STATUS */
+   { 14686, 0x00000B32 }, /* GL_LIST_BASE */
+   { 14699, 0x00020000 }, /* GL_LIST_BIT */
+   { 14711, 0x00000B33 }, /* GL_LIST_INDEX */
+   { 14725, 0x00000B30 }, /* GL_LIST_MODE */
+   { 14738, 0x00000101 }, /* GL_LOAD */
+   { 14746, 0x00000BF1 }, /* GL_LOGIC_OP */
+   { 14758, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
+   { 14775, 0x00008CA1 }, /* GL_LOWER_LEFT */
+   { 14789, 0x00001909 }, /* GL_LUMINANCE */
+   { 14802, 0x00008041 }, /* GL_LUMINANCE12 */
+   { 14817, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
+   { 14840, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
+   { 14867, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
+   { 14889, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
+   { 14915, 0x00008041 }, /* GL_LUMINANCE12_EXT */
+   { 14934, 0x00008042 }, /* GL_LUMINANCE16 */
+   { 14949, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
+   { 14972, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
+   { 14999, 0x00008042 }, /* GL_LUMINANCE16_EXT */
+   { 15018, 0x0000803F }, /* GL_LUMINANCE4 */
+   { 15032, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
+   { 15053, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
+   { 15078, 0x0000803F }, /* GL_LUMINANCE4_EXT */
+   { 15096, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
+   { 15117, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
+   { 15142, 0x00008040 }, /* GL_LUMINANCE8 */
+   { 15156, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
+   { 15177, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
+   { 15202, 0x00008040 }, /* GL_LUMINANCE8_EXT */
+   { 15220, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
+   { 15239, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
+   { 15255, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
+   { 15275, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
+   { 15297, 0x00000D91 }, /* GL_MAP1_INDEX */
+   { 15311, 0x00000D92 }, /* GL_MAP1_NORMAL */
+   { 15326, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
+   { 15350, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
+   { 15374, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
+   { 15398, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
+   { 15422, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
+   { 15439, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
+   { 15456, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+   { 15484, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+   { 15513, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+   { 15542, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+   { 15571, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+   { 15600, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+   { 15629, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+   { 15658, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+   { 15686, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+   { 15714, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+   { 15742, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+   { 15770, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+   { 15798, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+   { 15826, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+   { 15854, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+   { 15882, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+   { 15910, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
+   { 15926, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
+   { 15946, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
+   { 15968, 0x00000DB1 }, /* GL_MAP2_INDEX */
+   { 15982, 0x00000DB2 }, /* GL_MAP2_NORMAL */
+   { 15997, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
+   { 16021, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
+   { 16045, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
+   { 16069, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
+   { 16093, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
+   { 16110, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
+   { 16127, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+   { 16155, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+   { 16184, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+   { 16213, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+   { 16242, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+   { 16271, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+   { 16300, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+   { 16329, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+   { 16357, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+   { 16385, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+   { 16413, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+   { 16441, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+   { 16469, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+   { 16497, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
+   { 16525, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+   { 16553, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+   { 16581, 0x00000D10 }, /* GL_MAP_COLOR */
+   { 16594, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */
+   { 16620, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */
+   { 16649, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */
+   { 16677, 0x00000001 }, /* GL_MAP_READ_BIT */
+   { 16693, 0x00000D11 }, /* GL_MAP_STENCIL */
+   { 16708, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */
+   { 16734, 0x00000002 }, /* GL_MAP_WRITE_BIT */
+   { 16751, 0x000088C0 }, /* GL_MATRIX0_ARB */
+   { 16766, 0x00008630 }, /* GL_MATRIX0_NV */
+   { 16780, 0x000088CA }, /* GL_MATRIX10_ARB */
+   { 16796, 0x000088CB }, /* GL_MATRIX11_ARB */
+   { 16812, 0x000088CC }, /* GL_MATRIX12_ARB */
+   { 16828, 0x000088CD }, /* GL_MATRIX13_ARB */
+   { 16844, 0x000088CE }, /* GL_MATRIX14_ARB */
+   { 16860, 0x000088CF }, /* GL_MATRIX15_ARB */
+   { 16876, 0x000088D0 }, /* GL_MATRIX16_ARB */
+   { 16892, 0x000088D1 }, /* GL_MATRIX17_ARB */
+   { 16908, 0x000088D2 }, /* GL_MATRIX18_ARB */
+   { 16924, 0x000088D3 }, /* GL_MATRIX19_ARB */
+   { 16940, 0x000088C1 }, /* GL_MATRIX1_ARB */
+   { 16955, 0x00008631 }, /* GL_MATRIX1_NV */
+   { 16969, 0x000088D4 }, /* GL_MATRIX20_ARB */
+   { 16985, 0x000088D5 }, /* GL_MATRIX21_ARB */
+   { 17001, 0x000088D6 }, /* GL_MATRIX22_ARB */
+   { 17017, 0x000088D7 }, /* GL_MATRIX23_ARB */
+   { 17033, 0x000088D8 }, /* GL_MATRIX24_ARB */
+   { 17049, 0x000088D9 }, /* GL_MATRIX25_ARB */
+   { 17065, 0x000088DA }, /* GL_MATRIX26_ARB */
+   { 17081, 0x000088DB }, /* GL_MATRIX27_ARB */
+   { 17097, 0x000088DC }, /* GL_MATRIX28_ARB */
+   { 17113, 0x000088DD }, /* GL_MATRIX29_ARB */
+   { 17129, 0x000088C2 }, /* GL_MATRIX2_ARB */
+   { 17144, 0x00008632 }, /* GL_MATRIX2_NV */
+   { 17158, 0x000088DE }, /* GL_MATRIX30_ARB */
+   { 17174, 0x000088DF }, /* GL_MATRIX31_ARB */
+   { 17190, 0x000088C3 }, /* GL_MATRIX3_ARB */
+   { 17205, 0x00008633 }, /* GL_MATRIX3_NV */
+   { 17219, 0x000088C4 }, /* GL_MATRIX4_ARB */
+   { 17234, 0x00008634 }, /* GL_MATRIX4_NV */
+   { 17248, 0x000088C5 }, /* GL_MATRIX5_ARB */
+   { 17263, 0x00008635 }, /* GL_MATRIX5_NV */
+   { 17277, 0x000088C6 }, /* GL_MATRIX6_ARB */
+   { 17292, 0x00008636 }, /* GL_MATRIX6_NV */
+   { 17306, 0x000088C7 }, /* GL_MATRIX7_ARB */
+   { 17321, 0x00008637 }, /* GL_MATRIX7_NV */
+   { 17335, 0x000088C8 }, /* GL_MATRIX8_ARB */
+   { 17350, 0x000088C9 }, /* GL_MATRIX9_ARB */
+   { 17365, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
+   { 17391, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+   { 17425, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+   { 17456, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+   { 17489, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+   { 17520, 0x00000BA0 }, /* GL_MATRIX_MODE */
+   { 17535, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
+   { 17557, 0x00008008 }, /* GL_MAX */
+   { 17564, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
+   { 17587, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
+   { 17619, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
+   { 17645, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+   { 17678, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+   { 17704, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 17738, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
+   { 17757, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
+   { 17786, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+   { 17818, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
+   { 17854, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+   { 17890, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
+   { 17930, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
+   { 17956, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
+   { 17986, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
+   { 18011, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
+   { 18040, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+   { 18069, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
+   { 18102, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
+   { 18122, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
+   { 18146, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
+   { 18170, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
+   { 18194, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
+   { 18219, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
+   { 18237, 0x00008008 }, /* GL_MAX_EXT */
+   { 18248, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+   { 18283, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
+   { 18322, 0x00000D31 }, /* GL_MAX_LIGHTS */
+   { 18336, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
+   { 18356, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+   { 18394, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+   { 18423, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
+   { 18447, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
+   { 18475, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
+   { 18498, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 18535, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 18571, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+   { 18598, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+   { 18627, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+   { 18661, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
+   { 18697, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+   { 18724, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+   { 18756, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+   { 18792, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+   { 18821, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+   { 18850, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
+   { 18878, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+   { 18916, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 18960, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 19003, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 19037, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 19076, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 19113, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 19151, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 19194, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 19237, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+   { 19267, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+   { 19298, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 19334, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 19370, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
+   { 19400, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+   { 19434, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
+   { 19467, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
+   { 19496, 0x00008D57 }, /* GL_MAX_SAMPLES */
+   { 19511, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+   { 19538, 0x00008504 }, /* GL_MAX_SHININESS_NV */
+   { 19558, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
+   { 19582, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
+   { 19604, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
+   { 19630, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+   { 19657, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
+   { 19688, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
+   { 19712, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 19746, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
+   { 19766, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
+   { 19793, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
+   { 19814, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
+   { 19839, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
+   { 19864, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
+   { 19899, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
+   { 19921, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
+   { 19947, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
+   { 19969, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
+   { 19995, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+   { 20029, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
+   { 20067, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+   { 20100, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
+   { 20137, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
+   { 20161, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
+   { 20182, 0x00008007 }, /* GL_MIN */
+   { 20189, 0x0000802E }, /* GL_MINMAX */
+   { 20199, 0x0000802E }, /* GL_MINMAX_EXT */
+   { 20213, 0x0000802F }, /* GL_MINMAX_FORMAT */
+   { 20230, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
+   { 20251, 0x00008030 }, /* GL_MINMAX_SINK */
+   { 20266, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
+   { 20285, 0x00008007 }, /* GL_MIN_EXT */
+   { 20296, 0x00008370 }, /* GL_MIRRORED_REPEAT */
+   { 20315, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
+   { 20338, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
+   { 20361, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
+   { 20381, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
+   { 20401, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+   { 20431, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
+   { 20459, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+   { 20487, 0x00001700 }, /* GL_MODELVIEW */
+   { 20500, 0x00001700 }, /* GL_MODELVIEW0_ARB */
+   { 20518, 0x0000872A }, /* GL_MODELVIEW10_ARB */
+   { 20537, 0x0000872B }, /* GL_MODELVIEW11_ARB */
+   { 20556, 0x0000872C }, /* GL_MODELVIEW12_ARB */
+   { 20575, 0x0000872D }, /* GL_MODELVIEW13_ARB */
+   { 20594, 0x0000872E }, /* GL_MODELVIEW14_ARB */
+   { 20613, 0x0000872F }, /* GL_MODELVIEW15_ARB */
+   { 20632, 0x00008730 }, /* GL_MODELVIEW16_ARB */
+   { 20651, 0x00008731 }, /* GL_MODELVIEW17_ARB */
+   { 20670, 0x00008732 }, /* GL_MODELVIEW18_ARB */
+   { 20689, 0x00008733 }, /* GL_MODELVIEW19_ARB */
+   { 20708, 0x0000850A }, /* GL_MODELVIEW1_ARB */
+   { 20726, 0x00008734 }, /* GL_MODELVIEW20_ARB */
+   { 20745, 0x00008735 }, /* GL_MODELVIEW21_ARB */
+   { 20764, 0x00008736 }, /* GL_MODELVIEW22_ARB */
+   { 20783, 0x00008737 }, /* GL_MODELVIEW23_ARB */
+   { 20802, 0x00008738 }, /* GL_MODELVIEW24_ARB */
+   { 20821, 0x00008739 }, /* GL_MODELVIEW25_ARB */
+   { 20840, 0x0000873A }, /* GL_MODELVIEW26_ARB */
+   { 20859, 0x0000873B }, /* GL_MODELVIEW27_ARB */
+   { 20878, 0x0000873C }, /* GL_MODELVIEW28_ARB */
+   { 20897, 0x0000873D }, /* GL_MODELVIEW29_ARB */
+   { 20916, 0x00008722 }, /* GL_MODELVIEW2_ARB */
+   { 20934, 0x0000873E }, /* GL_MODELVIEW30_ARB */
+   { 20953, 0x0000873F }, /* GL_MODELVIEW31_ARB */
+   { 20972, 0x00008723 }, /* GL_MODELVIEW3_ARB */
+   { 20990, 0x00008724 }, /* GL_MODELVIEW4_ARB */
+   { 21008, 0x00008725 }, /* GL_MODELVIEW5_ARB */
+   { 21026, 0x00008726 }, /* GL_MODELVIEW6_ARB */
+   { 21044, 0x00008727 }, /* GL_MODELVIEW7_ARB */
+   { 21062, 0x00008728 }, /* GL_MODELVIEW8_ARB */
+   { 21080, 0x00008729 }, /* GL_MODELVIEW9_ARB */
+   { 21098, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
+   { 21118, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
+   { 21145, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
+   { 21170, 0x00002100 }, /* GL_MODULATE */
+   { 21182, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
+   { 21202, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
+   { 21229, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
+   { 21254, 0x00000103 }, /* GL_MULT */
+   { 21262, 0x0000809D }, /* GL_MULTISAMPLE */
+   { 21277, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
+   { 21297, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
+   { 21316, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
+   { 21335, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
+   { 21359, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
+   { 21382, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+   { 21412, 0x00002A25 }, /* GL_N3F_V3F */
+   { 21423, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
+   { 21443, 0x0000150E }, /* GL_NAND */
+   { 21451, 0x00002600 }, /* GL_NEAREST */
+   { 21462, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+   { 21493, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+   { 21525, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
+   { 21550, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
+   { 21576, 0x00000200 }, /* GL_NEVER */
+   { 21585, 0x00001102 }, /* GL_NICEST */
+   { 21595, 0x00000000 }, /* GL_NONE */
+   { 21603, 0x00001505 }, /* GL_NOOP */
+   { 21611, 0x00001508 }, /* GL_NOR */
+   { 21618, 0x00000BA1 }, /* GL_NORMALIZE */
+   { 21631, 0x00008075 }, /* GL_NORMAL_ARRAY */
+   { 21647, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+   { 21678, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
+   { 21713, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
+   { 21737, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
+   { 21760, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
+   { 21781, 0x00008511 }, /* GL_NORMAL_MAP */
+   { 21795, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
+   { 21813, 0x00008511 }, /* GL_NORMAL_MAP_NV */
+   { 21830, 0x00000205 }, /* GL_NOTEQUAL */
+   { 21842, 0x00000000 }, /* GL_NO_ERROR */
+   { 21854, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+   { 21888, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
+   { 21926, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
+   { 21958, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
+   { 22000, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
+   { 22030, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
+   { 22070, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
+   { 22101, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
+   { 22130, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
+   { 22158, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
+   { 22188, 0x00002401 }, /* GL_OBJECT_LINEAR */
+   { 22205, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
+   { 22231, 0x00002501 }, /* GL_OBJECT_PLANE */
+   { 22247, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
+   { 22282, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
+   { 22304, 0x00009112 }, /* GL_OBJECT_TYPE */
+   { 22319, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
+   { 22338, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
+   { 22368, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
+   { 22389, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
+   { 22417, 0x00000001 }, /* GL_ONE */
+   { 22424, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+   { 22452, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
+   { 22484, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
+   { 22512, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
+   { 22544, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
+   { 22567, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
+   { 22590, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
+   { 22613, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
+   { 22636, 0x00008598 }, /* GL_OPERAND0_ALPHA */
+   { 22654, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
+   { 22676, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
+   { 22698, 0x00008590 }, /* GL_OPERAND0_RGB */
+   { 22714, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
+   { 22734, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
+   { 22754, 0x00008599 }, /* GL_OPERAND1_ALPHA */
+   { 22772, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
+   { 22794, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
+   { 22816, 0x00008591 }, /* GL_OPERAND1_RGB */
+   { 22832, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
+   { 22852, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
+   { 22872, 0x0000859A }, /* GL_OPERAND2_ALPHA */
+   { 22890, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
+   { 22912, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
+   { 22934, 0x00008592 }, /* GL_OPERAND2_RGB */
+   { 22950, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
+   { 22970, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
+   { 22990, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
+   { 23011, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
+   { 23030, 0x00001507 }, /* GL_OR */
+   { 23036, 0x00000A01 }, /* GL_ORDER */
+   { 23045, 0x0000150D }, /* GL_OR_INVERTED */
+   { 23060, 0x0000150B }, /* GL_OR_REVERSE */
+   { 23074, 0x00000505 }, /* GL_OUT_OF_MEMORY */
+   { 23091, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
+   { 23109, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
+   { 23130, 0x00008758 }, /* GL_PACK_INVERT_MESA */
+   { 23150, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
+   { 23168, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
+   { 23187, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
+   { 23207, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
+   { 23227, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
+   { 23245, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
+   { 23264, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
+   { 23289, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
+   { 23313, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
+   { 23334, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
+   { 23356, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
+   { 23378, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
+   { 23403, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
+   { 23427, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
+   { 23448, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
+   { 23470, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
+   { 23492, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
+   { 23514, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
+   { 23545, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
+   { 23565, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+   { 23590, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
+   { 23610, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+   { 23635, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
+   { 23655, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+   { 23680, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
+   { 23700, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+   { 23725, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
+   { 23745, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+   { 23770, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
+   { 23790, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+   { 23815, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
+   { 23835, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+   { 23860, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
+   { 23880, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+   { 23905, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
+   { 23925, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+   { 23950, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
+   { 23970, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+   { 23995, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
+   { 24013, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */
+   { 24034, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */
+   { 24063, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
+   { 24096, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
+   { 24121, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */
+   { 24144, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+   { 24175, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
+   { 24210, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
+   { 24237, 0x00001B00 }, /* GL_POINT */
+   { 24246, 0x00000000 }, /* GL_POINTS */
+   { 24256, 0x00000002 }, /* GL_POINT_BIT */
+   { 24269, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
+   { 24299, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
+   { 24333, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
+   { 24367, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
+   { 24402, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
+   { 24431, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
+   { 24464, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
+   { 24497, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
+   { 24531, 0x00000B11 }, /* GL_POINT_SIZE */
+   { 24545, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
+   { 24571, 0x00008127 }, /* GL_POINT_SIZE_MAX */
+   { 24589, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
+   { 24611, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
+   { 24633, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
+   { 24656, 0x00008126 }, /* GL_POINT_SIZE_MIN */
+   { 24674, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
+   { 24696, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
+   { 24718, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
+   { 24741, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
+   { 24761, 0x00000B10 }, /* GL_POINT_SMOOTH */
+   { 24777, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
+   { 24798, 0x00008861 }, /* GL_POINT_SPRITE */
+   { 24814, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
+   { 24834, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
+   { 24863, 0x00008861 }, /* GL_POINT_SPRITE_NV */
+   { 24882, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
+   { 24908, 0x00000701 }, /* GL_POINT_TOKEN */
+   { 24923, 0x00000009 }, /* GL_POLYGON */
+   { 24934, 0x00000008 }, /* GL_POLYGON_BIT */
+   { 24949, 0x00000B40 }, /* GL_POLYGON_MODE */
+   { 24965, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
+   { 24988, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
+   { 25013, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
+   { 25036, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
+   { 25059, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
+   { 25083, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
+   { 25107, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
+   { 25125, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
+   { 25148, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
+   { 25167, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
+   { 25190, 0x00000703 }, /* GL_POLYGON_TOKEN */
+   { 25207, 0x00001203 }, /* GL_POSITION */
+   { 25219, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+   { 25251, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
+   { 25287, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+   { 25320, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
+   { 25357, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+   { 25388, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
+   { 25423, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+   { 25455, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
+   { 25491, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 25524, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+   { 25556, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
+   { 25592, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+   { 25625, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
+   { 25662, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+   { 25692, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
+   { 25726, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+   { 25757, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
+   { 25792, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+   { 25823, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
+   { 25858, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+   { 25890, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
+   { 25926, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+   { 25956, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
+   { 25990, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+   { 26021, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
+   { 26056, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+   { 26088, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+   { 26119, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
+   { 26154, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+   { 26186, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
+   { 26222, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
+   { 26251, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
+   { 26284, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
+   { 26314, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
+   { 26348, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+   { 26387, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+   { 26420, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+   { 26460, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+   { 26494, 0x00008578 }, /* GL_PREVIOUS */
+   { 26506, 0x00008578 }, /* GL_PREVIOUS_ARB */
+   { 26522, 0x00008578 }, /* GL_PREVIOUS_EXT */
+   { 26538, 0x00008577 }, /* GL_PRIMARY_COLOR */
+   { 26555, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
+   { 26576, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
+   { 26597, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 26630, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 26662, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
+   { 26685, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
+   { 26708, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
+   { 26738, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
+   { 26767, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
+   { 26795, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
+   { 26817, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+   { 26845, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+   { 26873, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
+   { 26895, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
+   { 26916, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 26956, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 26995, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 27025, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 27060, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 27093, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 27127, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 27166, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 27205, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
+   { 27227, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
+   { 27253, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
+   { 27277, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
+   { 27300, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
+   { 27322, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
+   { 27343, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
+   { 27364, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
+   { 27391, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 27423, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 27455, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+   { 27490, 0x00001701 }, /* GL_PROJECTION */
+   { 27504, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
+   { 27525, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
+   { 27551, 0x00008E4F }, /* GL_PROVOKING_VERTEX */
+   { 27571, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */
+   { 27595, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
+   { 27616, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
+   { 27635, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
+   { 27658, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 27697, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+   { 27735, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
+   { 27755, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
+   { 27785, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
+   { 27809, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
+   { 27829, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
+   { 27859, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
+   { 27883, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
+   { 27903, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+   { 27936, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
+   { 27962, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
+   { 27992, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+   { 28023, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
+   { 28053, 0x00002003 }, /* GL_Q */
+   { 28058, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
+   { 28083, 0x00000007 }, /* GL_QUADS */
+   { 28092, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */
+   { 28136, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
+   { 28184, 0x00008614 }, /* GL_QUAD_MESH_SUN */
+   { 28201, 0x00000008 }, /* GL_QUAD_STRIP */
+   { 28215, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
+   { 28237, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
+   { 28263, 0x00008866 }, /* GL_QUERY_RESULT */
+   { 28279, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
+   { 28299, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
+   { 28325, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
+   { 28355, 0x00002002 }, /* GL_R */
+   { 28360, 0x00002A10 }, /* GL_R3_G3_B2 */
+   { 28372, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+   { 28405, 0x00000C02 }, /* GL_READ_BUFFER */
+   { 28420, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */
+   { 28440, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
+   { 28472, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
+   { 28496, 0x000088B8 }, /* GL_READ_ONLY */
+   { 28509, 0x000088B8 }, /* GL_READ_ONLY_ARB */
+   { 28526, 0x000088BA }, /* GL_READ_WRITE */
+   { 28540, 0x000088BA }, /* GL_READ_WRITE_ARB */
+   { 28558, 0x00001903 }, /* GL_RED */
+   { 28565, 0x00008016 }, /* GL_REDUCE */
+   { 28575, 0x00008016 }, /* GL_REDUCE_EXT */
+   { 28589, 0x00000D15 }, /* GL_RED_BIAS */
+   { 28601, 0x00000D52 }, /* GL_RED_BITS */
+   { 28613, 0x00000D14 }, /* GL_RED_SCALE */
+   { 28626, 0x00008512 }, /* GL_REFLECTION_MAP */
+   { 28644, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
+   { 28666, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
+   { 28687, 0x00001C00 }, /* GL_RENDER */
+   { 28697, 0x00008D41 }, /* GL_RENDERBUFFER */
+   { 28713, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */
+   { 28740, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
+   { 28768, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */
+   { 28794, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */
+   { 28821, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
+   { 28841, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */
+   { 28868, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */
+   { 28891, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
+   { 28918, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+   { 28950, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
+   { 28986, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */
+   { 29011, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */
+   { 29035, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */
+   { 29064, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */
+   { 29086, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
+   { 29112, 0x00001F01 }, /* GL_RENDERER */
+   { 29124, 0x00000C40 }, /* GL_RENDER_MODE */
+   { 29139, 0x00002901 }, /* GL_REPEAT */
+   { 29149, 0x00001E01 }, /* GL_REPLACE */
+   { 29160, 0x00008062 }, /* GL_REPLACE_EXT */
+   { 29175, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
+   { 29198, 0x0000803A }, /* GL_RESCALE_NORMAL */
+   { 29216, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
+   { 29238, 0x00000102 }, /* GL_RETURN */
+   { 29248, 0x00001907 }, /* GL_RGB */
+   { 29255, 0x00008052 }, /* GL_RGB10 */
+   { 29264, 0x00008059 }, /* GL_RGB10_A2 */
+   { 29276, 0x00008059 }, /* GL_RGB10_A2_EXT */
+   { 29292, 0x00008052 }, /* GL_RGB10_EXT */
+   { 29305, 0x00008053 }, /* GL_RGB12 */
+   { 29314, 0x00008053 }, /* GL_RGB12_EXT */
+   { 29327, 0x00008054 }, /* GL_RGB16 */
+   { 29336, 0x00008054 }, /* GL_RGB16_EXT */
+   { 29349, 0x0000804E }, /* GL_RGB2_EXT */
+   { 29361, 0x0000804F }, /* GL_RGB4 */
+   { 29369, 0x0000804F }, /* GL_RGB4_EXT */
+   { 29381, 0x000083A1 }, /* GL_RGB4_S3TC */
+   { 29394, 0x00008050 }, /* GL_RGB5 */
+   { 29402, 0x00008057 }, /* GL_RGB5_A1 */
+   { 29413, 0x00008057 }, /* GL_RGB5_A1_EXT */
+   { 29428, 0x00008050 }, /* GL_RGB5_EXT */
+   { 29440, 0x00008051 }, /* GL_RGB8 */
+   { 29448, 0x00008051 }, /* GL_RGB8_EXT */
+   { 29460, 0x00001908 }, /* GL_RGBA */
+   { 29468, 0x0000805A }, /* GL_RGBA12 */
+   { 29478, 0x0000805A }, /* GL_RGBA12_EXT */
+   { 29492, 0x0000805B }, /* GL_RGBA16 */
+   { 29502, 0x0000805B }, /* GL_RGBA16_EXT */
+   { 29516, 0x00008055 }, /* GL_RGBA2 */
+   { 29525, 0x00008055 }, /* GL_RGBA2_EXT */
+   { 29538, 0x00008056 }, /* GL_RGBA4 */
+   { 29547, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
+   { 29566, 0x00008056 }, /* GL_RGBA4_EXT */
+   { 29579, 0x000083A3 }, /* GL_RGBA4_S3TC */
+   { 29593, 0x00008058 }, /* GL_RGBA8 */
+   { 29602, 0x00008058 }, /* GL_RGBA8_EXT */
+   { 29615, 0x00008F97 }, /* GL_RGBA8_SNORM */
+   { 29630, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
+   { 29648, 0x00000C31 }, /* GL_RGBA_MODE */
+   { 29661, 0x000083A2 }, /* GL_RGBA_S3TC */
+   { 29674, 0x00008F93 }, /* GL_RGBA_SNORM */
+   { 29688, 0x000083A0 }, /* GL_RGB_S3TC */
+   { 29700, 0x00008573 }, /* GL_RGB_SCALE */
+   { 29713, 0x00008573 }, /* GL_RGB_SCALE_ARB */
+   { 29730, 0x00008573 }, /* GL_RGB_SCALE_EXT */
+   { 29747, 0x00000407 }, /* GL_RIGHT */
+   { 29756, 0x00002000 }, /* GL_S */
+   { 29761, 0x00008B5D }, /* GL_SAMPLER_1D */
+   { 29775, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
+   { 29796, 0x00008B5E }, /* GL_SAMPLER_2D */
+   { 29810, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
+   { 29831, 0x00008B5F }, /* GL_SAMPLER_3D */
+   { 29845, 0x00008B60 }, /* GL_SAMPLER_CUBE */
+   { 29861, 0x000080A9 }, /* GL_SAMPLES */
+   { 29872, 0x000086B4 }, /* GL_SAMPLES_3DFX */
+   { 29888, 0x000080A9 }, /* GL_SAMPLES_ARB */
+   { 29903, 0x00008914 }, /* GL_SAMPLES_PASSED */
+   { 29921, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
+   { 29943, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+   { 29971, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
+   { 30003, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
+   { 30026, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
+   { 30053, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
+   { 30071, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
+   { 30094, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
+   { 30116, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
+   { 30135, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
+   { 30158, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
+   { 30184, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
+   { 30214, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
+   { 30239, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
+   { 30268, 0x00080000 }, /* GL_SCISSOR_BIT */
+   { 30283, 0x00000C10 }, /* GL_SCISSOR_BOX */
+   { 30298, 0x00000C11 }, /* GL_SCISSOR_TEST */
+   { 30314, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
+   { 30339, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+   { 30379, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
+   { 30423, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+   { 30456, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+   { 30486, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+   { 30518, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+   { 30548, 0x00001C02 }, /* GL_SELECT */
+   { 30558, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
+   { 30586, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
+   { 30611, 0x00008012 }, /* GL_SEPARABLE_2D */
+   { 30627, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
+   { 30654, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
+   { 30685, 0x0000150F }, /* GL_SET */
+   { 30692, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
+   { 30713, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
+   { 30737, 0x00008B4F }, /* GL_SHADER_TYPE */
+   { 30752, 0x00000B54 }, /* GL_SHADE_MODEL */
+   { 30767, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
+   { 30795, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
+   { 30818, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+   { 30848, 0x00001601 }, /* GL_SHININESS */
+   { 30861, 0x00001402 }, /* GL_SHORT */
+   { 30870, 0x00009119 }, /* GL_SIGNALED */
+   { 30882, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */
+   { 30903, 0x000081F9 }, /* GL_SINGLE_COLOR */
+   { 30919, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
+   { 30939, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
+   { 30958, 0x00008C46 }, /* GL_SLUMINANCE */
+   { 30972, 0x00008C47 }, /* GL_SLUMINANCE8 */
+   { 30987, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */
+   { 31009, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */
+   { 31029, 0x00001D01 }, /* GL_SMOOTH */
+   { 31039, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
+   { 31072, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
+   { 31099, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
+   { 31132, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
+   { 31159, 0x00008588 }, /* GL_SOURCE0_ALPHA */
+   { 31176, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
+   { 31197, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
+   { 31218, 0x00008580 }, /* GL_SOURCE0_RGB */
+   { 31233, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
+   { 31252, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
+   { 31271, 0x00008589 }, /* GL_SOURCE1_ALPHA */
+   { 31288, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
+   { 31309, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
+   { 31330, 0x00008581 }, /* GL_SOURCE1_RGB */
+   { 31345, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
+   { 31364, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
+   { 31383, 0x0000858A }, /* GL_SOURCE2_ALPHA */
+   { 31400, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
+   { 31421, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
+   { 31442, 0x00008582 }, /* GL_SOURCE2_RGB */
+   { 31457, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
+   { 31476, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
+   { 31495, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
+   { 31515, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
+   { 31533, 0x00001202 }, /* GL_SPECULAR */
+   { 31545, 0x00002402 }, /* GL_SPHERE_MAP */
+   { 31559, 0x00001206 }, /* GL_SPOT_CUTOFF */
+   { 31574, 0x00001204 }, /* GL_SPOT_DIRECTION */
+   { 31592, 0x00001205 }, /* GL_SPOT_EXPONENT */
+   { 31609, 0x00008588 }, /* GL_SRC0_ALPHA */
+   { 31623, 0x00008580 }, /* GL_SRC0_RGB */
+   { 31635, 0x00008589 }, /* GL_SRC1_ALPHA */
+   { 31649, 0x00008581 }, /* GL_SRC1_RGB */
+   { 31661, 0x0000858A }, /* GL_SRC2_ALPHA */
+   { 31675, 0x00008582 }, /* GL_SRC2_RGB */
+   { 31687, 0x00000302 }, /* GL_SRC_ALPHA */
+   { 31700, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
+   { 31722, 0x00000300 }, /* GL_SRC_COLOR */
+   { 31735, 0x00008C40 }, /* GL_SRGB */
+   { 31743, 0x00008C41 }, /* GL_SRGB8 */
+   { 31752, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */
+   { 31768, 0x00008C42 }, /* GL_SRGB_ALPHA */
+   { 31782, 0x00000503 }, /* GL_STACK_OVERFLOW */
+   { 31800, 0x00000504 }, /* GL_STACK_UNDERFLOW */
+   { 31819, 0x000088E6 }, /* GL_STATIC_COPY */
+   { 31834, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
+   { 31853, 0x000088E4 }, /* GL_STATIC_DRAW */
+   { 31868, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
+   { 31887, 0x000088E5 }, /* GL_STATIC_READ */
+   { 31902, 0x000088E5 }, /* GL_STATIC_READ_ARB */
+   { 31921, 0x00001802 }, /* GL_STENCIL */
+   { 31932, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */
+   { 31954, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
+   { 31980, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
+   { 32001, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */
+   { 32026, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
+   { 32047, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */
+   { 32072, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+   { 32104, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */
+   { 32140, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+   { 32172, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */
+   { 32208, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
+   { 32228, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
+   { 32255, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
+   { 32281, 0x00000D57 }, /* GL_STENCIL_BITS */
+   { 32297, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
+   { 32319, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
+   { 32342, 0x00000B94 }, /* GL_STENCIL_FAIL */
+   { 32358, 0x00000B92 }, /* GL_STENCIL_FUNC */
+   { 32374, 0x00001901 }, /* GL_STENCIL_INDEX */
+   { 32391, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
+   { 32414, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
+   { 32436, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
+   { 32458, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
+   { 32480, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
+   { 32501, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
+   { 32528, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
+   { 32555, 0x00000B97 }, /* GL_STENCIL_REF */
+   { 32570, 0x00000B90 }, /* GL_STENCIL_TEST */
+   { 32586, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+   { 32615, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
+   { 32637, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
+   { 32658, 0x00000C33 }, /* GL_STEREO */
+   { 32668, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */
+   { 32692, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */
+   { 32717, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */
+   { 32741, 0x000088E2 }, /* GL_STREAM_COPY */
+   { 32756, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
+   { 32775, 0x000088E0 }, /* GL_STREAM_DRAW */
+   { 32790, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
+   { 32809, 0x000088E1 }, /* GL_STREAM_READ */
+   { 32824, 0x000088E1 }, /* GL_STREAM_READ_ARB */
+   { 32843, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
+   { 32860, 0x000084E7 }, /* GL_SUBTRACT */
+   { 32872, 0x000084E7 }, /* GL_SUBTRACT_ARB */
+   { 32888, 0x00009113 }, /* GL_SYNC_CONDITION */
+   { 32906, 0x00009116 }, /* GL_SYNC_FENCE */
+   { 32920, 0x00009115 }, /* GL_SYNC_FLAGS */
+   { 32934, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */
+   { 32961, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+   { 32991, 0x00009114 }, /* GL_SYNC_STATUS */
+   { 33006, 0x00002001 }, /* GL_T */
+   { 33011, 0x00002A2A }, /* GL_T2F_C3F_V3F */
+   { 33026, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
+   { 33045, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
+   { 33061, 0x00002A2B }, /* GL_T2F_N3F_V3F */
+   { 33076, 0x00002A27 }, /* GL_T2F_V3F */
+   { 33087, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
+   { 33106, 0x00002A28 }, /* GL_T4F_V4F */
+   { 33117, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
+   { 33140, 0x00001702 }, /* GL_TEXTURE */
+   { 33151, 0x000084C0 }, /* GL_TEXTURE0 */
+   { 33163, 0x000084C0 }, /* GL_TEXTURE0_ARB */
+   { 33179, 0x000084C1 }, /* GL_TEXTURE1 */
+   { 33191, 0x000084CA }, /* GL_TEXTURE10 */
+   { 33204, 0x000084CA }, /* GL_TEXTURE10_ARB */
+   { 33221, 0x000084CB }, /* GL_TEXTURE11 */
+   { 33234, 0x000084CB }, /* GL_TEXTURE11_ARB */
+   { 33251, 0x000084CC }, /* GL_TEXTURE12 */
+   { 33264, 0x000084CC }, /* GL_TEXTURE12_ARB */
+   { 33281, 0x000084CD }, /* GL_TEXTURE13 */
+   { 33294, 0x000084CD }, /* GL_TEXTURE13_ARB */
+   { 33311, 0x000084CE }, /* GL_TEXTURE14 */
+   { 33324, 0x000084CE }, /* GL_TEXTURE14_ARB */
+   { 33341, 0x000084CF }, /* GL_TEXTURE15 */
+   { 33354, 0x000084CF }, /* GL_TEXTURE15_ARB */
+   { 33371, 0x000084D0 }, /* GL_TEXTURE16 */
+   { 33384, 0x000084D0 }, /* GL_TEXTURE16_ARB */
+   { 33401, 0x000084D1 }, /* GL_TEXTURE17 */
+   { 33414, 0x000084D1 }, /* GL_TEXTURE17_ARB */
+   { 33431, 0x000084D2 }, /* GL_TEXTURE18 */
+   { 33444, 0x000084D2 }, /* GL_TEXTURE18_ARB */
+   { 33461, 0x000084D3 }, /* GL_TEXTURE19 */
+   { 33474, 0x000084D3 }, /* GL_TEXTURE19_ARB */
+   { 33491, 0x000084C1 }, /* GL_TEXTURE1_ARB */
+   { 33507, 0x000084C2 }, /* GL_TEXTURE2 */
+   { 33519, 0x000084D4 }, /* GL_TEXTURE20 */
+   { 33532, 0x000084D4 }, /* GL_TEXTURE20_ARB */
+   { 33549, 0x000084D5 }, /* GL_TEXTURE21 */
+   { 33562, 0x000084D5 }, /* GL_TEXTURE21_ARB */
+   { 33579, 0x000084D6 }, /* GL_TEXTURE22 */
+   { 33592, 0x000084D6 }, /* GL_TEXTURE22_ARB */
+   { 33609, 0x000084D7 }, /* GL_TEXTURE23 */
+   { 33622, 0x000084D7 }, /* GL_TEXTURE23_ARB */
+   { 33639, 0x000084D8 }, /* GL_TEXTURE24 */
+   { 33652, 0x000084D8 }, /* GL_TEXTURE24_ARB */
+   { 33669, 0x000084D9 }, /* GL_TEXTURE25 */
+   { 33682, 0x000084D9 }, /* GL_TEXTURE25_ARB */
+   { 33699, 0x000084DA }, /* GL_TEXTURE26 */
+   { 33712, 0x000084DA }, /* GL_TEXTURE26_ARB */
+   { 33729, 0x000084DB }, /* GL_TEXTURE27 */
+   { 33742, 0x000084DB }, /* GL_TEXTURE27_ARB */
+   { 33759, 0x000084DC }, /* GL_TEXTURE28 */
+   { 33772, 0x000084DC }, /* GL_TEXTURE28_ARB */
+   { 33789, 0x000084DD }, /* GL_TEXTURE29 */
+   { 33802, 0x000084DD }, /* GL_TEXTURE29_ARB */
+   { 33819, 0x000084C2 }, /* GL_TEXTURE2_ARB */
+   { 33835, 0x000084C3 }, /* GL_TEXTURE3 */
+   { 33847, 0x000084DE }, /* GL_TEXTURE30 */
+   { 33860, 0x000084DE }, /* GL_TEXTURE30_ARB */
+   { 33877, 0x000084DF }, /* GL_TEXTURE31 */
+   { 33890, 0x000084DF }, /* GL_TEXTURE31_ARB */
+   { 33907, 0x000084C3 }, /* GL_TEXTURE3_ARB */
+   { 33923, 0x000084C4 }, /* GL_TEXTURE4 */
+   { 33935, 0x000084C4 }, /* GL_TEXTURE4_ARB */
+   { 33951, 0x000084C5 }, /* GL_TEXTURE5 */
+   { 33963, 0x000084C5 }, /* GL_TEXTURE5_ARB */
+   { 33979, 0x000084C6 }, /* GL_TEXTURE6 */
+   { 33991, 0x000084C6 }, /* GL_TEXTURE6_ARB */
+   { 34007, 0x000084C7 }, /* GL_TEXTURE7 */
+   { 34019, 0x000084C7 }, /* GL_TEXTURE7_ARB */
+   { 34035, 0x000084C8 }, /* GL_TEXTURE8 */
+   { 34047, 0x000084C8 }, /* GL_TEXTURE8_ARB */
+   { 34063, 0x000084C9 }, /* GL_TEXTURE9 */
+   { 34075, 0x000084C9 }, /* GL_TEXTURE9_ARB */
+   { 34091, 0x00000DE0 }, /* GL_TEXTURE_1D */
+   { 34105, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
+   { 34129, 0x00000DE1 }, /* GL_TEXTURE_2D */
+   { 34143, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
+   { 34167, 0x0000806F }, /* GL_TEXTURE_3D */
+   { 34181, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
+   { 34203, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
+   { 34229, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
+   { 34251, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
+   { 34273, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
+   { 34305, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
+   { 34327, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
+   { 34359, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
+   { 34381, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
+   { 34409, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
+   { 34441, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+   { 34474, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
+   { 34506, 0x00040000 }, /* GL_TEXTURE_BIT */
+   { 34521, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
+   { 34542, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
+   { 34567, 0x00001005 }, /* GL_TEXTURE_BORDER */
+   { 34585, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
+   { 34609, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+   { 34640, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+   { 34670, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+   { 34700, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+   { 34735, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+   { 34766, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 34804, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
+   { 34831, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+   { 34863, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+   { 34897, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
+   { 34921, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
+   { 34949, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
+   { 34973, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
+   { 35001, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+   { 35034, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
+   { 35058, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
+   { 35080, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
+   { 35102, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
+   { 35128, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
+   { 35162, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+   { 35195, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
+   { 35232, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
+   { 35260, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
+   { 35292, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
+   { 35315, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+   { 35353, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
+   { 35395, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+   { 35426, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+   { 35454, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+   { 35484, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+   { 35512, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
+   { 35532, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
+   { 35556, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+   { 35587, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
+   { 35622, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+   { 35653, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
+   { 35688, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+   { 35719, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
+   { 35754, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+   { 35785, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
+   { 35820, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+   { 35851, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
+   { 35886, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+   { 35917, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
+   { 35952, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+   { 35981, 0x00008071 }, /* GL_TEXTURE_DEPTH */
+   { 35998, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
+   { 36020, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
+   { 36046, 0x00002300 }, /* GL_TEXTURE_ENV */
+   { 36061, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
+   { 36082, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
+   { 36102, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
+   { 36128, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
+   { 36148, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
+   { 36165, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
+   { 36182, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
+   { 36199, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
+   { 36216, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
+   { 36241, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
+   { 36263, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
+   { 36289, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
+   { 36307, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
+   { 36333, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
+   { 36359, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
+   { 36389, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
+   { 36416, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
+   { 36441, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
+   { 36461, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
+   { 36485, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+   { 36512, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+   { 36539, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+   { 36566, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
+   { 36592, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
+   { 36622, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
+   { 36644, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
+   { 36662, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 36692, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+   { 36720, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+   { 36748, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+   { 36776, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
+   { 36797, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
+   { 36816, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
+   { 36838, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
+   { 36857, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
+   { 36877, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+   { 36907, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+   { 36938, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
+   { 36963, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
+   { 36987, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
+   { 37007, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
+   { 37031, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
+   { 37051, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
+   { 37074, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */
+   { 37098, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+   { 37128, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
+   { 37153, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+   { 37187, 0x00001000 }, /* GL_TEXTURE_WIDTH */
+   { 37204, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
+   { 37222, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
+   { 37240, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
+   { 37258, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */
+   { 37277, 0xFFFFFFFFFFFFFFFF }, /* GL_TIMEOUT_IGNORED */
+   { 37296, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
+   { 37316, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
+   { 37335, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+   { 37364, 0x00001000 }, /* GL_TRANSFORM_BIT */
+   { 37381, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
+   { 37407, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
+   { 37437, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+   { 37469, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+   { 37499, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
+   { 37533, 0x0000862C }, /* GL_TRANSPOSE_NV */
+   { 37549, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+   { 37580, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
+   { 37615, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+   { 37643, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
+   { 37675, 0x00000004 }, /* GL_TRIANGLES */
+   { 37688, 0x00000006 }, /* GL_TRIANGLE_FAN */
+   { 37704, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
+   { 37725, 0x00000005 }, /* GL_TRIANGLE_STRIP */
+   { 37743, 0x00000001 }, /* GL_TRUE */
+   { 37751, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
+   { 37771, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
+   { 37794, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
+   { 37814, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
+   { 37835, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
+   { 37857, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
+   { 37879, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
+   { 37899, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
+   { 37920, 0x00009118 }, /* GL_UNSIGNALED */
+   { 37934, 0x00001401 }, /* GL_UNSIGNED_BYTE */
+   { 37951, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+   { 37978, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
+   { 38001, 0x00001405 }, /* GL_UNSIGNED_INT */
+   { 38017, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
+   { 38044, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */
+   { 38065, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
+   { 38089, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+   { 38120, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
+   { 38144, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+   { 38172, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */
+   { 38195, 0x00001403 }, /* GL_UNSIGNED_SHORT */
+   { 38213, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+   { 38243, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+   { 38269, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+   { 38299, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+   { 38325, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
+   { 38349, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+   { 38377, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+   { 38405, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
+   { 38432, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+   { 38464, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
+   { 38495, 0x00008CA2 }, /* GL_UPPER_LEFT */
+   { 38509, 0x00002A20 }, /* GL_V2F */
+   { 38516, 0x00002A21 }, /* GL_V3F */
+   { 38523, 0x00008B83 }, /* GL_VALIDATE_STATUS */
+   { 38542, 0x00001F00 }, /* GL_VENDOR */
+   { 38552, 0x00001F02 }, /* GL_VERSION */
+   { 38563, 0x00008074 }, /* GL_VERTEX_ARRAY */
+   { 38579, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */
+   { 38603, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
+   { 38633, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+   { 38664, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
+   { 38699, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
+   { 38723, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
+   { 38744, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
+   { 38767, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
+   { 38788, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+   { 38815, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+   { 38843, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+   { 38871, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+   { 38899, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+   { 38927, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+   { 38955, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+   { 38983, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+   { 39010, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+   { 39037, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+   { 39064, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+   { 39091, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+   { 39118, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+   { 39145, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+   { 39172, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+   { 39199, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+   { 39226, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+   { 39264, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
+   { 39306, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+   { 39337, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
+   { 39372, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+   { 39406, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
+   { 39444, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+   { 39475, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
+   { 39510, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+   { 39538, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
+   { 39570, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+   { 39600, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
+   { 39634, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+   { 39662, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
+   { 39694, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
+   { 39714, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
+   { 39736, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
+   { 39765, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
+   { 39786, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
+   { 39815, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
+   { 39848, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
+   { 39880, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+   { 39907, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
+   { 39938, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
+   { 39968, 0x00008B31 }, /* GL_VERTEX_SHADER */
+   { 39985, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
+   { 40006, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
+   { 40033, 0x00000BA2 }, /* GL_VIEWPORT */
+   { 40045, 0x00000800 }, /* GL_VIEWPORT_BIT */
+   { 40061, 0x0000911D }, /* GL_WAIT_FAILED */
+   { 40076, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
+   { 40096, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+   { 40127, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
+   { 40162, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+   { 40190, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+   { 40215, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+   { 40242, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+   { 40267, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
+   { 40291, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
+   { 40310, 0x000088B9 }, /* GL_WRITE_ONLY */
+   { 40324, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
+   { 40342, 0x00001506 }, /* GL_XOR */
+   { 40349, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
+   { 40368, 0x00008757 }, /* GL_YCBCR_MESA */
+   { 40382, 0x00000000 }, /* GL_ZERO */
+   { 40390, 0x00000D16 }, /* GL_ZOOM_X */
+   { 40400, 0x00000D17 }, /* GL_ZOOM_Y */
 };
 
 static const unsigned reduced_enums[1347] =
 {
-       475, /* GL_FALSE */
-       691, /* GL_LINES */
-       693, /* GL_LINE_LOOP */
-       700, /* GL_LINE_STRIP */
-      1743, /* GL_TRIANGLES */
-      1746, /* GL_TRIANGLE_STRIP */
-      1744, /* GL_TRIANGLE_FAN */
-      1271, /* GL_QUADS */
-      1274, /* GL_QUAD_STRIP */
-      1158, /* GL_POLYGON */
-      1170, /* GL_POLYGON_STIPPLE_BIT */
-      1119, /* GL_PIXEL_MODE_BIT */
-       678, /* GL_LIGHTING_BIT */
-       504, /* GL_FOG_BIT */
+       476, /* GL_FALSE */
+       694, /* GL_LINES */
+       696, /* GL_LINE_LOOP */
+       703, /* GL_LINE_STRIP */
+      1748, /* GL_TRIANGLES */
+      1751, /* GL_TRIANGLE_STRIP */
+      1749, /* GL_TRIANGLE_FAN */
+      1275, /* GL_QUADS */
+      1279, /* GL_QUAD_STRIP */
+      1161, /* GL_POLYGON */
+      1173, /* GL_POLYGON_STIPPLE_BIT */
+      1122, /* GL_PIXEL_MODE_BIT */
+       681, /* GL_LIGHTING_BIT */
+       506, /* GL_FOG_BIT */
          8, /* GL_ACCUM */
-       710, /* GL_LOAD */
-      1326, /* GL_RETURN */
-       991, /* GL_MULT */
+       713, /* GL_LOAD */
+      1331, /* GL_RETURN */
+       994, /* GL_MULT */
         23, /* GL_ADD */
-      1007, /* GL_NEVER */
-       668, /* GL_LESS */
-       465, /* GL_EQUAL */
-       667, /* GL_LEQUAL */
-       590, /* GL_GREATER */
-      1022, /* GL_NOTEQUAL */
-       589, /* GL_GEQUAL */
+      1010, /* GL_NEVER */
+       671, /* GL_LESS */
+       466, /* GL_EQUAL */
+       670, /* GL_LEQUAL */
+       592, /* GL_GREATER */
+      1025, /* GL_NOTEQUAL */
+       591, /* GL_GEQUAL */
         47, /* GL_ALWAYS */
-      1467, /* GL_SRC_COLOR */
-      1052, /* GL_ONE_MINUS_SRC_COLOR */
-      1465, /* GL_SRC_ALPHA */
-      1051, /* GL_ONE_MINUS_SRC_ALPHA */
-       444, /* GL_DST_ALPHA */
-      1049, /* GL_ONE_MINUS_DST_ALPHA */
-       445, /* GL_DST_COLOR */
-      1050, /* GL_ONE_MINUS_DST_COLOR */
-      1466, /* GL_SRC_ALPHA_SATURATE */
-       577, /* GL_FRONT_LEFT */
-       578, /* GL_FRONT_RIGHT */
+      1472, /* GL_SRC_COLOR */
+      1055, /* GL_ONE_MINUS_SRC_COLOR */
+      1470, /* GL_SRC_ALPHA */
+      1054, /* GL_ONE_MINUS_SRC_ALPHA */
+       445, /* GL_DST_ALPHA */
+      1052, /* GL_ONE_MINUS_DST_ALPHA */
+       446, /* GL_DST_COLOR */
+      1053, /* GL_ONE_MINUS_DST_COLOR */
+      1471, /* GL_SRC_ALPHA_SATURATE */
+       579, /* GL_FRONT_LEFT */
+       580, /* GL_FRONT_RIGHT */
         69, /* GL_BACK_LEFT */
         70, /* GL_BACK_RIGHT */
-       574, /* GL_FRONT */
+       576, /* GL_FRONT */
         68, /* GL_BACK */
-       666, /* GL_LEFT */
-      1368, /* GL_RIGHT */
-       575, /* GL_FRONT_AND_BACK */
+       669, /* GL_LEFT */
+      1373, /* GL_RIGHT */
+       577, /* GL_FRONT_AND_BACK */
         63, /* GL_AUX0 */
         64, /* GL_AUX1 */
         65, /* GL_AUX2 */
         66, /* GL_AUX3 */
-       656, /* GL_INVALID_ENUM */
-       660, /* GL_INVALID_VALUE */
-       659, /* GL_INVALID_OPERATION */
-      1472, /* GL_STACK_OVERFLOW */
-      1473, /* GL_STACK_UNDERFLOW */
-      1077, /* GL_OUT_OF_MEMORY */
-       657, /* GL_INVALID_FRAMEBUFFER_OPERATION */
+       658, /* GL_INVALID_ENUM */
+       662, /* GL_INVALID_VALUE */
+       661, /* GL_INVALID_OPERATION */
+      1477, /* GL_STACK_OVERFLOW */
+      1478, /* GL_STACK_UNDERFLOW */
+      1080, /* GL_OUT_OF_MEMORY */
+       659, /* GL_INVALID_FRAMEBUFFER_OPERATION */
          0, /* GL_2D */
          2, /* GL_3D */
          3, /* GL_3D_COLOR */
          4, /* GL_3D_COLOR_TEXTURE */
          6, /* GL_4D_COLOR_TEXTURE */
-      1097, /* GL_PASS_THROUGH_TOKEN */
-      1157, /* GL_POINT_TOKEN */
-       701, /* GL_LINE_TOKEN */
-      1171, /* GL_POLYGON_TOKEN */
+      1100, /* GL_PASS_THROUGH_TOKEN */
+      1160, /* GL_POINT_TOKEN */
+       704, /* GL_LINE_TOKEN */
+      1174, /* GL_POLYGON_TOKEN */
         74, /* GL_BITMAP_TOKEN */
-       443, /* GL_DRAW_PIXEL_TOKEN */
+       444, /* GL_DRAW_PIXEL_TOKEN */
        301, /* GL_COPY_PIXEL_TOKEN */
-       694, /* GL_LINE_RESET_TOKEN */
-       468, /* GL_EXP */
-       469, /* GL_EXP2 */
+       697, /* GL_LINE_RESET_TOKEN */
+       469, /* GL_EXP */
+       470, /* GL_EXP2 */
        337, /* GL_CW */
        125, /* GL_CCW */
        146, /* GL_COEFF */
-      1074, /* GL_ORDER */
-       381, /* GL_DOMAIN */
+      1077, /* GL_ORDER */
+       382, /* GL_DOMAIN */
        311, /* GL_CURRENT_COLOR */
        314, /* GL_CURRENT_INDEX */
        320, /* GL_CURRENT_NORMAL */
@@ -3844,519 +3854,519 @@ static const unsigned reduced_enums[1347] =
        328, /* GL_CURRENT_RASTER_POSITION */
        329, /* GL_CURRENT_RASTER_POSITION_VALID */
        326, /* GL_CURRENT_RASTER_DISTANCE */
-      1150, /* GL_POINT_SMOOTH */
-      1139, /* GL_POINT_SIZE */
-      1149, /* GL_POINT_SIZE_RANGE */
-      1140, /* GL_POINT_SIZE_GRANULARITY */
-       695, /* GL_LINE_SMOOTH */
-       702, /* GL_LINE_WIDTH */
-       704, /* GL_LINE_WIDTH_RANGE */
-       703, /* GL_LINE_WIDTH_GRANULARITY */
-       697, /* GL_LINE_STIPPLE */
-       698, /* GL_LINE_STIPPLE_PATTERN */
-       699, /* GL_LINE_STIPPLE_REPEAT */
-       709, /* GL_LIST_MODE */
-       874, /* GL_MAX_LIST_NESTING */
-       706, /* GL_LIST_BASE */
-       708, /* GL_LIST_INDEX */
-      1160, /* GL_POLYGON_MODE */
-      1167, /* GL_POLYGON_SMOOTH */
-      1169, /* GL_POLYGON_STIPPLE */
-       454, /* GL_EDGE_FLAG */
+      1153, /* GL_POINT_SMOOTH */
+      1142, /* GL_POINT_SIZE */
+      1152, /* GL_POINT_SIZE_RANGE */
+      1143, /* GL_POINT_SIZE_GRANULARITY */
+       698, /* GL_LINE_SMOOTH */
+       705, /* GL_LINE_WIDTH */
+       707, /* GL_LINE_WIDTH_RANGE */
+       706, /* GL_LINE_WIDTH_GRANULARITY */
+       700, /* GL_LINE_STIPPLE */
+       701, /* GL_LINE_STIPPLE_PATTERN */
+       702, /* GL_LINE_STIPPLE_REPEAT */
+       712, /* GL_LIST_MODE */
+       877, /* GL_MAX_LIST_NESTING */
+       709, /* GL_LIST_BASE */
+       711, /* GL_LIST_INDEX */
+      1163, /* GL_POLYGON_MODE */
+      1170, /* GL_POLYGON_SMOOTH */
+      1172, /* GL_POLYGON_STIPPLE */
+       455, /* GL_EDGE_FLAG */
        304, /* GL_CULL_FACE */
        305, /* GL_CULL_FACE_MODE */
-       576, /* GL_FRONT_FACE */
-       677, /* GL_LIGHTING */
-       682, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-       683, /* GL_LIGHT_MODEL_TWO_SIDE */
-       679, /* GL_LIGHT_MODEL_AMBIENT */
-      1414, /* GL_SHADE_MODEL */
+       578, /* GL_FRONT_FACE */
+       680, /* GL_LIGHTING */
+       685, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+       686, /* GL_LIGHT_MODEL_TWO_SIDE */
+       682, /* GL_LIGHT_MODEL_AMBIENT */
+      1419, /* GL_SHADE_MODEL */
        193, /* GL_COLOR_MATERIAL_FACE */
        194, /* GL_COLOR_MATERIAL_PARAMETER */
        192, /* GL_COLOR_MATERIAL */
-       503, /* GL_FOG */
-       525, /* GL_FOG_INDEX */
-       521, /* GL_FOG_DENSITY */
-       529, /* GL_FOG_START */
-       523, /* GL_FOG_END */
-       526, /* GL_FOG_MODE */
-       505, /* GL_FOG_COLOR */
-       368, /* GL_DEPTH_RANGE */
-       375, /* GL_DEPTH_TEST */
-       378, /* GL_DEPTH_WRITEMASK */
-       356, /* GL_DEPTH_CLEAR_VALUE */
-       367, /* GL_DEPTH_FUNC */
+       505, /* GL_FOG */
+       527, /* GL_FOG_INDEX */
+       523, /* GL_FOG_DENSITY */
+       531, /* GL_FOG_START */
+       525, /* GL_FOG_END */
+       528, /* GL_FOG_MODE */
+       507, /* GL_FOG_COLOR */
+       369, /* GL_DEPTH_RANGE */
+       376, /* GL_DEPTH_TEST */
+       379, /* GL_DEPTH_WRITEMASK */
+       357, /* GL_DEPTH_CLEAR_VALUE */
+       368, /* GL_DEPTH_FUNC */
         12, /* GL_ACCUM_CLEAR_VALUE */
-      1508, /* GL_STENCIL_TEST */
-      1496, /* GL_STENCIL_CLEAR_VALUE */
-      1498, /* GL_STENCIL_FUNC */
-      1510, /* GL_STENCIL_VALUE_MASK */
-      1497, /* GL_STENCIL_FAIL */
-      1505, /* GL_STENCIL_PASS_DEPTH_FAIL */
-      1506, /* GL_STENCIL_PASS_DEPTH_PASS */
-      1507, /* GL_STENCIL_REF */
-      1511, /* GL_STENCIL_WRITEMASK */
-       843, /* GL_MATRIX_MODE */
-      1012, /* GL_NORMALIZE */
-      1837, /* GL_VIEWPORT */
-       986, /* GL_MODELVIEW_STACK_DEPTH */
-      1250, /* GL_PROJECTION_STACK_DEPTH */
-      1718, /* GL_TEXTURE_STACK_DEPTH */
-       984, /* GL_MODELVIEW_MATRIX */
-      1249, /* GL_PROJECTION_MATRIX */
-      1701, /* GL_TEXTURE_MATRIX */
+      1513, /* GL_STENCIL_TEST */
+      1501, /* GL_STENCIL_CLEAR_VALUE */
+      1503, /* GL_STENCIL_FUNC */
+      1515, /* GL_STENCIL_VALUE_MASK */
+      1502, /* GL_STENCIL_FAIL */
+      1510, /* GL_STENCIL_PASS_DEPTH_FAIL */
+      1511, /* GL_STENCIL_PASS_DEPTH_PASS */
+      1512, /* GL_STENCIL_REF */
+      1516, /* GL_STENCIL_WRITEMASK */
+       846, /* GL_MATRIX_MODE */
+      1015, /* GL_NORMALIZE */
+      1842, /* GL_VIEWPORT */
+       989, /* GL_MODELVIEW_STACK_DEPTH */
+      1253, /* GL_PROJECTION_STACK_DEPTH */
+      1723, /* GL_TEXTURE_STACK_DEPTH */
+       987, /* GL_MODELVIEW_MATRIX */
+      1252, /* GL_PROJECTION_MATRIX */
+      1706, /* GL_TEXTURE_MATRIX */
         61, /* GL_ATTRIB_STACK_DEPTH */
        136, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
         43, /* GL_ALPHA_TEST */
         44, /* GL_ALPHA_TEST_FUNC */
         45, /* GL_ALPHA_TEST_REF */
-       380, /* GL_DITHER */
+       381, /* GL_DITHER */
         78, /* GL_BLEND_DST */
         87, /* GL_BLEND_SRC */
         75, /* GL_BLEND */
-       712, /* GL_LOGIC_OP_MODE */
-       630, /* GL_INDEX_LOGIC_OP */
+       715, /* GL_LOGIC_OP_MODE */
+       632, /* GL_INDEX_LOGIC_OP */
        191, /* GL_COLOR_LOGIC_OP */
         67, /* GL_AUX_BUFFERS */
-       391, /* GL_DRAW_BUFFER */
-      1284, /* GL_READ_BUFFER */
-      1395, /* GL_SCISSOR_BOX */
-      1396, /* GL_SCISSOR_TEST */
-       629, /* GL_INDEX_CLEAR_VALUE */
-       634, /* GL_INDEX_WRITEMASK */
+       392, /* GL_DRAW_BUFFER */
+      1289, /* GL_READ_BUFFER */
+      1400, /* GL_SCISSOR_BOX */
+      1401, /* GL_SCISSOR_TEST */
+       631, /* GL_INDEX_CLEAR_VALUE */
+       636, /* GL_INDEX_WRITEMASK */
        188, /* GL_COLOR_CLEAR_VALUE */
        230, /* GL_COLOR_WRITEMASK */
-       631, /* GL_INDEX_MODE */
-      1361, /* GL_RGBA_MODE */
-       390, /* GL_DOUBLEBUFFER */
-      1512, /* GL_STEREO */
-      1319, /* GL_RENDER_MODE */
-      1098, /* GL_PERSPECTIVE_CORRECTION_HINT */
-      1151, /* GL_POINT_SMOOTH_HINT */
-       696, /* GL_LINE_SMOOTH_HINT */
-      1168, /* GL_POLYGON_SMOOTH_HINT */
-       524, /* GL_FOG_HINT */
-      1682, /* GL_TEXTURE_GEN_S */
-      1683, /* GL_TEXTURE_GEN_T */
-      1681, /* GL_TEXTURE_GEN_R */
-      1680, /* GL_TEXTURE_GEN_Q */
-      1111, /* GL_PIXEL_MAP_I_TO_I */
-      1117, /* GL_PIXEL_MAP_S_TO_S */
-      1113, /* GL_PIXEL_MAP_I_TO_R */
-      1109, /* GL_PIXEL_MAP_I_TO_G */
-      1107, /* GL_PIXEL_MAP_I_TO_B */
-      1105, /* GL_PIXEL_MAP_I_TO_A */
-      1115, /* GL_PIXEL_MAP_R_TO_R */
-      1103, /* GL_PIXEL_MAP_G_TO_G */
-      1101, /* GL_PIXEL_MAP_B_TO_B */
-      1099, /* GL_PIXEL_MAP_A_TO_A */
-      1112, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-      1118, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-      1114, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-      1110, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-      1108, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-      1106, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-      1116, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-      1104, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-      1102, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-      1100, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-      1755, /* GL_UNPACK_SWAP_BYTES */
-      1750, /* GL_UNPACK_LSB_FIRST */
-      1751, /* GL_UNPACK_ROW_LENGTH */
-      1754, /* GL_UNPACK_SKIP_ROWS */
-      1753, /* GL_UNPACK_SKIP_PIXELS */
-      1748, /* GL_UNPACK_ALIGNMENT */
-      1086, /* GL_PACK_SWAP_BYTES */
-      1081, /* GL_PACK_LSB_FIRST */
-      1082, /* GL_PACK_ROW_LENGTH */
-      1085, /* GL_PACK_SKIP_ROWS */
-      1084, /* GL_PACK_SKIP_PIXELS */
-      1078, /* GL_PACK_ALIGNMENT */
-       790, /* GL_MAP_COLOR */
-       795, /* GL_MAP_STENCIL */
-       633, /* GL_INDEX_SHIFT */
-       632, /* GL_INDEX_OFFSET */
-      1297, /* GL_RED_SCALE */
-      1295, /* GL_RED_BIAS */
-      1855, /* GL_ZOOM_X */
-      1856, /* GL_ZOOM_Y */
-       594, /* GL_GREEN_SCALE */
-       592, /* GL_GREEN_BIAS */
+       633, /* GL_INDEX_MODE */
+      1366, /* GL_RGBA_MODE */
+       391, /* GL_DOUBLEBUFFER */
+      1517, /* GL_STEREO */
+      1324, /* GL_RENDER_MODE */
+      1101, /* GL_PERSPECTIVE_CORRECTION_HINT */
+      1154, /* GL_POINT_SMOOTH_HINT */
+       699, /* GL_LINE_SMOOTH_HINT */
+      1171, /* GL_POLYGON_SMOOTH_HINT */
+       526, /* GL_FOG_HINT */
+      1687, /* GL_TEXTURE_GEN_S */
+      1688, /* GL_TEXTURE_GEN_T */
+      1686, /* GL_TEXTURE_GEN_R */
+      1685, /* GL_TEXTURE_GEN_Q */
+      1114, /* GL_PIXEL_MAP_I_TO_I */
+      1120, /* GL_PIXEL_MAP_S_TO_S */
+      1116, /* GL_PIXEL_MAP_I_TO_R */
+      1112, /* GL_PIXEL_MAP_I_TO_G */
+      1110, /* GL_PIXEL_MAP_I_TO_B */
+      1108, /* GL_PIXEL_MAP_I_TO_A */
+      1118, /* GL_PIXEL_MAP_R_TO_R */
+      1106, /* GL_PIXEL_MAP_G_TO_G */
+      1104, /* GL_PIXEL_MAP_B_TO_B */
+      1102, /* GL_PIXEL_MAP_A_TO_A */
+      1115, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+      1121, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+      1117, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+      1113, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+      1111, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+      1109, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+      1119, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+      1107, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+      1105, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+      1103, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+      1760, /* GL_UNPACK_SWAP_BYTES */
+      1755, /* GL_UNPACK_LSB_FIRST */
+      1756, /* GL_UNPACK_ROW_LENGTH */
+      1759, /* GL_UNPACK_SKIP_ROWS */
+      1758, /* GL_UNPACK_SKIP_PIXELS */
+      1753, /* GL_UNPACK_ALIGNMENT */
+      1089, /* GL_PACK_SWAP_BYTES */
+      1084, /* GL_PACK_LSB_FIRST */
+      1085, /* GL_PACK_ROW_LENGTH */
+      1088, /* GL_PACK_SKIP_ROWS */
+      1087, /* GL_PACK_SKIP_PIXELS */
+      1081, /* GL_PACK_ALIGNMENT */
+       793, /* GL_MAP_COLOR */
+       798, /* GL_MAP_STENCIL */
+       635, /* GL_INDEX_SHIFT */
+       634, /* GL_INDEX_OFFSET */
+      1302, /* GL_RED_SCALE */
+      1300, /* GL_RED_BIAS */
+      1860, /* GL_ZOOM_X */
+      1861, /* GL_ZOOM_Y */
+       596, /* GL_GREEN_SCALE */
+       594, /* GL_GREEN_BIAS */
         93, /* GL_BLUE_SCALE */
         91, /* GL_BLUE_BIAS */
         42, /* GL_ALPHA_SCALE */
         40, /* GL_ALPHA_BIAS */
-       369, /* GL_DEPTH_SCALE */
+       370, /* GL_DEPTH_SCALE */
        350, /* GL_DEPTH_BIAS */
-       869, /* GL_MAX_EVAL_ORDER */
-       873, /* GL_MAX_LIGHTS */
-       852, /* GL_MAX_CLIP_PLANES */
-       919, /* GL_MAX_TEXTURE_SIZE */
-       879, /* GL_MAX_PIXEL_MAP_TABLE */
-       848, /* GL_MAX_ATTRIB_STACK_DEPTH */
-       876, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-       877, /* GL_MAX_NAME_STACK_DEPTH */
-       905, /* GL_MAX_PROJECTION_STACK_DEPTH */
-       920, /* GL_MAX_TEXTURE_STACK_DEPTH */
-       934, /* GL_MAX_VIEWPORT_DIMS */
-       849, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-      1522, /* GL_SUBPIXEL_BITS */
-       628, /* GL_INDEX_BITS */
-      1296, /* GL_RED_BITS */
-       593, /* GL_GREEN_BITS */
+       872, /* GL_MAX_EVAL_ORDER */
+       876, /* GL_MAX_LIGHTS */
+       855, /* GL_MAX_CLIP_PLANES */
+       922, /* GL_MAX_TEXTURE_SIZE */
+       882, /* GL_MAX_PIXEL_MAP_TABLE */
+       851, /* GL_MAX_ATTRIB_STACK_DEPTH */
+       879, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+       880, /* GL_MAX_NAME_STACK_DEPTH */
+       908, /* GL_MAX_PROJECTION_STACK_DEPTH */
+       923, /* GL_MAX_TEXTURE_STACK_DEPTH */
+       937, /* GL_MAX_VIEWPORT_DIMS */
+       852, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+      1527, /* GL_SUBPIXEL_BITS */
+       630, /* GL_INDEX_BITS */
+      1301, /* GL_RED_BITS */
+       595, /* GL_GREEN_BITS */
         92, /* GL_BLUE_BITS */
         41, /* GL_ALPHA_BITS */
        351, /* GL_DEPTH_BITS */
-      1494, /* GL_STENCIL_BITS */
+      1499, /* GL_STENCIL_BITS */
         14, /* GL_ACCUM_RED_BITS */
         13, /* GL_ACCUM_GREEN_BITS */
         10, /* GL_ACCUM_BLUE_BITS */
          9, /* GL_ACCUM_ALPHA_BITS */
-      1000, /* GL_NAME_STACK_DEPTH */
+      1003, /* GL_NAME_STACK_DEPTH */
         62, /* GL_AUTO_NORMAL */
-       736, /* GL_MAP1_COLOR_4 */
-       739, /* GL_MAP1_INDEX */
-       740, /* GL_MAP1_NORMAL */
-       741, /* GL_MAP1_TEXTURE_COORD_1 */
-       742, /* GL_MAP1_TEXTURE_COORD_2 */
-       743, /* GL_MAP1_TEXTURE_COORD_3 */
-       744, /* GL_MAP1_TEXTURE_COORD_4 */
-       745, /* GL_MAP1_VERTEX_3 */
-       746, /* GL_MAP1_VERTEX_4 */
-       763, /* GL_MAP2_COLOR_4 */
-       766, /* GL_MAP2_INDEX */
-       767, /* GL_MAP2_NORMAL */
-       768, /* GL_MAP2_TEXTURE_COORD_1 */
-       769, /* GL_MAP2_TEXTURE_COORD_2 */
-       770, /* GL_MAP2_TEXTURE_COORD_3 */
-       771, /* GL_MAP2_TEXTURE_COORD_4 */
-       772, /* GL_MAP2_VERTEX_3 */
-       773, /* GL_MAP2_VERTEX_4 */
-       737, /* GL_MAP1_GRID_DOMAIN */
-       738, /* GL_MAP1_GRID_SEGMENTS */
-       764, /* GL_MAP2_GRID_DOMAIN */
-       765, /* GL_MAP2_GRID_SEGMENTS */
-      1605, /* GL_TEXTURE_1D */
-      1607, /* GL_TEXTURE_2D */
-       478, /* GL_FEEDBACK_BUFFER_POINTER */
-       479, /* GL_FEEDBACK_BUFFER_SIZE */
-       480, /* GL_FEEDBACK_BUFFER_TYPE */
-      1405, /* GL_SELECTION_BUFFER_POINTER */
-      1406, /* GL_SELECTION_BUFFER_SIZE */
-      1723, /* GL_TEXTURE_WIDTH */
-      1687, /* GL_TEXTURE_HEIGHT */
-      1642, /* GL_TEXTURE_COMPONENTS */
-      1626, /* GL_TEXTURE_BORDER_COLOR */
-      1625, /* GL_TEXTURE_BORDER */
-       382, /* GL_DONT_CARE */
-       476, /* GL_FASTEST */
-      1008, /* GL_NICEST */
+       739, /* GL_MAP1_COLOR_4 */
+       742, /* GL_MAP1_INDEX */
+       743, /* GL_MAP1_NORMAL */
+       744, /* GL_MAP1_TEXTURE_COORD_1 */
+       745, /* GL_MAP1_TEXTURE_COORD_2 */
+       746, /* GL_MAP1_TEXTURE_COORD_3 */
+       747, /* GL_MAP1_TEXTURE_COORD_4 */
+       748, /* GL_MAP1_VERTEX_3 */
+       749, /* GL_MAP1_VERTEX_4 */
+       766, /* GL_MAP2_COLOR_4 */
+       769, /* GL_MAP2_INDEX */
+       770, /* GL_MAP2_NORMAL */
+       771, /* GL_MAP2_TEXTURE_COORD_1 */
+       772, /* GL_MAP2_TEXTURE_COORD_2 */
+       773, /* GL_MAP2_TEXTURE_COORD_3 */
+       774, /* GL_MAP2_TEXTURE_COORD_4 */
+       775, /* GL_MAP2_VERTEX_3 */
+       776, /* GL_MAP2_VERTEX_4 */
+       740, /* GL_MAP1_GRID_DOMAIN */
+       741, /* GL_MAP1_GRID_SEGMENTS */
+       767, /* GL_MAP2_GRID_DOMAIN */
+       768, /* GL_MAP2_GRID_SEGMENTS */
+      1610, /* GL_TEXTURE_1D */
+      1612, /* GL_TEXTURE_2D */
+       479, /* GL_FEEDBACK_BUFFER_POINTER */
+       480, /* GL_FEEDBACK_BUFFER_SIZE */
+       481, /* GL_FEEDBACK_BUFFER_TYPE */
+      1410, /* GL_SELECTION_BUFFER_POINTER */
+      1411, /* GL_SELECTION_BUFFER_SIZE */
+      1728, /* GL_TEXTURE_WIDTH */
+      1692, /* GL_TEXTURE_HEIGHT */
+      1647, /* GL_TEXTURE_COMPONENTS */
+      1631, /* GL_TEXTURE_BORDER_COLOR */
+      1630, /* GL_TEXTURE_BORDER */
+       383, /* GL_DONT_CARE */
+       477, /* GL_FASTEST */
+      1011, /* GL_NICEST */
         48, /* GL_AMBIENT */
-       379, /* GL_DIFFUSE */
-      1454, /* GL_SPECULAR */
-      1172, /* GL_POSITION */
-      1457, /* GL_SPOT_DIRECTION */
-      1458, /* GL_SPOT_EXPONENT */
-      1456, /* GL_SPOT_CUTOFF */
+       380, /* GL_DIFFUSE */
+      1459, /* GL_SPECULAR */
+      1175, /* GL_POSITION */
+      1462, /* GL_SPOT_DIRECTION */
+      1463, /* GL_SPOT_EXPONENT */
+      1461, /* GL_SPOT_CUTOFF */
        275, /* GL_CONSTANT_ATTENUATION */
-       686, /* GL_LINEAR_ATTENUATION */
-      1270, /* GL_QUADRATIC_ATTENUATION */
+       689, /* GL_LINEAR_ATTENUATION */
+      1274, /* GL_QUADRATIC_ATTENUATION */
        244, /* GL_COMPILE */
        245, /* GL_COMPILE_AND_EXECUTE */
        120, /* GL_BYTE */
-      1757, /* GL_UNSIGNED_BYTE */
-      1419, /* GL_SHORT */
-      1768, /* GL_UNSIGNED_SHORT */
-       636, /* GL_INT */
-      1760, /* GL_UNSIGNED_INT */
-       484, /* GL_FLOAT */
+      1762, /* GL_UNSIGNED_BYTE */
+      1424, /* GL_SHORT */
+      1773, /* GL_UNSIGNED_SHORT */
+       638, /* GL_INT */
+      1765, /* GL_UNSIGNED_INT */
+       486, /* GL_FLOAT */
          1, /* GL_2_BYTES */
          5, /* GL_3_BYTES */
          7, /* GL_4_BYTES */
-       389, /* GL_DOUBLE */
+       390, /* GL_DOUBLE */
        132, /* GL_CLEAR */
         50, /* GL_AND */
         52, /* GL_AND_REVERSE */
        299, /* GL_COPY */
         51, /* GL_AND_INVERTED */
-      1010, /* GL_NOOP */
-      1851, /* GL_XOR */
-      1073, /* GL_OR */
-      1011, /* GL_NOR */
-       466, /* GL_EQUIV */
-       663, /* GL_INVERT */
-      1076, /* GL_OR_REVERSE */
+      1013, /* GL_NOOP */
+      1856, /* GL_XOR */
+      1076, /* GL_OR */
+      1014, /* GL_NOR */
+       467, /* GL_EQUIV */
+       665, /* GL_INVERT */
+      1079, /* GL_OR_REVERSE */
        300, /* GL_COPY_INVERTED */
-      1075, /* GL_OR_INVERTED */
-      1001, /* GL_NAND */
-      1410, /* GL_SET */
-       463, /* GL_EMISSION */
-      1418, /* GL_SHININESS */
+      1078, /* GL_OR_INVERTED */
+      1004, /* GL_NAND */
+      1415, /* GL_SET */
+       464, /* GL_EMISSION */
+      1423, /* GL_SHININESS */
         49, /* GL_AMBIENT_AND_DIFFUSE */
        190, /* GL_COLOR_INDEXES */
-       951, /* GL_MODELVIEW */
-      1248, /* GL_PROJECTION */
-      1540, /* GL_TEXTURE */
+       954, /* GL_MODELVIEW */
+      1251, /* GL_PROJECTION */
+      1545, /* GL_TEXTURE */
        147, /* GL_COLOR */
        346, /* GL_DEPTH */
-      1480, /* GL_STENCIL */
+      1485, /* GL_STENCIL */
        189, /* GL_COLOR_INDEX */
-      1499, /* GL_STENCIL_INDEX */
-       357, /* GL_DEPTH_COMPONENT */
-      1292, /* GL_RED */
-       591, /* GL_GREEN */
+      1504, /* GL_STENCIL_INDEX */
+       358, /* GL_DEPTH_COMPONENT */
+      1297, /* GL_RED */
+       593, /* GL_GREEN */
         90, /* GL_BLUE */
         31, /* GL_ALPHA */
-      1327, /* GL_RGB */
-      1346, /* GL_RGBA */
-       714, /* GL_LUMINANCE */
-       735, /* GL_LUMINANCE_ALPHA */
+      1332, /* GL_RGB */
+      1351, /* GL_RGBA */
+       717, /* GL_LUMINANCE */
+       738, /* GL_LUMINANCE_ALPHA */
         73, /* GL_BITMAP */
-      1128, /* GL_POINT */
-       684, /* GL_LINE */
-       481, /* GL_FILL */
-      1301, /* GL_RENDER */
-       477, /* GL_FEEDBACK */
-      1404, /* GL_SELECT */
-       483, /* GL_FLAT */
-      1429, /* GL_SMOOTH */
-       664, /* GL_KEEP */
-      1321, /* GL_REPLACE */
-       618, /* GL_INCR */
+      1131, /* GL_POINT */
+       687, /* GL_LINE */
+       482, /* GL_FILL */
+      1306, /* GL_RENDER */
+       478, /* GL_FEEDBACK */
+      1409, /* GL_SELECT */
+       485, /* GL_FLAT */
+      1434, /* GL_SMOOTH */
+       666, /* GL_KEEP */
+      1326, /* GL_REPLACE */
+       620, /* GL_INCR */
        342, /* GL_DECR */
-      1783, /* GL_VENDOR */
-      1318, /* GL_RENDERER */
-      1784, /* GL_VERSION */
-       470, /* GL_EXTENSIONS */
-      1369, /* GL_S */
-      1531, /* GL_T */
-      1281, /* GL_R */
-      1269, /* GL_Q */
-       987, /* GL_MODULATE */
+      1788, /* GL_VENDOR */
+      1323, /* GL_RENDERER */
+      1789, /* GL_VERSION */
+       471, /* GL_EXTENSIONS */
+      1374, /* GL_S */
+      1536, /* GL_T */
+      1286, /* GL_R */
+      1273, /* GL_Q */
+       990, /* GL_MODULATE */
        341, /* GL_DECAL */
-      1677, /* GL_TEXTURE_ENV_MODE */
-      1676, /* GL_TEXTURE_ENV_COLOR */
-      1675, /* GL_TEXTURE_ENV */
-       471, /* GL_EYE_LINEAR */
-      1034, /* GL_OBJECT_LINEAR */
-      1455, /* GL_SPHERE_MAP */
-      1679, /* GL_TEXTURE_GEN_MODE */
-      1036, /* GL_OBJECT_PLANE */
-       472, /* GL_EYE_PLANE */
-      1002, /* GL_NEAREST */
-       685, /* GL_LINEAR */
-      1006, /* GL_NEAREST_MIPMAP_NEAREST */
-       690, /* GL_LINEAR_MIPMAP_NEAREST */
-      1005, /* GL_NEAREST_MIPMAP_LINEAR */
-       689, /* GL_LINEAR_MIPMAP_LINEAR */
-      1700, /* GL_TEXTURE_MAG_FILTER */
-      1708, /* GL_TEXTURE_MIN_FILTER */
-      1725, /* GL_TEXTURE_WRAP_S */
-      1726, /* GL_TEXTURE_WRAP_T */
+      1682, /* GL_TEXTURE_ENV_MODE */
+      1681, /* GL_TEXTURE_ENV_COLOR */
+      1680, /* GL_TEXTURE_ENV */
+       472, /* GL_EYE_LINEAR */
+      1037, /* GL_OBJECT_LINEAR */
+      1460, /* GL_SPHERE_MAP */
+      1684, /* GL_TEXTURE_GEN_MODE */
+      1039, /* GL_OBJECT_PLANE */
+       473, /* GL_EYE_PLANE */
+      1005, /* GL_NEAREST */
+       688, /* GL_LINEAR */
+      1009, /* GL_NEAREST_MIPMAP_NEAREST */
+       693, /* GL_LINEAR_MIPMAP_NEAREST */
+      1008, /* GL_NEAREST_MIPMAP_LINEAR */
+       692, /* GL_LINEAR_MIPMAP_LINEAR */
+      1705, /* GL_TEXTURE_MAG_FILTER */
+      1713, /* GL_TEXTURE_MIN_FILTER */
+      1730, /* GL_TEXTURE_WRAP_S */
+      1731, /* GL_TEXTURE_WRAP_T */
        126, /* GL_CLAMP */
-      1320, /* GL_REPEAT */
-      1166, /* GL_POLYGON_OFFSET_UNITS */
-      1165, /* GL_POLYGON_OFFSET_POINT */
-      1164, /* GL_POLYGON_OFFSET_LINE */
-      1282, /* GL_R3_G3_B2 */
-      1780, /* GL_V2F */
-      1781, /* GL_V3F */
+      1325, /* GL_REPEAT */
+      1169, /* GL_POLYGON_OFFSET_UNITS */
+      1168, /* GL_POLYGON_OFFSET_POINT */
+      1167, /* GL_POLYGON_OFFSET_LINE */
+      1287, /* GL_R3_G3_B2 */
+      1785, /* GL_V2F */
+      1786, /* GL_V3F */
        123, /* GL_C4UB_V2F */
        124, /* GL_C4UB_V3F */
        121, /* GL_C3F_V3F */
-       999, /* GL_N3F_V3F */
+      1002, /* GL_N3F_V3F */
        122, /* GL_C4F_N3F_V3F */
-      1536, /* GL_T2F_V3F */
-      1538, /* GL_T4F_V4F */
-      1534, /* GL_T2F_C4UB_V3F */
-      1532, /* GL_T2F_C3F_V3F */
-      1535, /* GL_T2F_N3F_V3F */
-      1533, /* GL_T2F_C4F_N3F_V3F */
-      1537, /* GL_T4F_C4F_N3F_V4F */
+      1541, /* GL_T2F_V3F */
+      1543, /* GL_T4F_V4F */
+      1539, /* GL_T2F_C4UB_V3F */
+      1537, /* GL_T2F_C3F_V3F */
+      1540, /* GL_T2F_N3F_V3F */
+      1538, /* GL_T2F_C4F_N3F_V3F */
+      1542, /* GL_T4F_C4F_N3F_V4F */
        139, /* GL_CLIP_PLANE0 */
        140, /* GL_CLIP_PLANE1 */
        141, /* GL_CLIP_PLANE2 */
        142, /* GL_CLIP_PLANE3 */
        143, /* GL_CLIP_PLANE4 */
        144, /* GL_CLIP_PLANE5 */
-       669, /* GL_LIGHT0 */
-       670, /* GL_LIGHT1 */
-       671, /* GL_LIGHT2 */
-       672, /* GL_LIGHT3 */
-       673, /* GL_LIGHT4 */
-       674, /* GL_LIGHT5 */
-       675, /* GL_LIGHT6 */
-       676, /* GL_LIGHT7 */
-       595, /* GL_HINT_BIT */
+       672, /* GL_LIGHT0 */
+       673, /* GL_LIGHT1 */
+       674, /* GL_LIGHT2 */
+       675, /* GL_LIGHT3 */
+       676, /* GL_LIGHT4 */
+       677, /* GL_LIGHT5 */
+       678, /* GL_LIGHT6 */
+       679, /* GL_LIGHT7 */
+       597, /* GL_HINT_BIT */
        277, /* GL_CONSTANT_COLOR */
-      1047, /* GL_ONE_MINUS_CONSTANT_COLOR */
+      1050, /* GL_ONE_MINUS_CONSTANT_COLOR */
        272, /* GL_CONSTANT_ALPHA */
-      1045, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+      1048, /* GL_ONE_MINUS_CONSTANT_ALPHA */
         76, /* GL_BLEND_COLOR */
-       579, /* GL_FUNC_ADD */
-       935, /* GL_MIN */
-       845, /* GL_MAX */
+       581, /* GL_FUNC_ADD */
+       938, /* GL_MIN */
+       848, /* GL_MAX */
         81, /* GL_BLEND_EQUATION */
-       583, /* GL_FUNC_SUBTRACT */
-       581, /* GL_FUNC_REVERSE_SUBTRACT */
+       585, /* GL_FUNC_SUBTRACT */
+       583, /* GL_FUNC_REVERSE_SUBTRACT */
        280, /* GL_CONVOLUTION_1D */
        281, /* GL_CONVOLUTION_2D */
-      1407, /* GL_SEPARABLE_2D */
+      1412, /* GL_SEPARABLE_2D */
        284, /* GL_CONVOLUTION_BORDER_MODE */
        288, /* GL_CONVOLUTION_FILTER_SCALE */
        286, /* GL_CONVOLUTION_FILTER_BIAS */
-      1293, /* GL_REDUCE */
+      1298, /* GL_REDUCE */
        290, /* GL_CONVOLUTION_FORMAT */
        294, /* GL_CONVOLUTION_WIDTH */
        292, /* GL_CONVOLUTION_HEIGHT */
-       860, /* GL_MAX_CONVOLUTION_WIDTH */
-       858, /* GL_MAX_CONVOLUTION_HEIGHT */
-      1205, /* GL_POST_CONVOLUTION_RED_SCALE */
-      1201, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-      1196, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-      1192, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-      1203, /* GL_POST_CONVOLUTION_RED_BIAS */
-      1199, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-      1194, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-      1190, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-       596, /* GL_HISTOGRAM */
-      1253, /* GL_PROXY_HISTOGRAM */
-       612, /* GL_HISTOGRAM_WIDTH */
-       602, /* GL_HISTOGRAM_FORMAT */
-       608, /* GL_HISTOGRAM_RED_SIZE */
-       604, /* GL_HISTOGRAM_GREEN_SIZE */
-       599, /* GL_HISTOGRAM_BLUE_SIZE */
-       597, /* GL_HISTOGRAM_ALPHA_SIZE */
-       606, /* GL_HISTOGRAM_LUMINANCE_SIZE */
-       610, /* GL_HISTOGRAM_SINK */
-       936, /* GL_MINMAX */
-       938, /* GL_MINMAX_FORMAT */
-       940, /* GL_MINMAX_SINK */
-      1539, /* GL_TABLE_TOO_LARGE_EXT */
-      1759, /* GL_UNSIGNED_BYTE_3_3_2 */
-      1770, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-      1772, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-      1765, /* GL_UNSIGNED_INT_8_8_8_8 */
-      1761, /* GL_UNSIGNED_INT_10_10_10_2 */
-      1163, /* GL_POLYGON_OFFSET_FILL */
-      1162, /* GL_POLYGON_OFFSET_FACTOR */
-      1161, /* GL_POLYGON_OFFSET_BIAS */
-      1324, /* GL_RESCALE_NORMAL */
+       863, /* GL_MAX_CONVOLUTION_WIDTH */
+       861, /* GL_MAX_CONVOLUTION_HEIGHT */
+      1208, /* GL_POST_CONVOLUTION_RED_SCALE */
+      1204, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+      1199, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+      1195, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+      1206, /* GL_POST_CONVOLUTION_RED_BIAS */
+      1202, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+      1197, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+      1193, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+       598, /* GL_HISTOGRAM */
+      1257, /* GL_PROXY_HISTOGRAM */
+       614, /* GL_HISTOGRAM_WIDTH */
+       604, /* GL_HISTOGRAM_FORMAT */
+       610, /* GL_HISTOGRAM_RED_SIZE */
+       606, /* GL_HISTOGRAM_GREEN_SIZE */
+       601, /* GL_HISTOGRAM_BLUE_SIZE */
+       599, /* GL_HISTOGRAM_ALPHA_SIZE */
+       608, /* GL_HISTOGRAM_LUMINANCE_SIZE */
+       612, /* GL_HISTOGRAM_SINK */
+       939, /* GL_MINMAX */
+       941, /* GL_MINMAX_FORMAT */
+       943, /* GL_MINMAX_SINK */
+      1544, /* GL_TABLE_TOO_LARGE_EXT */
+      1764, /* GL_UNSIGNED_BYTE_3_3_2 */
+      1775, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+      1777, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+      1770, /* GL_UNSIGNED_INT_8_8_8_8 */
+      1766, /* GL_UNSIGNED_INT_10_10_10_2 */
+      1166, /* GL_POLYGON_OFFSET_FILL */
+      1165, /* GL_POLYGON_OFFSET_FACTOR */
+      1164, /* GL_POLYGON_OFFSET_BIAS */
+      1329, /* GL_RESCALE_NORMAL */
         36, /* GL_ALPHA4 */
         38, /* GL_ALPHA8 */
         32, /* GL_ALPHA12 */
         34, /* GL_ALPHA16 */
-       725, /* GL_LUMINANCE4 */
-       731, /* GL_LUMINANCE8 */
-       715, /* GL_LUMINANCE12 */
-       721, /* GL_LUMINANCE16 */
-       726, /* GL_LUMINANCE4_ALPHA4 */
-       729, /* GL_LUMINANCE6_ALPHA2 */
-       732, /* GL_LUMINANCE8_ALPHA8 */
-       718, /* GL_LUMINANCE12_ALPHA4 */
-       716, /* GL_LUMINANCE12_ALPHA12 */
-       722, /* GL_LUMINANCE16_ALPHA16 */
-       637, /* GL_INTENSITY */
-       642, /* GL_INTENSITY4 */
-       644, /* GL_INTENSITY8 */
-       638, /* GL_INTENSITY12 */
-       640, /* GL_INTENSITY16 */
-      1336, /* GL_RGB2_EXT */
-      1337, /* GL_RGB4 */
-      1340, /* GL_RGB5 */
-      1344, /* GL_RGB8 */
-      1328, /* GL_RGB10 */
-      1332, /* GL_RGB12 */
-      1334, /* GL_RGB16 */
-      1351, /* GL_RGBA2 */
-      1353, /* GL_RGBA4 */
-      1341, /* GL_RGB5_A1 */
-      1357, /* GL_RGBA8 */
-      1329, /* GL_RGB10_A2 */
-      1347, /* GL_RGBA12 */
-      1349, /* GL_RGBA16 */
-      1715, /* GL_TEXTURE_RED_SIZE */
-      1685, /* GL_TEXTURE_GREEN_SIZE */
-      1623, /* GL_TEXTURE_BLUE_SIZE */
-      1610, /* GL_TEXTURE_ALPHA_SIZE */
-      1698, /* GL_TEXTURE_LUMINANCE_SIZE */
-      1689, /* GL_TEXTURE_INTENSITY_SIZE */
-      1322, /* GL_REPLACE_EXT */
-      1257, /* GL_PROXY_TEXTURE_1D */
-      1260, /* GL_PROXY_TEXTURE_2D */
-      1721, /* GL_TEXTURE_TOO_LARGE_EXT */
-      1710, /* GL_TEXTURE_PRIORITY */
-      1717, /* GL_TEXTURE_RESIDENT */
-      1613, /* GL_TEXTURE_BINDING_1D */
-      1615, /* GL_TEXTURE_BINDING_2D */
-      1617, /* GL_TEXTURE_BINDING_3D */
-      1083, /* GL_PACK_SKIP_IMAGES */
-      1079, /* GL_PACK_IMAGE_HEIGHT */
-      1752, /* GL_UNPACK_SKIP_IMAGES */
-      1749, /* GL_UNPACK_IMAGE_HEIGHT */
-      1609, /* GL_TEXTURE_3D */
-      1263, /* GL_PROXY_TEXTURE_3D */
-      1672, /* GL_TEXTURE_DEPTH */
-      1724, /* GL_TEXTURE_WRAP_R */
-       846, /* GL_MAX_3D_TEXTURE_SIZE */
-      1785, /* GL_VERTEX_ARRAY */
-      1013, /* GL_NORMAL_ARRAY */
+       728, /* GL_LUMINANCE4 */
+       734, /* GL_LUMINANCE8 */
+       718, /* GL_LUMINANCE12 */
+       724, /* GL_LUMINANCE16 */
+       729, /* GL_LUMINANCE4_ALPHA4 */
+       732, /* GL_LUMINANCE6_ALPHA2 */
+       735, /* GL_LUMINANCE8_ALPHA8 */
+       721, /* GL_LUMINANCE12_ALPHA4 */
+       719, /* GL_LUMINANCE12_ALPHA12 */
+       725, /* GL_LUMINANCE16_ALPHA16 */
+       639, /* GL_INTENSITY */
+       644, /* GL_INTENSITY4 */
+       646, /* GL_INTENSITY8 */
+       640, /* GL_INTENSITY12 */
+       642, /* GL_INTENSITY16 */
+      1341, /* GL_RGB2_EXT */
+      1342, /* GL_RGB4 */
+      1345, /* GL_RGB5 */
+      1349, /* GL_RGB8 */
+      1333, /* GL_RGB10 */
+      1337, /* GL_RGB12 */
+      1339, /* GL_RGB16 */
+      1356, /* GL_RGBA2 */
+      1358, /* GL_RGBA4 */
+      1346, /* GL_RGB5_A1 */
+      1362, /* GL_RGBA8 */
+      1334, /* GL_RGB10_A2 */
+      1352, /* GL_RGBA12 */
+      1354, /* GL_RGBA16 */
+      1720, /* GL_TEXTURE_RED_SIZE */
+      1690, /* GL_TEXTURE_GREEN_SIZE */
+      1628, /* GL_TEXTURE_BLUE_SIZE */
+      1615, /* GL_TEXTURE_ALPHA_SIZE */
+      1703, /* GL_TEXTURE_LUMINANCE_SIZE */
+      1694, /* GL_TEXTURE_INTENSITY_SIZE */
+      1327, /* GL_REPLACE_EXT */
+      1261, /* GL_PROXY_TEXTURE_1D */
+      1264, /* GL_PROXY_TEXTURE_2D */
+      1726, /* GL_TEXTURE_TOO_LARGE_EXT */
+      1715, /* GL_TEXTURE_PRIORITY */
+      1722, /* GL_TEXTURE_RESIDENT */
+      1618, /* GL_TEXTURE_BINDING_1D */
+      1620, /* GL_TEXTURE_BINDING_2D */
+      1622, /* GL_TEXTURE_BINDING_3D */
+      1086, /* GL_PACK_SKIP_IMAGES */
+      1082, /* GL_PACK_IMAGE_HEIGHT */
+      1757, /* GL_UNPACK_SKIP_IMAGES */
+      1754, /* GL_UNPACK_IMAGE_HEIGHT */
+      1614, /* GL_TEXTURE_3D */
+      1267, /* GL_PROXY_TEXTURE_3D */
+      1677, /* GL_TEXTURE_DEPTH */
+      1729, /* GL_TEXTURE_WRAP_R */
+       849, /* GL_MAX_3D_TEXTURE_SIZE */
+      1790, /* GL_VERTEX_ARRAY */
+      1016, /* GL_NORMAL_ARRAY */
        148, /* GL_COLOR_ARRAY */
-       622, /* GL_INDEX_ARRAY */
-      1650, /* GL_TEXTURE_COORD_ARRAY */
-       455, /* GL_EDGE_FLAG_ARRAY */
-      1791, /* GL_VERTEX_ARRAY_SIZE */
-      1793, /* GL_VERTEX_ARRAY_TYPE */
-      1792, /* GL_VERTEX_ARRAY_STRIDE */
-      1018, /* GL_NORMAL_ARRAY_TYPE */
-      1017, /* GL_NORMAL_ARRAY_STRIDE */
+       624, /* GL_INDEX_ARRAY */
+      1655, /* GL_TEXTURE_COORD_ARRAY */
+       456, /* GL_EDGE_FLAG_ARRAY */
+      1796, /* GL_VERTEX_ARRAY_SIZE */
+      1798, /* GL_VERTEX_ARRAY_TYPE */
+      1797, /* GL_VERTEX_ARRAY_STRIDE */
+      1021, /* GL_NORMAL_ARRAY_TYPE */
+      1020, /* GL_NORMAL_ARRAY_STRIDE */
        152, /* GL_COLOR_ARRAY_SIZE */
        154, /* GL_COLOR_ARRAY_TYPE */
        153, /* GL_COLOR_ARRAY_STRIDE */
-       627, /* GL_INDEX_ARRAY_TYPE */
-       626, /* GL_INDEX_ARRAY_STRIDE */
-      1654, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-      1656, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-      1655, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-       459, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-      1790, /* GL_VERTEX_ARRAY_POINTER */
-      1016, /* GL_NORMAL_ARRAY_POINTER */
+       629, /* GL_INDEX_ARRAY_TYPE */
+       628, /* GL_INDEX_ARRAY_STRIDE */
+      1659, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+      1661, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+      1660, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+       460, /* GL_EDGE_FLAG_ARRAY_STRIDE */
+      1795, /* GL_VERTEX_ARRAY_POINTER */
+      1019, /* GL_NORMAL_ARRAY_POINTER */
        151, /* GL_COLOR_ARRAY_POINTER */
-       625, /* GL_INDEX_ARRAY_POINTER */
-      1653, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-       458, /* GL_EDGE_FLAG_ARRAY_POINTER */
-       992, /* GL_MULTISAMPLE */
-      1381, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-      1383, /* GL_SAMPLE_ALPHA_TO_ONE */
-      1388, /* GL_SAMPLE_COVERAGE */
-      1385, /* GL_SAMPLE_BUFFERS */
-      1376, /* GL_SAMPLES */
-      1392, /* GL_SAMPLE_COVERAGE_VALUE */
-      1390, /* GL_SAMPLE_COVERAGE_INVERT */
+       627, /* GL_INDEX_ARRAY_POINTER */
+      1658, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+       459, /* GL_EDGE_FLAG_ARRAY_POINTER */
+       995, /* GL_MULTISAMPLE */
+      1386, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+      1388, /* GL_SAMPLE_ALPHA_TO_ONE */
+      1393, /* GL_SAMPLE_COVERAGE */
+      1390, /* GL_SAMPLE_BUFFERS */
+      1381, /* GL_SAMPLES */
+      1397, /* GL_SAMPLE_COVERAGE_VALUE */
+      1395, /* GL_SAMPLE_COVERAGE_INVERT */
        195, /* GL_COLOR_MATRIX */
        197, /* GL_COLOR_MATRIX_STACK_DEPTH */
-       854, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-      1188, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-      1184, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-      1179, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-      1175, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-      1186, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-      1182, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-      1177, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-      1173, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-      1633, /* GL_TEXTURE_COLOR_TABLE_SGI */
-      1264, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-      1635, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+       857, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+      1191, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+      1187, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+      1182, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+      1178, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+      1189, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+      1185, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+      1180, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+      1176, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+      1638, /* GL_TEXTURE_COLOR_TABLE_SGI */
+      1268, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+      1640, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
         80, /* GL_BLEND_DST_RGB */
         89, /* GL_BLEND_SRC_RGB */
         79, /* GL_BLEND_DST_ALPHA */
         88, /* GL_BLEND_SRC_ALPHA */
        201, /* GL_COLOR_TABLE */
-      1198, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-      1181, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-      1252, /* GL_PROXY_COLOR_TABLE */
-      1256, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-      1255, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+      1201, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+      1184, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+      1256, /* GL_PROXY_COLOR_TABLE */
+      1260, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+      1259, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
        225, /* GL_COLOR_TABLE_SCALE */
        205, /* GL_COLOR_TABLE_BIAS */
        210, /* GL_COLOR_TABLE_FORMAT */
@@ -4369,380 +4379,380 @@ static const unsigned reduced_enums[1347] =
        216, /* GL_COLOR_TABLE_INTENSITY_SIZE */
         71, /* GL_BGR */
         72, /* GL_BGRA */
-       868, /* GL_MAX_ELEMENTS_VERTICES */
-       867, /* GL_MAX_ELEMENTS_INDICES */
-      1688, /* GL_TEXTURE_INDEX_SIZE_EXT */
+       871, /* GL_MAX_ELEMENTS_VERTICES */
+       870, /* GL_MAX_ELEMENTS_INDICES */
+      1693, /* GL_TEXTURE_INDEX_SIZE_EXT */
        145, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
-      1145, /* GL_POINT_SIZE_MIN */
-      1141, /* GL_POINT_SIZE_MAX */
-      1135, /* GL_POINT_FADE_THRESHOLD_SIZE */
-      1131, /* GL_POINT_DISTANCE_ATTENUATION */
+      1148, /* GL_POINT_SIZE_MIN */
+      1144, /* GL_POINT_SIZE_MAX */
+      1138, /* GL_POINT_FADE_THRESHOLD_SIZE */
+      1134, /* GL_POINT_DISTANCE_ATTENUATION */
        127, /* GL_CLAMP_TO_BORDER */
        130, /* GL_CLAMP_TO_EDGE */
-      1709, /* GL_TEXTURE_MIN_LOD */
-      1707, /* GL_TEXTURE_MAX_LOD */
-      1612, /* GL_TEXTURE_BASE_LEVEL */
-      1706, /* GL_TEXTURE_MAX_LEVEL */
-       615, /* GL_IGNORE_BORDER_HP */
+      1714, /* GL_TEXTURE_MIN_LOD */
+      1712, /* GL_TEXTURE_MAX_LOD */
+      1617, /* GL_TEXTURE_BASE_LEVEL */
+      1711, /* GL_TEXTURE_MAX_LEVEL */
+       617, /* GL_IGNORE_BORDER_HP */
        276, /* GL_CONSTANT_BORDER_HP */
-      1323, /* GL_REPLICATE_BORDER_HP */
+      1328, /* GL_REPLICATE_BORDER_HP */
        282, /* GL_CONVOLUTION_BORDER_COLOR */
-      1042, /* GL_OCCLUSION_TEST_HP */
-      1043, /* GL_OCCLUSION_TEST_RESULT_HP */
-       687, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-      1627, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-      1629, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-      1631, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-      1632, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-      1630, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-      1628, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-       850, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-       851, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-      1208, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-      1210, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-      1207, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-      1209, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-      1696, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-      1697, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-      1695, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-       585, /* GL_GENERATE_MIPMAP */
-       586, /* GL_GENERATE_MIPMAP_HINT */
-       527, /* GL_FOG_OFFSET_SGIX */
-       528, /* GL_FOG_OFFSET_VALUE_SGIX */
-      1641, /* GL_TEXTURE_COMPARE_SGIX */
-      1640, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-      1692, /* GL_TEXTURE_LEQUAL_R_SGIX */
-      1684, /* GL_TEXTURE_GEQUAL_R_SGIX */
-       358, /* GL_DEPTH_COMPONENT16 */
-       361, /* GL_DEPTH_COMPONENT24 */
-       364, /* GL_DEPTH_COMPONENT32 */
+      1045, /* GL_OCCLUSION_TEST_HP */
+      1046, /* GL_OCCLUSION_TEST_RESULT_HP */
+       690, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+      1632, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+      1634, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+      1636, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+      1637, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+      1635, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+      1633, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+       853, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+       854, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+      1211, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+      1213, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+      1210, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+      1212, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+      1701, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+      1702, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+      1700, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+       587, /* GL_GENERATE_MIPMAP */
+       588, /* GL_GENERATE_MIPMAP_HINT */
+       529, /* GL_FOG_OFFSET_SGIX */
+       530, /* GL_FOG_OFFSET_VALUE_SGIX */
+      1646, /* GL_TEXTURE_COMPARE_SGIX */
+      1645, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+      1697, /* GL_TEXTURE_LEQUAL_R_SGIX */
+      1689, /* GL_TEXTURE_GEQUAL_R_SGIX */
+       359, /* GL_DEPTH_COMPONENT16 */
+       362, /* GL_DEPTH_COMPONENT24 */
+       365, /* GL_DEPTH_COMPONENT32 */
        306, /* GL_CULL_VERTEX_EXT */
        308, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
        307, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
-      1848, /* GL_WRAP_BORDER_SUN */
-      1634, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-       680, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-      1422, /* GL_SINGLE_COLOR */
-      1408, /* GL_SEPARATE_SPECULAR_COLOR */
-      1417, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-       538, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
-       539, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
-       546, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
-       541, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
-       537, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
-       536, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
-       540, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
-       547, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
-       558, /* GL_FRAMEBUFFER_DEFAULT */
-       571, /* GL_FRAMEBUFFER_UNDEFINED */
-       371, /* GL_DEPTH_STENCIL_ATTACHMENT */
-       621, /* GL_INDEX */
-      1758, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-      1773, /* GL_UNSIGNED_SHORT_5_6_5 */
-      1774, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-      1771, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-      1769, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-      1766, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-      1764, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-      1704, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-      1705, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-      1703, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-       943, /* GL_MIRRORED_REPEAT */
-      1364, /* GL_RGB_S3TC */
-      1339, /* GL_RGB4_S3TC */
-      1362, /* GL_RGBA_S3TC */
-      1356, /* GL_RGBA4_S3TC */
-      1360, /* GL_RGBA_DXT5_S3TC */
-      1354, /* GL_RGBA4_DXT5_S3TC */
+      1853, /* GL_WRAP_BORDER_SUN */
+      1639, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+       683, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+      1427, /* GL_SINGLE_COLOR */
+      1413, /* GL_SEPARATE_SPECULAR_COLOR */
+      1422, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+       540, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
+       541, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
+       548, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
+       543, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
+       539, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
+       538, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
+       542, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
+       549, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
+       560, /* GL_FRAMEBUFFER_DEFAULT */
+       573, /* GL_FRAMEBUFFER_UNDEFINED */
+       372, /* GL_DEPTH_STENCIL_ATTACHMENT */
+       623, /* GL_INDEX */
+      1763, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+      1778, /* GL_UNSIGNED_SHORT_5_6_5 */
+      1779, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+      1776, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+      1774, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+      1771, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+      1769, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+      1709, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+      1710, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+      1708, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+       946, /* GL_MIRRORED_REPEAT */
+      1369, /* GL_RGB_S3TC */
+      1344, /* GL_RGB4_S3TC */
+      1367, /* GL_RGBA_S3TC */
+      1361, /* GL_RGBA4_S3TC */
+      1365, /* GL_RGBA_DXT5_S3TC */
+      1359, /* GL_RGBA4_DXT5_S3TC */
        264, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
        259, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
        260, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
        261, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
-      1004, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-      1003, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-       688, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-       514, /* GL_FOG_COORDINATE_SOURCE */
-       506, /* GL_FOG_COORD */
-       530, /* GL_FRAGMENT_DEPTH */
+      1007, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+      1006, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+       691, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+       516, /* GL_FOG_COORDINATE_SOURCE */
+       508, /* GL_FOG_COORD */
+       532, /* GL_FRAGMENT_DEPTH */
        312, /* GL_CURRENT_FOG_COORD */
-       513, /* GL_FOG_COORDINATE_ARRAY_TYPE */
-       512, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
-       511, /* GL_FOG_COORDINATE_ARRAY_POINTER */
-       508, /* GL_FOG_COORDINATE_ARRAY */
+       515, /* GL_FOG_COORDINATE_ARRAY_TYPE */
+       514, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
+       513, /* GL_FOG_COORDINATE_ARRAY_POINTER */
+       510, /* GL_FOG_COORDINATE_ARRAY */
        199, /* GL_COLOR_SUM */
        332, /* GL_CURRENT_SECONDARY_COLOR */
-      1401, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-      1403, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-      1402, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-      1400, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-      1397, /* GL_SECONDARY_COLOR_ARRAY */
+      1406, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+      1408, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+      1407, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+      1405, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+      1402, /* GL_SECONDARY_COLOR_ARRAY */
        330, /* GL_CURRENT_RASTER_SECONDARY_COLOR */
         28, /* GL_ALIASED_POINT_SIZE_RANGE */
         27, /* GL_ALIASED_LINE_WIDTH_RANGE */
-      1541, /* GL_TEXTURE0 */
-      1543, /* GL_TEXTURE1 */
-      1565, /* GL_TEXTURE2 */
-      1587, /* GL_TEXTURE3 */
-      1593, /* GL_TEXTURE4 */
-      1595, /* GL_TEXTURE5 */
-      1597, /* GL_TEXTURE6 */
-      1599, /* GL_TEXTURE7 */
-      1601, /* GL_TEXTURE8 */
-      1603, /* GL_TEXTURE9 */
-      1544, /* GL_TEXTURE10 */
-      1546, /* GL_TEXTURE11 */
-      1548, /* GL_TEXTURE12 */
-      1550, /* GL_TEXTURE13 */
-      1552, /* GL_TEXTURE14 */
-      1554, /* GL_TEXTURE15 */
-      1556, /* GL_TEXTURE16 */
-      1558, /* GL_TEXTURE17 */
-      1560, /* GL_TEXTURE18 */
-      1562, /* GL_TEXTURE19 */
-      1566, /* GL_TEXTURE20 */
-      1568, /* GL_TEXTURE21 */
-      1570, /* GL_TEXTURE22 */
-      1572, /* GL_TEXTURE23 */
-      1574, /* GL_TEXTURE24 */
-      1576, /* GL_TEXTURE25 */
-      1578, /* GL_TEXTURE26 */
-      1580, /* GL_TEXTURE27 */
-      1582, /* GL_TEXTURE28 */
-      1584, /* GL_TEXTURE29 */
-      1588, /* GL_TEXTURE30 */
-      1590, /* GL_TEXTURE31 */
+      1546, /* GL_TEXTURE0 */
+      1548, /* GL_TEXTURE1 */
+      1570, /* GL_TEXTURE2 */
+      1592, /* GL_TEXTURE3 */
+      1598, /* GL_TEXTURE4 */
+      1600, /* GL_TEXTURE5 */
+      1602, /* GL_TEXTURE6 */
+      1604, /* GL_TEXTURE7 */
+      1606, /* GL_TEXTURE8 */
+      1608, /* GL_TEXTURE9 */
+      1549, /* GL_TEXTURE10 */
+      1551, /* GL_TEXTURE11 */
+      1553, /* GL_TEXTURE12 */
+      1555, /* GL_TEXTURE13 */
+      1557, /* GL_TEXTURE14 */
+      1559, /* GL_TEXTURE15 */
+      1561, /* GL_TEXTURE16 */
+      1563, /* GL_TEXTURE17 */
+      1565, /* GL_TEXTURE18 */
+      1567, /* GL_TEXTURE19 */
+      1571, /* GL_TEXTURE20 */
+      1573, /* GL_TEXTURE21 */
+      1575, /* GL_TEXTURE22 */
+      1577, /* GL_TEXTURE23 */
+      1579, /* GL_TEXTURE24 */
+      1581, /* GL_TEXTURE25 */
+      1583, /* GL_TEXTURE26 */
+      1585, /* GL_TEXTURE27 */
+      1587, /* GL_TEXTURE28 */
+      1589, /* GL_TEXTURE29 */
+      1593, /* GL_TEXTURE30 */
+      1595, /* GL_TEXTURE31 */
         18, /* GL_ACTIVE_TEXTURE */
        133, /* GL_CLIENT_ACTIVE_TEXTURE */
-       921, /* GL_MAX_TEXTURE_UNITS */
-      1736, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-      1739, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-      1741, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-      1733, /* GL_TRANSPOSE_COLOR_MATRIX */
-      1523, /* GL_SUBTRACT */
-       908, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
+       924, /* GL_MAX_TEXTURE_UNITS */
+      1741, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+      1744, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+      1746, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+      1738, /* GL_TRANSPOSE_COLOR_MATRIX */
+      1528, /* GL_SUBTRACT */
+       911, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
        247, /* GL_COMPRESSED_ALPHA */
        251, /* GL_COMPRESSED_LUMINANCE */
        252, /* GL_COMPRESSED_LUMINANCE_ALPHA */
        249, /* GL_COMPRESSED_INTENSITY */
        255, /* GL_COMPRESSED_RGB */
        256, /* GL_COMPRESSED_RGBA */
-      1648, /* GL_TEXTURE_COMPRESSION_HINT */
-      1713, /* GL_TEXTURE_RECTANGLE_ARB */
-      1620, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-      1267, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-       906, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-       370, /* GL_DEPTH_STENCIL */
-      1762, /* GL_UNSIGNED_INT_24_8 */
-       917, /* GL_MAX_TEXTURE_LOD_BIAS */
-      1702, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-       918, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-      1678, /* GL_TEXTURE_FILTER_CONTROL */
-      1693, /* GL_TEXTURE_LOD_BIAS */
+      1653, /* GL_TEXTURE_COMPRESSION_HINT */
+      1718, /* GL_TEXTURE_RECTANGLE_ARB */
+      1625, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+      1271, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+       909, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+       371, /* GL_DEPTH_STENCIL */
+      1767, /* GL_UNSIGNED_INT_24_8 */
+       920, /* GL_MAX_TEXTURE_LOD_BIAS */
+      1707, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+       921, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+      1683, /* GL_TEXTURE_FILTER_CONTROL */
+      1698, /* GL_TEXTURE_LOD_BIAS */
        232, /* GL_COMBINE4 */
-       911, /* GL_MAX_SHININESS_NV */
-       912, /* GL_MAX_SPOT_EXPONENT_NV */
-       619, /* GL_INCR_WRAP */
+       914, /* GL_MAX_SHININESS_NV */
+       915, /* GL_MAX_SPOT_EXPONENT_NV */
+       621, /* GL_INCR_WRAP */
        343, /* GL_DECR_WRAP */
-       963, /* GL_MODELVIEW1_ARB */
-      1019, /* GL_NORMAL_MAP */
-      1298, /* GL_REFLECTION_MAP */
-      1657, /* GL_TEXTURE_CUBE_MAP */
-      1618, /* GL_TEXTURE_BINDING_CUBE_MAP */
-      1665, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-      1659, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-      1667, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-      1661, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-      1669, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-      1663, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-      1265, /* GL_PROXY_TEXTURE_CUBE_MAP */
-       862, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-       998, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-       522, /* GL_FOG_DISTANCE_MODE_NV */
-       474, /* GL_EYE_RADIAL_NV */
-       473, /* GL_EYE_PLANE_ABSOLUTE_NV */
+       966, /* GL_MODELVIEW1_ARB */
+      1022, /* GL_NORMAL_MAP */
+      1303, /* GL_REFLECTION_MAP */
+      1662, /* GL_TEXTURE_CUBE_MAP */
+      1623, /* GL_TEXTURE_BINDING_CUBE_MAP */
+      1670, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+      1664, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+      1672, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+      1666, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+      1674, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+      1668, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+      1269, /* GL_PROXY_TEXTURE_CUBE_MAP */
+       865, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+      1001, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+       524, /* GL_FOG_DISTANCE_MODE_NV */
+       475, /* GL_EYE_RADIAL_NV */
+       474, /* GL_EYE_PLANE_ABSOLUTE_NV */
        231, /* GL_COMBINE */
        238, /* GL_COMBINE_RGB */
        233, /* GL_COMBINE_ALPHA */
-      1365, /* GL_RGB_SCALE */
+      1370, /* GL_RGB_SCALE */
         24, /* GL_ADD_SIGNED */
-       647, /* GL_INTERPOLATE */
+       649, /* GL_INTERPOLATE */
        271, /* GL_CONSTANT */
-      1214, /* GL_PRIMARY_COLOR */
-      1211, /* GL_PREVIOUS */
-      1437, /* GL_SOURCE0_RGB */
-      1443, /* GL_SOURCE1_RGB */
-      1449, /* GL_SOURCE2_RGB */
-      1453, /* GL_SOURCE3_RGB_NV */
-      1434, /* GL_SOURCE0_ALPHA */
-      1440, /* GL_SOURCE1_ALPHA */
-      1446, /* GL_SOURCE2_ALPHA */
-      1452, /* GL_SOURCE3_ALPHA_NV */
-      1056, /* GL_OPERAND0_RGB */
-      1062, /* GL_OPERAND1_RGB */
-      1068, /* GL_OPERAND2_RGB */
-      1072, /* GL_OPERAND3_RGB_NV */
-      1053, /* GL_OPERAND0_ALPHA */
-      1059, /* GL_OPERAND1_ALPHA */
-      1065, /* GL_OPERAND2_ALPHA */
-      1071, /* GL_OPERAND3_ALPHA_NV */
-      1786, /* GL_VERTEX_ARRAY_BINDING */
-      1711, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
-      1712, /* GL_TEXTURE_RANGE_POINTER_APPLE */
-      1852, /* GL_YCBCR_422_APPLE */
-      1775, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-      1777, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-      1720, /* GL_TEXTURE_STORAGE_HINT_APPLE */
-      1514, /* GL_STORAGE_PRIVATE_APPLE */
-      1513, /* GL_STORAGE_CACHED_APPLE */
-      1515, /* GL_STORAGE_SHARED_APPLE */
-      1424, /* GL_SLICE_ACCUM_SUN */
-      1273, /* GL_QUAD_MESH_SUN */
-      1745, /* GL_TRIANGLE_MESH_SUN */
-      1825, /* GL_VERTEX_PROGRAM_ARB */
-      1836, /* GL_VERTEX_STATE_PROGRAM_NV */
-      1812, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-      1818, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-      1820, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-      1822, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+      1217, /* GL_PRIMARY_COLOR */
+      1214, /* GL_PREVIOUS */
+      1442, /* GL_SOURCE0_RGB */
+      1448, /* GL_SOURCE1_RGB */
+      1454, /* GL_SOURCE2_RGB */
+      1458, /* GL_SOURCE3_RGB_NV */
+      1439, /* GL_SOURCE0_ALPHA */
+      1445, /* GL_SOURCE1_ALPHA */
+      1451, /* GL_SOURCE2_ALPHA */
+      1457, /* GL_SOURCE3_ALPHA_NV */
+      1059, /* GL_OPERAND0_RGB */
+      1065, /* GL_OPERAND1_RGB */
+      1071, /* GL_OPERAND2_RGB */
+      1075, /* GL_OPERAND3_RGB_NV */
+      1056, /* GL_OPERAND0_ALPHA */
+      1062, /* GL_OPERAND1_ALPHA */
+      1068, /* GL_OPERAND2_ALPHA */
+      1074, /* GL_OPERAND3_ALPHA_NV */
+      1791, /* GL_VERTEX_ARRAY_BINDING */
+      1716, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+      1717, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+      1857, /* GL_YCBCR_422_APPLE */
+      1780, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+      1782, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+      1725, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+      1519, /* GL_STORAGE_PRIVATE_APPLE */
+      1518, /* GL_STORAGE_CACHED_APPLE */
+      1520, /* GL_STORAGE_SHARED_APPLE */
+      1429, /* GL_SLICE_ACCUM_SUN */
+      1278, /* GL_QUAD_MESH_SUN */
+      1750, /* GL_TRIANGLE_MESH_SUN */
+      1830, /* GL_VERTEX_PROGRAM_ARB */
+      1841, /* GL_VERTEX_STATE_PROGRAM_NV */
+      1817, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+      1823, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+      1825, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+      1827, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
        334, /* GL_CURRENT_VERTEX_ATTRIB */
-      1227, /* GL_PROGRAM_LENGTH_ARB */
-      1241, /* GL_PROGRAM_STRING_ARB */
-       985, /* GL_MODELVIEW_PROJECTION_NV */
-       614, /* GL_IDENTITY_NV */
-       661, /* GL_INVERSE_NV */
-      1738, /* GL_TRANSPOSE_NV */
-       662, /* GL_INVERSE_TRANSPOSE_NV */
-       892, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-       891, /* GL_MAX_PROGRAM_MATRICES_ARB */
-       799, /* GL_MATRIX0_NV */
-       811, /* GL_MATRIX1_NV */
-       823, /* GL_MATRIX2_NV */
-       827, /* GL_MATRIX3_NV */
-       829, /* GL_MATRIX4_NV */
-       831, /* GL_MATRIX5_NV */
-       833, /* GL_MATRIX6_NV */
-       835, /* GL_MATRIX7_NV */
+      1230, /* GL_PROGRAM_LENGTH_ARB */
+      1244, /* GL_PROGRAM_STRING_ARB */
+       988, /* GL_MODELVIEW_PROJECTION_NV */
+       616, /* GL_IDENTITY_NV */
+       663, /* GL_INVERSE_NV */
+      1743, /* GL_TRANSPOSE_NV */
+       664, /* GL_INVERSE_TRANSPOSE_NV */
+       895, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+       894, /* GL_MAX_PROGRAM_MATRICES_ARB */
+       802, /* GL_MATRIX0_NV */
+       814, /* GL_MATRIX1_NV */
+       826, /* GL_MATRIX2_NV */
+       830, /* GL_MATRIX3_NV */
+       832, /* GL_MATRIX4_NV */
+       834, /* GL_MATRIX5_NV */
+       836, /* GL_MATRIX6_NV */
+       838, /* GL_MATRIX7_NV */
        318, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
        315, /* GL_CURRENT_MATRIX_ARB */
-      1828, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-      1831, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-      1239, /* GL_PROGRAM_PARAMETER_NV */
-      1816, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-      1243, /* GL_PROGRAM_TARGET_NV */
-      1240, /* GL_PROGRAM_RESIDENT_NV */
-      1730, /* GL_TRACK_MATRIX_NV */
-      1731, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-      1826, /* GL_VERTEX_PROGRAM_BINDING_NV */
-      1221, /* GL_PROGRAM_ERROR_POSITION_ARB */
-       355, /* GL_DEPTH_CLAMP_NV */
-      1794, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-      1801, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-      1802, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-      1803, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-      1804, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-      1805, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-      1806, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-      1807, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-      1808, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-      1809, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-      1795, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-      1796, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-      1797, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-      1798, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-      1799, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-      1800, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-       747, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-       754, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-       755, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-       756, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-       757, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-       758, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-       759, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-       760, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-       761, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-       762, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-       748, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-       749, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-       750, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-       751, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-       752, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-       753, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-       774, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-       781, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-       782, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-       783, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-       784, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-       785, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-       786, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-      1220, /* GL_PROGRAM_BINDING_ARB */
-       788, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-       789, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-       775, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-       776, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-       777, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-       778, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-       779, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-       780, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-      1646, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-      1643, /* GL_TEXTURE_COMPRESSED */
-      1024, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+      1833, /* GL_VERTEX_PROGRAM_POINT_SIZE */
+      1836, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+      1242, /* GL_PROGRAM_PARAMETER_NV */
+      1821, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+      1246, /* GL_PROGRAM_TARGET_NV */
+      1243, /* GL_PROGRAM_RESIDENT_NV */
+      1735, /* GL_TRACK_MATRIX_NV */
+      1736, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+      1831, /* GL_VERTEX_PROGRAM_BINDING_NV */
+      1224, /* GL_PROGRAM_ERROR_POSITION_ARB */
+       355, /* GL_DEPTH_CLAMP */
+      1799, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+      1806, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+      1807, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+      1808, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+      1809, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+      1810, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+      1811, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+      1812, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+      1813, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+      1814, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+      1800, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+      1801, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+      1802, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+      1803, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+      1804, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+      1805, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+       750, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+       757, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+       758, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+       759, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+       760, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+       761, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+       762, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+       763, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+       764, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+       765, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+       751, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+       752, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+       753, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+       754, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+       755, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+       756, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+       777, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+       784, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+       785, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+       786, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+       787, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+       788, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+       789, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+      1223, /* GL_PROGRAM_BINDING_ARB */
+       791, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+       792, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+       778, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+       779, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+       780, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+       781, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+       782, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+       783, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+      1651, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+      1648, /* GL_TEXTURE_COMPRESSED */
+      1027, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
        269, /* GL_COMPRESSED_TEXTURE_FORMATS */
-       933, /* GL_MAX_VERTEX_UNITS_ARB */
+       936, /* GL_MAX_VERTEX_UNITS_ARB */
         22, /* GL_ACTIVE_VERTEX_UNITS_ARB */
-      1847, /* GL_WEIGHT_SUM_UNITY_ARB */
-      1824, /* GL_VERTEX_BLEND_ARB */
+      1852, /* GL_WEIGHT_SUM_UNITY_ARB */
+      1829, /* GL_VERTEX_BLEND_ARB */
        336, /* GL_CURRENT_WEIGHT_ARB */
-      1846, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-      1845, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-      1844, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-      1843, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-      1840, /* GL_WEIGHT_ARRAY_ARB */
-       383, /* GL_DOT3_RGB */
-       384, /* GL_DOT3_RGBA */
+      1851, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+      1850, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+      1849, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+      1848, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+      1845, /* GL_WEIGHT_ARRAY_ARB */
+       384, /* GL_DOT3_RGB */
+       385, /* GL_DOT3_RGBA */
        263, /* GL_COMPRESSED_RGB_FXT1_3DFX */
        258, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
-       993, /* GL_MULTISAMPLE_3DFX */
-      1386, /* GL_SAMPLE_BUFFERS_3DFX */
-      1377, /* GL_SAMPLES_3DFX */
-       974, /* GL_MODELVIEW2_ARB */
-       977, /* GL_MODELVIEW3_ARB */
-       978, /* GL_MODELVIEW4_ARB */
-       979, /* GL_MODELVIEW5_ARB */
-       980, /* GL_MODELVIEW6_ARB */
-       981, /* GL_MODELVIEW7_ARB */
-       982, /* GL_MODELVIEW8_ARB */
-       983, /* GL_MODELVIEW9_ARB */
-       953, /* GL_MODELVIEW10_ARB */
-       954, /* GL_MODELVIEW11_ARB */
-       955, /* GL_MODELVIEW12_ARB */
-       956, /* GL_MODELVIEW13_ARB */
-       957, /* GL_MODELVIEW14_ARB */
-       958, /* GL_MODELVIEW15_ARB */
-       959, /* GL_MODELVIEW16_ARB */
-       960, /* GL_MODELVIEW17_ARB */
-       961, /* GL_MODELVIEW18_ARB */
-       962, /* GL_MODELVIEW19_ARB */
-       964, /* GL_MODELVIEW20_ARB */
-       965, /* GL_MODELVIEW21_ARB */
-       966, /* GL_MODELVIEW22_ARB */
-       967, /* GL_MODELVIEW23_ARB */
-       968, /* GL_MODELVIEW24_ARB */
-       969, /* GL_MODELVIEW25_ARB */
-       970, /* GL_MODELVIEW26_ARB */
-       971, /* GL_MODELVIEW27_ARB */
-       972, /* GL_MODELVIEW28_ARB */
-       973, /* GL_MODELVIEW29_ARB */
-       975, /* GL_MODELVIEW30_ARB */
-       976, /* GL_MODELVIEW31_ARB */
-       388, /* GL_DOT3_RGB_EXT */
-       386, /* GL_DOT3_RGBA_EXT */
-       947, /* GL_MIRROR_CLAMP_EXT */
-       950, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-       988, /* GL_MODULATE_ADD_ATI */
-       989, /* GL_MODULATE_SIGNED_ADD_ATI */
-       990, /* GL_MODULATE_SUBTRACT_ATI */
-      1853, /* GL_YCBCR_MESA */
-      1080, /* GL_PACK_INVERT_MESA */
+       996, /* GL_MULTISAMPLE_3DFX */
+      1391, /* GL_SAMPLE_BUFFERS_3DFX */
+      1382, /* GL_SAMPLES_3DFX */
+       977, /* GL_MODELVIEW2_ARB */
+       980, /* GL_MODELVIEW3_ARB */
+       981, /* GL_MODELVIEW4_ARB */
+       982, /* GL_MODELVIEW5_ARB */
+       983, /* GL_MODELVIEW6_ARB */
+       984, /* GL_MODELVIEW7_ARB */
+       985, /* GL_MODELVIEW8_ARB */
+       986, /* GL_MODELVIEW9_ARB */
+       956, /* GL_MODELVIEW10_ARB */
+       957, /* GL_MODELVIEW11_ARB */
+       958, /* GL_MODELVIEW12_ARB */
+       959, /* GL_MODELVIEW13_ARB */
+       960, /* GL_MODELVIEW14_ARB */
+       961, /* GL_MODELVIEW15_ARB */
+       962, /* GL_MODELVIEW16_ARB */
+       963, /* GL_MODELVIEW17_ARB */
+       964, /* GL_MODELVIEW18_ARB */
+       965, /* GL_MODELVIEW19_ARB */
+       967, /* GL_MODELVIEW20_ARB */
+       968, /* GL_MODELVIEW21_ARB */
+       969, /* GL_MODELVIEW22_ARB */
+       970, /* GL_MODELVIEW23_ARB */
+       971, /* GL_MODELVIEW24_ARB */
+       972, /* GL_MODELVIEW25_ARB */
+       973, /* GL_MODELVIEW26_ARB */
+       974, /* GL_MODELVIEW27_ARB */
+       975, /* GL_MODELVIEW28_ARB */
+       976, /* GL_MODELVIEW29_ARB */
+       978, /* GL_MODELVIEW30_ARB */
+       979, /* GL_MODELVIEW31_ARB */
+       389, /* GL_DOT3_RGB_EXT */
+       387, /* GL_DOT3_RGBA_EXT */
+       950, /* GL_MIRROR_CLAMP_EXT */
+       953, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+       991, /* GL_MODULATE_ADD_ATI */
+       992, /* GL_MODULATE_SIGNED_ADD_ATI */
+       993, /* GL_MODULATE_SUBTRACT_ATI */
+      1858, /* GL_YCBCR_MESA */
+      1083, /* GL_PACK_INVERT_MESA */
        339, /* GL_DEBUG_OBJECT_MESA */
        340, /* GL_DEBUG_PRINT_MESA */
        338, /* GL_DEBUG_ASSERT_MESA */
@@ -4752,292 +4762,292 @@ static const unsigned reduced_enums[1347] =
        117, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */
        115, /* GL_BUMP_NUM_TEX_UNITS_ATI */
        119, /* GL_BUMP_TEX_UNITS_ATI */
-       447, /* GL_DUDV_ATI */
-       446, /* GL_DU8DV8_ATI */
+       448, /* GL_DUDV_ATI */
+       447, /* GL_DU8DV8_ATI */
        114, /* GL_BUMP_ENVMAP_ATI */
        118, /* GL_BUMP_TARGET_ATI */
-      1485, /* GL_STENCIL_BACK_FUNC */
-      1483, /* GL_STENCIL_BACK_FAIL */
-      1487, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-      1489, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
-       531, /* GL_FRAGMENT_PROGRAM_ARB */
-      1218, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-      1246, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-      1245, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-      1230, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-      1236, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-      1235, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-       881, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-       904, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-       903, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-       894, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-       900, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-       899, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-       864, /* GL_MAX_DRAW_BUFFERS */
-       392, /* GL_DRAW_BUFFER0 */
-       395, /* GL_DRAW_BUFFER1 */
-       416, /* GL_DRAW_BUFFER2 */
-       419, /* GL_DRAW_BUFFER3 */
-       422, /* GL_DRAW_BUFFER4 */
-       425, /* GL_DRAW_BUFFER5 */
-       428, /* GL_DRAW_BUFFER6 */
-       431, /* GL_DRAW_BUFFER7 */
-       434, /* GL_DRAW_BUFFER8 */
-       437, /* GL_DRAW_BUFFER9 */
-       396, /* GL_DRAW_BUFFER10 */
-       399, /* GL_DRAW_BUFFER11 */
-       402, /* GL_DRAW_BUFFER12 */
-       405, /* GL_DRAW_BUFFER13 */
-       408, /* GL_DRAW_BUFFER14 */
-       411, /* GL_DRAW_BUFFER15 */
+      1490, /* GL_STENCIL_BACK_FUNC */
+      1488, /* GL_STENCIL_BACK_FAIL */
+      1492, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+      1494, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+       533, /* GL_FRAGMENT_PROGRAM_ARB */
+      1221, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+      1249, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+      1248, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+      1233, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+      1239, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+      1238, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+       884, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+       907, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+       906, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+       897, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+       903, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+       902, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+       867, /* GL_MAX_DRAW_BUFFERS */
+       393, /* GL_DRAW_BUFFER0 */
+       396, /* GL_DRAW_BUFFER1 */
+       417, /* GL_DRAW_BUFFER2 */
+       420, /* GL_DRAW_BUFFER3 */
+       423, /* GL_DRAW_BUFFER4 */
+       426, /* GL_DRAW_BUFFER5 */
+       429, /* GL_DRAW_BUFFER6 */
+       432, /* GL_DRAW_BUFFER7 */
+       435, /* GL_DRAW_BUFFER8 */
+       438, /* GL_DRAW_BUFFER9 */
+       397, /* GL_DRAW_BUFFER10 */
+       400, /* GL_DRAW_BUFFER11 */
+       403, /* GL_DRAW_BUFFER12 */
+       406, /* GL_DRAW_BUFFER13 */
+       409, /* GL_DRAW_BUFFER14 */
+       412, /* GL_DRAW_BUFFER15 */
         82, /* GL_BLEND_EQUATION_ALPHA */
-       844, /* GL_MATRIX_PALETTE_ARB */
-       875, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-       878, /* GL_MAX_PALETTE_MATRICES_ARB */
+       847, /* GL_MATRIX_PALETTE_ARB */
+       878, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+       881, /* GL_MAX_PALETTE_MATRICES_ARB */
        321, /* GL_CURRENT_PALETTE_MATRIX_ARB */
-       838, /* GL_MATRIX_INDEX_ARRAY_ARB */
+       841, /* GL_MATRIX_INDEX_ARRAY_ARB */
        316, /* GL_CURRENT_MATRIX_INDEX_ARB */
-       840, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-       842, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-       841, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-       839, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-      1673, /* GL_TEXTURE_DEPTH_SIZE */
-       376, /* GL_DEPTH_TEXTURE_MODE */
-      1638, /* GL_TEXTURE_COMPARE_MODE */
-      1636, /* GL_TEXTURE_COMPARE_FUNC */
+       843, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+       845, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+       844, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+       842, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+      1678, /* GL_TEXTURE_DEPTH_SIZE */
+       377, /* GL_DEPTH_TEXTURE_MODE */
+      1643, /* GL_TEXTURE_COMPARE_MODE */
+      1641, /* GL_TEXTURE_COMPARE_FUNC */
        242, /* GL_COMPARE_R_TO_TEXTURE */
-      1152, /* GL_POINT_SPRITE */
+      1155, /* GL_POINT_SPRITE */
        296, /* GL_COORD_REPLACE */
-      1156, /* GL_POINT_SPRITE_R_MODE_NV */
-      1275, /* GL_QUERY_COUNTER_BITS */
+      1159, /* GL_POINT_SPRITE_R_MODE_NV */
+      1280, /* GL_QUERY_COUNTER_BITS */
        323, /* GL_CURRENT_QUERY */
-      1277, /* GL_QUERY_RESULT */
-      1279, /* GL_QUERY_RESULT_AVAILABLE */
-       927, /* GL_MAX_VERTEX_ATTRIBS */
-      1814, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
-       374, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
-       373, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
-       913, /* GL_MAX_TEXTURE_COORDS */
-       915, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-      1223, /* GL_PROGRAM_ERROR_STRING_ARB */
-      1225, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-      1224, /* GL_PROGRAM_FORMAT_ARB */
-      1722, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+      1282, /* GL_QUERY_RESULT */
+      1284, /* GL_QUERY_RESULT_AVAILABLE */
+       930, /* GL_MAX_VERTEX_ATTRIBS */
+      1819, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+       375, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
+       374, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
+       916, /* GL_MAX_TEXTURE_COORDS */
+       918, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+      1226, /* GL_PROGRAM_ERROR_STRING_ARB */
+      1228, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+      1227, /* GL_PROGRAM_FORMAT_ARB */
+      1727, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
        353, /* GL_DEPTH_BOUNDS_TEST_EXT */
        352, /* GL_DEPTH_BOUNDS_EXT */
         53, /* GL_ARRAY_BUFFER */
-       460, /* GL_ELEMENT_ARRAY_BUFFER */
+       461, /* GL_ELEMENT_ARRAY_BUFFER */
         54, /* GL_ARRAY_BUFFER_BINDING */
-       461, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-      1788, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-      1014, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+       462, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
+      1793, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+      1017, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
        149, /* GL_COLOR_ARRAY_BUFFER_BINDING */
-       623, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-      1651, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-       456, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-      1398, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-       509, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-      1841, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-      1810, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-      1226, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-       887, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-      1232, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-       896, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-      1244, /* GL_PROGRAM_TEMPORARIES_ARB */
-       902, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-      1234, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-       898, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-      1238, /* GL_PROGRAM_PARAMETERS_ARB */
-       901, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-      1233, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-       897, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-      1219, /* GL_PROGRAM_ATTRIBS_ARB */
-       882, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-      1231, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-       895, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-      1217, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-       880, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-      1229, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-       893, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-       888, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-       884, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-      1247, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-      1735, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-      1288, /* GL_READ_ONLY */
-      1849, /* GL_WRITE_ONLY */
-      1290, /* GL_READ_WRITE */
+       625, /* GL_INDEX_ARRAY_BUFFER_BINDING */
+      1656, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+       457, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
+      1403, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+       511, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
+      1846, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+      1815, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+      1229, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+       890, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+      1235, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+       899, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+      1247, /* GL_PROGRAM_TEMPORARIES_ARB */
+       905, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+      1237, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+       901, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+      1241, /* GL_PROGRAM_PARAMETERS_ARB */
+       904, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+      1236, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+       900, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+      1222, /* GL_PROGRAM_ATTRIBS_ARB */
+       885, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+      1234, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+       898, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+      1220, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+       883, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+      1232, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+       896, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+       891, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+       887, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+      1250, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+      1740, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+      1293, /* GL_READ_ONLY */
+      1854, /* GL_WRITE_ONLY */
+      1295, /* GL_READ_WRITE */
        102, /* GL_BUFFER_ACCESS */
        105, /* GL_BUFFER_MAPPED */
        107, /* GL_BUFFER_MAP_POINTER */
-      1729, /* GL_TIME_ELAPSED_EXT */
-       798, /* GL_MATRIX0_ARB */
-       810, /* GL_MATRIX1_ARB */
-       822, /* GL_MATRIX2_ARB */
-       826, /* GL_MATRIX3_ARB */
-       828, /* GL_MATRIX4_ARB */
-       830, /* GL_MATRIX5_ARB */
-       832, /* GL_MATRIX6_ARB */
-       834, /* GL_MATRIX7_ARB */
-       836, /* GL_MATRIX8_ARB */
-       837, /* GL_MATRIX9_ARB */
-       800, /* GL_MATRIX10_ARB */
-       801, /* GL_MATRIX11_ARB */
-       802, /* GL_MATRIX12_ARB */
-       803, /* GL_MATRIX13_ARB */
-       804, /* GL_MATRIX14_ARB */
-       805, /* GL_MATRIX15_ARB */
-       806, /* GL_MATRIX16_ARB */
-       807, /* GL_MATRIX17_ARB */
-       808, /* GL_MATRIX18_ARB */
-       809, /* GL_MATRIX19_ARB */
-       812, /* GL_MATRIX20_ARB */
-       813, /* GL_MATRIX21_ARB */
-       814, /* GL_MATRIX22_ARB */
-       815, /* GL_MATRIX23_ARB */
-       816, /* GL_MATRIX24_ARB */
-       817, /* GL_MATRIX25_ARB */
-       818, /* GL_MATRIX26_ARB */
-       819, /* GL_MATRIX27_ARB */
-       820, /* GL_MATRIX28_ARB */
-       821, /* GL_MATRIX29_ARB */
-       824, /* GL_MATRIX30_ARB */
-       825, /* GL_MATRIX31_ARB */
-      1518, /* GL_STREAM_DRAW */
-      1520, /* GL_STREAM_READ */
-      1516, /* GL_STREAM_COPY */
-      1476, /* GL_STATIC_DRAW */
-      1478, /* GL_STATIC_READ */
-      1474, /* GL_STATIC_COPY */
-       450, /* GL_DYNAMIC_DRAW */
-       452, /* GL_DYNAMIC_READ */
-       448, /* GL_DYNAMIC_COPY */
-      1120, /* GL_PIXEL_PACK_BUFFER */
-      1124, /* GL_PIXEL_UNPACK_BUFFER */
-      1121, /* GL_PIXEL_PACK_BUFFER_BINDING */
-      1125, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+      1734, /* GL_TIME_ELAPSED_EXT */
+       801, /* GL_MATRIX0_ARB */
+       813, /* GL_MATRIX1_ARB */
+       825, /* GL_MATRIX2_ARB */
+       829, /* GL_MATRIX3_ARB */
+       831, /* GL_MATRIX4_ARB */
+       833, /* GL_MATRIX5_ARB */
+       835, /* GL_MATRIX6_ARB */
+       837, /* GL_MATRIX7_ARB */
+       839, /* GL_MATRIX8_ARB */
+       840, /* GL_MATRIX9_ARB */
+       803, /* GL_MATRIX10_ARB */
+       804, /* GL_MATRIX11_ARB */
+       805, /* GL_MATRIX12_ARB */
+       806, /* GL_MATRIX13_ARB */
+       807, /* GL_MATRIX14_ARB */
+       808, /* GL_MATRIX15_ARB */
+       809, /* GL_MATRIX16_ARB */
+       810, /* GL_MATRIX17_ARB */
+       811, /* GL_MATRIX18_ARB */
+       812, /* GL_MATRIX19_ARB */
+       815, /* GL_MATRIX20_ARB */
+       816, /* GL_MATRIX21_ARB */
+       817, /* GL_MATRIX22_ARB */
+       818, /* GL_MATRIX23_ARB */
+       819, /* GL_MATRIX24_ARB */
+       820, /* GL_MATRIX25_ARB */
+       821, /* GL_MATRIX26_ARB */
+       822, /* GL_MATRIX27_ARB */
+       823, /* GL_MATRIX28_ARB */
+       824, /* GL_MATRIX29_ARB */
+       827, /* GL_MATRIX30_ARB */
+       828, /* GL_MATRIX31_ARB */
+      1523, /* GL_STREAM_DRAW */
+      1525, /* GL_STREAM_READ */
+      1521, /* GL_STREAM_COPY */
+      1481, /* GL_STATIC_DRAW */
+      1483, /* GL_STATIC_READ */
+      1479, /* GL_STATIC_COPY */
+       451, /* GL_DYNAMIC_DRAW */
+       453, /* GL_DYNAMIC_READ */
+       449, /* GL_DYNAMIC_COPY */
+      1123, /* GL_PIXEL_PACK_BUFFER */
+      1127, /* GL_PIXEL_UNPACK_BUFFER */
+      1124, /* GL_PIXEL_PACK_BUFFER_BINDING */
+      1128, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
        347, /* GL_DEPTH24_STENCIL8 */
-      1719, /* GL_TEXTURE_STENCIL_SIZE */
-      1671, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
-       883, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-       886, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-       890, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-       889, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-       847, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-      1509, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+      1724, /* GL_TEXTURE_STENCIL_SIZE */
+      1676, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+       886, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+       889, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+       893, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+       892, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+       850, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
+      1514, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
         17, /* GL_ACTIVE_STENCIL_FACE_EXT */
-       948, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-      1379, /* GL_SAMPLES_PASSED */
+       951, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+      1384, /* GL_SAMPLES_PASSED */
        109, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */
        104, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */
-       532, /* GL_FRAGMENT_SHADER */
-      1834, /* GL_VERTEX_SHADER */
-      1237, /* GL_PROGRAM_OBJECT_ARB */
-      1411, /* GL_SHADER_OBJECT_ARB */
-       871, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-       931, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-       925, /* GL_MAX_VARYING_FLOATS */
-       929, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-       856, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-      1040, /* GL_OBJECT_TYPE_ARB */
-      1413, /* GL_SHADER_TYPE */
-       497, /* GL_FLOAT_VEC2 */
-       499, /* GL_FLOAT_VEC3 */
-       501, /* GL_FLOAT_VEC4 */
-       650, /* GL_INT_VEC2 */
-       652, /* GL_INT_VEC3 */
-       654, /* GL_INT_VEC4 */
+       534, /* GL_FRAGMENT_SHADER */
+      1839, /* GL_VERTEX_SHADER */
+      1240, /* GL_PROGRAM_OBJECT_ARB */
+      1416, /* GL_SHADER_OBJECT_ARB */
+       874, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+       934, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+       928, /* GL_MAX_VARYING_FLOATS */
+       932, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+       859, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+      1043, /* GL_OBJECT_TYPE_ARB */
+      1418, /* GL_SHADER_TYPE */
+       499, /* GL_FLOAT_VEC2 */
+       501, /* GL_FLOAT_VEC3 */
+       503, /* GL_FLOAT_VEC4 */
+       652, /* GL_INT_VEC2 */
+       654, /* GL_INT_VEC3 */
+       656, /* GL_INT_VEC4 */
         94, /* GL_BOOL */
         96, /* GL_BOOL_VEC2 */
         98, /* GL_BOOL_VEC3 */
        100, /* GL_BOOL_VEC4 */
-       485, /* GL_FLOAT_MAT2 */
-       489, /* GL_FLOAT_MAT3 */
-       493, /* GL_FLOAT_MAT4 */
-      1370, /* GL_SAMPLER_1D */
-      1372, /* GL_SAMPLER_2D */
-      1374, /* GL_SAMPLER_3D */
-      1375, /* GL_SAMPLER_CUBE */
-      1371, /* GL_SAMPLER_1D_SHADOW */
-      1373, /* GL_SAMPLER_2D_SHADOW */
-       487, /* GL_FLOAT_MAT2x3 */
-       488, /* GL_FLOAT_MAT2x4 */
-       491, /* GL_FLOAT_MAT3x2 */
-       492, /* GL_FLOAT_MAT3x4 */
-       495, /* GL_FLOAT_MAT4x2 */
-       496, /* GL_FLOAT_MAT4x3 */
+       487, /* GL_FLOAT_MAT2 */
+       491, /* GL_FLOAT_MAT3 */
+       495, /* GL_FLOAT_MAT4 */
+      1375, /* GL_SAMPLER_1D */
+      1377, /* GL_SAMPLER_2D */
+      1379, /* GL_SAMPLER_3D */
+      1380, /* GL_SAMPLER_CUBE */
+      1376, /* GL_SAMPLER_1D_SHADOW */
+      1378, /* GL_SAMPLER_2D_SHADOW */
+       489, /* GL_FLOAT_MAT2x3 */
+       490, /* GL_FLOAT_MAT2x4 */
+       493, /* GL_FLOAT_MAT3x2 */
+       494, /* GL_FLOAT_MAT3x4 */
+       497, /* GL_FLOAT_MAT4x2 */
+       498, /* GL_FLOAT_MAT4x3 */
        345, /* GL_DELETE_STATUS */
        246, /* GL_COMPILE_STATUS */
-       705, /* GL_LINK_STATUS */
-      1782, /* GL_VALIDATE_STATUS */
-       635, /* GL_INFO_LOG_LENGTH */
+       708, /* GL_LINK_STATUS */
+      1787, /* GL_VALIDATE_STATUS */
+       637, /* GL_INFO_LOG_LENGTH */
         56, /* GL_ATTACHED_SHADERS */
         20, /* GL_ACTIVE_UNIFORMS */
         21, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
-      1412, /* GL_SHADER_SOURCE_LENGTH */
+      1417, /* GL_SHADER_SOURCE_LENGTH */
         15, /* GL_ACTIVE_ATTRIBUTES */
         16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */
-       534, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
-      1415, /* GL_SHADING_LANGUAGE_VERSION */
+       536, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
+      1420, /* GL_SHADING_LANGUAGE_VERSION */
        322, /* GL_CURRENT_PROGRAM */
-      1089, /* GL_PALETTE4_RGB8_OES */
-      1091, /* GL_PALETTE4_RGBA8_OES */
-      1087, /* GL_PALETTE4_R5_G6_B5_OES */
-      1090, /* GL_PALETTE4_RGBA4_OES */
-      1088, /* GL_PALETTE4_RGB5_A1_OES */
-      1094, /* GL_PALETTE8_RGB8_OES */
-      1096, /* GL_PALETTE8_RGBA8_OES */
-      1092, /* GL_PALETTE8_R5_G6_B5_OES */
-      1095, /* GL_PALETTE8_RGBA4_OES */
-      1093, /* GL_PALETTE8_RGB5_A1_OES */
-       617, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
-       616, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-      1767, /* GL_UNSIGNED_NORMALIZED */
-      1606, /* GL_TEXTURE_1D_ARRAY_EXT */
-      1258, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-      1608, /* GL_TEXTURE_2D_ARRAY_EXT */
-      1261, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-      1614, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-      1616, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-      1468, /* GL_SRGB */
-      1469, /* GL_SRGB8 */
-      1471, /* GL_SRGB_ALPHA */
-      1470, /* GL_SRGB8_ALPHA8 */
-      1428, /* GL_SLUMINANCE_ALPHA */
-      1427, /* GL_SLUMINANCE8_ALPHA8 */
-      1425, /* GL_SLUMINANCE */
-      1426, /* GL_SLUMINANCE8 */
+      1092, /* GL_PALETTE4_RGB8_OES */
+      1094, /* GL_PALETTE4_RGBA8_OES */
+      1090, /* GL_PALETTE4_R5_G6_B5_OES */
+      1093, /* GL_PALETTE4_RGBA4_OES */
+      1091, /* GL_PALETTE4_RGB5_A1_OES */
+      1097, /* GL_PALETTE8_RGB8_OES */
+      1099, /* GL_PALETTE8_RGBA8_OES */
+      1095, /* GL_PALETTE8_R5_G6_B5_OES */
+      1098, /* GL_PALETTE8_RGBA4_OES */
+      1096, /* GL_PALETTE8_RGB5_A1_OES */
+       619, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
+       618, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
+      1772, /* GL_UNSIGNED_NORMALIZED */
+      1611, /* GL_TEXTURE_1D_ARRAY_EXT */
+      1262, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
+      1613, /* GL_TEXTURE_2D_ARRAY_EXT */
+      1265, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
+      1619, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
+      1621, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
+      1473, /* GL_SRGB */
+      1474, /* GL_SRGB8 */
+      1476, /* GL_SRGB_ALPHA */
+      1475, /* GL_SRGB8_ALPHA8 */
+      1433, /* GL_SLUMINANCE_ALPHA */
+      1432, /* GL_SLUMINANCE8_ALPHA8 */
+      1430, /* GL_SLUMINANCE */
+      1431, /* GL_SLUMINANCE8 */
        267, /* GL_COMPRESSED_SRGB */
        268, /* GL_COMPRESSED_SRGB_ALPHA */
        265, /* GL_COMPRESSED_SLUMINANCE */
        266, /* GL_COMPRESSED_SLUMINANCE_ALPHA */
-      1154, /* GL_POINT_SPRITE_COORD_ORIGIN */
-       713, /* GL_LOWER_LEFT */
-      1779, /* GL_UPPER_LEFT */
-      1491, /* GL_STENCIL_BACK_REF */
-      1492, /* GL_STENCIL_BACK_VALUE_MASK */
-      1493, /* GL_STENCIL_BACK_WRITEMASK */
-       441, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
-      1304, /* GL_RENDERBUFFER_BINDING_EXT */
-      1285, /* GL_READ_FRAMEBUFFER */
-       440, /* GL_DRAW_FRAMEBUFFER */
-      1286, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
-      1314, /* GL_RENDERBUFFER_SAMPLES */
-       544, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
-       542, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
-       553, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
-       549, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
-       551, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
-       556, /* GL_FRAMEBUFFER_COMPLETE */
-       560, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
-       566, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
-       564, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
-       562, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
-       565, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
-       563, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
-       569, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
-       572, /* GL_FRAMEBUFFER_UNSUPPORTED */
-       570, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
-       853, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
+      1157, /* GL_POINT_SPRITE_COORD_ORIGIN */
+       716, /* GL_LOWER_LEFT */
+      1784, /* GL_UPPER_LEFT */
+      1496, /* GL_STENCIL_BACK_REF */
+      1497, /* GL_STENCIL_BACK_VALUE_MASK */
+      1498, /* GL_STENCIL_BACK_WRITEMASK */
+       442, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
+      1309, /* GL_RENDERBUFFER_BINDING_EXT */
+      1290, /* GL_READ_FRAMEBUFFER */
+       441, /* GL_DRAW_FRAMEBUFFER */
+      1291, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
+      1319, /* GL_RENDERBUFFER_SAMPLES */
+       546, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
+       544, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
+       555, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
+       551, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
+       553, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+       558, /* GL_FRAMEBUFFER_COMPLETE */
+       562, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
+       568, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
+       566, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
+       564, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
+       567, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
+       565, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
+       571, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
+       574, /* GL_FRAMEBUFFER_UNSUPPORTED */
+       572, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
+       856, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
        155, /* GL_COLOR_ATTACHMENT0 */
        157, /* GL_COLOR_ATTACHMENT1 */
        171, /* GL_COLOR_ATTACHMENT2 */
@@ -5055,56 +5065,56 @@ static const unsigned reduced_enums[1347] =
        166, /* GL_COLOR_ATTACHMENT14 */
        168, /* GL_COLOR_ATTACHMENT15 */
        348, /* GL_DEPTH_ATTACHMENT */
-      1481, /* GL_STENCIL_ATTACHMENT */
-       535, /* GL_FRAMEBUFFER */
-      1302, /* GL_RENDERBUFFER */
-      1316, /* GL_RENDERBUFFER_WIDTH */
-      1309, /* GL_RENDERBUFFER_HEIGHT */
-      1311, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
-      1504, /* GL_STENCIL_INDEX_EXT */
-      1501, /* GL_STENCIL_INDEX1_EXT */
-      1502, /* GL_STENCIL_INDEX4_EXT */
-      1503, /* GL_STENCIL_INDEX8_EXT */
-      1500, /* GL_STENCIL_INDEX16_EXT */
-      1313, /* GL_RENDERBUFFER_RED_SIZE */
-      1308, /* GL_RENDERBUFFER_GREEN_SIZE */
-      1305, /* GL_RENDERBUFFER_BLUE_SIZE */
-      1303, /* GL_RENDERBUFFER_ALPHA_SIZE */
-      1306, /* GL_RENDERBUFFER_DEPTH_SIZE */
-      1315, /* GL_RENDERBUFFER_STENCIL_SIZE */
-       568, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
-       909, /* GL_MAX_SAMPLES */
-      1272, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
-       482, /* GL_FIRST_VERTEX_CONVENTION_EXT */
-       665, /* GL_LAST_VERTEX_CONVENTION_EXT */
-      1251, /* GL_PROVOKING_VERTEX_EXT */
+      1486, /* GL_STENCIL_ATTACHMENT */
+       537, /* GL_FRAMEBUFFER */
+      1307, /* GL_RENDERBUFFER */
+      1321, /* GL_RENDERBUFFER_WIDTH */
+      1314, /* GL_RENDERBUFFER_HEIGHT */
+      1316, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+      1509, /* GL_STENCIL_INDEX_EXT */
+      1506, /* GL_STENCIL_INDEX1_EXT */
+      1507, /* GL_STENCIL_INDEX4_EXT */
+      1508, /* GL_STENCIL_INDEX8_EXT */
+      1505, /* GL_STENCIL_INDEX16_EXT */
+      1318, /* GL_RENDERBUFFER_RED_SIZE */
+      1313, /* GL_RENDERBUFFER_GREEN_SIZE */
+      1310, /* GL_RENDERBUFFER_BLUE_SIZE */
+      1308, /* GL_RENDERBUFFER_ALPHA_SIZE */
+      1311, /* GL_RENDERBUFFER_DEPTH_SIZE */
+      1320, /* GL_RENDERBUFFER_STENCIL_SIZE */
+       570, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
+       912, /* GL_MAX_SAMPLES */
+      1276, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */
+       483, /* GL_FIRST_VERTEX_CONVENTION */
+       667, /* GL_LAST_VERTEX_CONVENTION */
+      1254, /* GL_PROVOKING_VERTEX */
        302, /* GL_COPY_READ_BUFFER */
        303, /* GL_COPY_WRITE_BUFFER */
-      1363, /* GL_RGBA_SNORM */
-      1359, /* GL_RGBA8_SNORM */
-      1421, /* GL_SIGNED_NORMALIZED */
-       910, /* GL_MAX_SERVER_WAIT_TIMEOUT */
-      1039, /* GL_OBJECT_TYPE */
-      1525, /* GL_SYNC_CONDITION */
-      1530, /* GL_SYNC_STATUS */
-      1527, /* GL_SYNC_FLAGS */
-      1526, /* GL_SYNC_FENCE */
-      1529, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
-      1756, /* GL_UNSIGNALED */
-      1420, /* GL_SIGNALED */
+      1368, /* GL_RGBA_SNORM */
+      1364, /* GL_RGBA8_SNORM */
+      1426, /* GL_SIGNED_NORMALIZED */
+       913, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+      1042, /* GL_OBJECT_TYPE */
+      1530, /* GL_SYNC_CONDITION */
+      1535, /* GL_SYNC_STATUS */
+      1532, /* GL_SYNC_FLAGS */
+      1531, /* GL_SYNC_FENCE */
+      1534, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+      1761, /* GL_UNSIGNALED */
+      1425, /* GL_SIGNALED */
         46, /* GL_ALREADY_SIGNALED */
-      1727, /* GL_TIMEOUT_EXPIRED */
+      1732, /* GL_TIMEOUT_EXPIRED */
        270, /* GL_CONDITION_SATISFIED */
-      1839, /* GL_WAIT_FAILED */
-       467, /* GL_EVAL_BIT */
-      1283, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-       707, /* GL_LIST_BIT */
-      1622, /* GL_TEXTURE_BIT */
-      1394, /* GL_SCISSOR_BIT */
+      1844, /* GL_WAIT_FAILED */
+       468, /* GL_EVAL_BIT */
+      1288, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+       710, /* GL_LIST_BIT */
+      1627, /* GL_TEXTURE_BIT */
+      1399, /* GL_SCISSOR_BIT */
         29, /* GL_ALL_ATTRIB_BITS */
-       995, /* GL_MULTISAMPLE_BIT */
+       998, /* GL_MULTISAMPLE_BIT */
         30, /* GL_ALL_CLIENT_ATTRIB_BITS */
-      1728, /* GL_TIMEOUT_IGNORED */
+      1733, /* GL_TIMEOUT_IGNORED */
 };
 
 typedef int (*cfunc)(const void *, const void *);
diff --git a/src/mesa/main/extensions.c b/src/mesa/main/extensions.c
index e3070b1547..6b11aceb5c 100644
--- a/src/mesa/main/extensions.c
+++ b/src/mesa/main/extensions.c
@@ -47,7 +47,9 @@ static const struct {
 } default_extensions[] = {
    { OFF, "GL_ARB_copy_buffer",                F(ARB_copy_buffer) },
    { OFF, "GL_ARB_depth_texture",              F(ARB_depth_texture) },
+   { OFF, "GL_ARB_depth_clamp",                F(ARB_depth_clamp) },
    { ON,  "GL_ARB_draw_buffers",               F(ARB_draw_buffers) },
+   { OFF, "GL_ARB_draw_elements_base_vertex",  F(ARB_draw_elements_base_vertex) },
    { OFF, "GL_ARB_fragment_program",           F(ARB_fragment_program) },
    { OFF, "GL_ARB_fragment_program_shadow",    F(ARB_fragment_program_shadow) },
    { OFF, "GL_ARB_fragment_shader",            F(ARB_fragment_shader) },
@@ -61,6 +63,7 @@ static const struct {
    { OFF, "GL_ARB_pixel_buffer_object",        F(EXT_pixel_buffer_object) },
    { OFF, "GL_ARB_point_parameters",           F(EXT_point_parameters) },
    { OFF, "GL_ARB_point_sprite",               F(ARB_point_sprite) },
+   { OFF, "GL_ARB_provoking_vertex",           F(EXT_provoking_vertex) },
    { OFF, "GL_ARB_seamless_cube_map",          F(ARB_seamless_cube_map) },
    { OFF, "GL_ARB_shader_objects",             F(ARB_shader_objects) },
    { OFF, "GL_ARB_shading_language_100",       F(ARB_shading_language_100) },
@@ -162,6 +165,7 @@ static const struct {
    { OFF, "GL_MESA_ycbcr_texture",             F(MESA_ycbcr_texture) },
    { ON,  "GL_MESA_window_pos",                F(ARB_window_pos) },
    { OFF, "GL_NV_blend_square",                F(NV_blend_square) },
+   { OFF, "GL_NV_depth_clamp",                 F(ARB_depth_clamp) },
    { OFF, "GL_NV_fragment_program",            F(NV_fragment_program) },
    { ON,  "GL_NV_light_max_exponent",          F(NV_light_max_exponent) },
    { OFF, "GL_NV_point_sprite",                F(NV_point_sprite) },
@@ -192,8 +196,10 @@ void
 _mesa_enable_sw_extensions(GLcontext *ctx)
 {
    ctx->Extensions.ARB_copy_buffer = GL_TRUE;
+   ctx->Extensions.ARB_depth_clamp = GL_TRUE;
    ctx->Extensions.ARB_depth_texture = GL_TRUE;
    /*ctx->Extensions.ARB_draw_buffers = GL_TRUE;*/
+   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
 #if FEATURE_ARB_fragment_program
    ctx->Extensions.ARB_fragment_program = GL_TRUE;
    ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
diff --git a/src/mesa/main/fbobject.c b/src/mesa/main/fbobject.c
index 825a23090b..13f49da5a7 100644
--- a/src/mesa/main/fbobject.c
+++ b/src/mesa/main/fbobject.c
@@ -46,6 +46,10 @@
 #include "texstore.h"
 
 
+/** Set this to 1 to help debug FBO incompleteness problems */
+#define DEBUG_FBO 0
+
+
 /**
  * Notes:
  *
@@ -308,8 +312,8 @@ _mesa_framebuffer_renderbuffer(GLcontext *ctx, struct gl_framebuffer *fb,
 static void
 att_incomplete(const char *msg)
 {
-#if 0
-   _mesa_printf("attachment incomplete: %s\n", msg);
+#if DEBUG_FBO
+   _mesa_debug(NULL, "attachment incomplete: %s\n", msg);
 #else
    (void) msg;
 #endif
@@ -317,6 +321,23 @@ att_incomplete(const char *msg)
 
 
 /**
+ * For debug only.
+ */
+static void
+fbo_incomplete(const char *msg, int index)
+{
+#if DEBUG_FBO
+   _mesa_debug(NULL, "FBO Incomplete: %s [%d]\n", msg, index);
+#else
+   (void) msg;
+   (void) index;
+#endif
+}
+
+
+
+
+/**
  * Test if an attachment point is complete and update its Complete field.
  * \param format if GL_COLOR, this is a color attachment point,
  *               if GL_DEPTH, this is a depth component attachment point,
@@ -468,20 +489,6 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format,
 
 
 /**
- * Helpful for debugging
- */
-static void
-fbo_incomplete(const char *msg, int index)
-{
-   (void) msg;
-   (void) index;
-   /*
-   _mesa_debug(NULL, "FBO Incomplete: %s [%d]\n", msg, index);
-   */
-}
-
-
-/**
  * Test if the given framebuffer object is complete and update its
  * Status field with the results.
  * Calls the ctx->Driver.ValidateFramebuffer() function to allow the
@@ -1953,13 +1960,13 @@ _mesa_GenerateMipmapEXT(GLenum target)
 
    _mesa_lock_texture(ctx, texObj);
    if (target == GL_TEXTURE_CUBE_MAP) {
-      int face;
-
+      GLuint face;
       for (face = 0; face < 6; face++)
 	 ctx->Driver.GenerateMipmap(ctx,
 				    GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + face,
 				    texObj);
-   } else {
+   }
+   else {
       ctx->Driver.GenerateMipmap(ctx, target, texObj);
    }
    _mesa_unlock_texture(ctx, texObj);
diff --git a/src/mesa/main/get.c b/src/mesa/main/get.c
index 477ed01030..a6e004a816 100644
--- a/src/mesa/main/get.c
+++ b/src/mesa/main/get.c
@@ -1722,6 +1722,10 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMin);
          params[1] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMax);
          break;
+      case GL_DEPTH_CLAMP:
+         CHECK_EXT1(ARB_depth_clamp, "GetBooleanv");
+         params[0] = ctx->Transform.DepthClamp;
+         break;
       case GL_MAX_DRAW_BUFFERS_ARB:
          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxDrawBuffers);
          break;
@@ -3553,6 +3557,10 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          params[0] = ctx->Depth.BoundsMin;
          params[1] = ctx->Depth.BoundsMax;
          break;
+      case GL_DEPTH_CLAMP:
+         CHECK_EXT1(ARB_depth_clamp, "GetFloatv");
+         params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.DepthClamp);
+         break;
       case GL_MAX_DRAW_BUFFERS_ARB:
          params[0] = (GLfloat)(ctx->Const.MaxDrawBuffers);
          break;
@@ -5384,6 +5392,10 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          params[0] = IROUND(ctx->Depth.BoundsMin);
          params[1] = IROUND(ctx->Depth.BoundsMax);
          break;
+      case GL_DEPTH_CLAMP:
+         CHECK_EXT1(ARB_depth_clamp, "GetIntegerv");
+         params[0] = BOOLEAN_TO_INT(ctx->Transform.DepthClamp);
+         break;
       case GL_MAX_DRAW_BUFFERS_ARB:
          params[0] = ctx->Const.MaxDrawBuffers;
          break;
@@ -7216,6 +7228,10 @@ _mesa_GetInteger64v( GLenum pname, GLint64 *params )
          params[0] = IROUND64(ctx->Depth.BoundsMin);
          params[1] = IROUND64(ctx->Depth.BoundsMax);
          break;
+      case GL_DEPTH_CLAMP:
+         CHECK_EXT1(ARB_depth_clamp, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Transform.DepthClamp);
+         break;
       case GL_MAX_DRAW_BUFFERS_ARB:
          params[0] = ctx->Const.MaxDrawBuffers;
          break;
diff --git a/src/mesa/main/get_gen.py b/src/mesa/main/get_gen.py
index 2878c1b552..364d8c55c4 100644
--- a/src/mesa/main/get_gen.py
+++ b/src/mesa/main/get_gen.py
@@ -905,6 +905,10 @@ StateVars = [
 	  ["ctx->Depth.BoundsMin", "ctx->Depth.BoundsMax"],
 	  "", ["EXT_depth_bounds_test"] ),
 
+	# GL_ARB_depth_clamp
+	( "GL_DEPTH_CLAMP", GLboolean, ["ctx->Transform.DepthClamp"], "",
+	  ["ARB_depth_clamp"] ),
+
 	# GL_ARB_draw_buffers
 	( "GL_MAX_DRAW_BUFFERS_ARB", GLint,
 	  ["ctx->Const.MaxDrawBuffers"], "", None ),
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 6b64bf8139..ae169fb9db 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -1482,6 +1482,7 @@ struct gl_transform_attrib
    GLboolean Normalize;				/**< Normalize all normals? */
    GLboolean RescaleNormals;			/**< GL_EXT_rescale_normal */
    GLboolean RasterPositionUnclipped;           /**< GL_IBM_rasterpos_clip */
+   GLboolean DepthClamp;			/**< GL_ARB_depth_clamp */
 
    GLboolean CullVertexFlag;	/**< True if GL_CULL_VERTEX_EXT is enabled */
    GLfloat CullEyePos[4];
@@ -2475,7 +2476,9 @@ struct gl_extensions
    GLboolean dummy;  /* don't remove this! */
    GLboolean ARB_copy_buffer;
    GLboolean ARB_depth_texture;
+   GLboolean ARB_depth_clamp;
    GLboolean ARB_draw_buffers;
+   GLboolean ARB_draw_elements_base_vertex;
    GLboolean ARB_fragment_program;
    GLboolean ARB_fragment_program_shadow;
    GLboolean ARB_fragment_shader;
diff --git a/src/mesa/main/syncobj.c b/src/mesa/main/syncobj.c
index 64f923ff91..ac3f9eb175 100644
--- a/src/mesa/main/syncobj.c
+++ b/src/mesa/main/syncobj.c
@@ -190,7 +190,7 @@ _mesa_unref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj)
 }
 
 
-GLboolean
+GLboolean GLAPIENTRY
 _mesa_IsSync(GLsync sync)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -201,7 +201,7 @@ _mesa_IsSync(GLsync sync)
 }
 
 
-void
+void GLAPIENTRY
 _mesa_DeleteSync(GLsync sync)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -231,7 +231,7 @@ _mesa_DeleteSync(GLsync sync)
 }
 
 
-GLsync
+GLsync GLAPIENTRY
 _mesa_FenceSync(GLenum condition, GLbitfield flags)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -278,7 +278,7 @@ _mesa_FenceSync(GLenum condition, GLbitfield flags)
 }
 
 
-GLenum
+GLenum GLAPIENTRY
 _mesa_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -319,7 +319,7 @@ _mesa_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 }
 
 
-void
+void GLAPIENTRY
 _mesa_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -348,7 +348,7 @@ _mesa_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 }
 
 
-void
+void GLAPIENTRY
 _mesa_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length,
 		GLint *values)
 {
diff --git a/src/mesa/main/syncobj.h b/src/mesa/main/syncobj.h
index fc160af289..f23fa281e2 100644
--- a/src/mesa/main/syncobj.h
+++ b/src/mesa/main/syncobj.h
@@ -48,22 +48,22 @@ _mesa_ref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj);
 extern void
 _mesa_unref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj);
 
-extern GLboolean
+extern GLboolean GLAPIENTRY
 _mesa_IsSync(GLsync sync);
 
-extern void
+extern void GLAPIENTRY
 _mesa_DeleteSync(GLsync sync);
 
-extern GLsync
+extern GLsync GLAPIENTRY
 _mesa_FenceSync(GLenum condition, GLbitfield flags);
 
-extern GLenum
+extern GLenum GLAPIENTRY
 _mesa_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
 
-extern void
+extern void GLAPIENTRY
 _mesa_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
 
-extern void
+extern void GLAPIENTRY
 _mesa_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length,
 		GLint *values);
 
diff --git a/src/mesa/main/texenvprogram.c b/src/mesa/main/texenvprogram.c
index 870970a355..2f3e47e69e 100644
--- a/src/mesa/main/texenvprogram.c
+++ b/src/mesa/main/texenvprogram.c
@@ -248,6 +248,40 @@ static GLuint translate_mode( GLenum envMode, GLenum mode )
 
 
 /**
+ * Do we need to clamp the results of the given texture env/combine mode?
+ * If the inputs to the mode are in [0,1] we don't always have to clamp
+ * the results.
+ */
+static GLboolean
+need_saturate( GLuint mode )
+{
+   switch (mode) {
+   case MODE_REPLACE:
+   case MODE_MODULATE:
+   case MODE_INTERPOLATE:
+      return GL_FALSE;
+   case MODE_ADD:
+   case MODE_ADD_SIGNED:
+   case MODE_SUBTRACT:
+   case MODE_DOT3_RGB:
+   case MODE_DOT3_RGB_EXT:
+   case MODE_DOT3_RGBA:
+   case MODE_DOT3_RGBA_EXT:
+   case MODE_MODULATE_ADD_ATI:
+   case MODE_MODULATE_SIGNED_ADD_ATI:
+   case MODE_MODULATE_SUBTRACT_ATI:
+   case MODE_ADD_PRODUCTS:
+   case MODE_ADD_PRODUCTS_SIGNED:
+   case MODE_BUMP_ENVMAP_ATI:
+      return GL_TRUE;
+   default:
+      assert(0);
+   }
+}
+
+
+
+/**
  * Translate TEXTURE_x_BIT to TEXTURE_x_INDEX.
  */
 static GLuint translate_tex_src_bit( GLbitfield bit )
@@ -1116,7 +1150,7 @@ static struct ureg
 emit_texenv(struct texenv_fragment_program *p, GLuint unit)
 {
    const struct state_key *key = p->state;
-   GLboolean saturate;
+   GLboolean rgb_saturate, alpha_saturate;
    GLuint rgb_shift, alpha_shift;
    struct ureg out, dest;
 
@@ -1146,7 +1180,19 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
    /* If we'll do rgb/alpha shifting don't saturate in emit_combine().
     * We don't want to clamp twice.
     */
-   saturate = !(rgb_shift || alpha_shift);
+   if (rgb_shift)
+      rgb_saturate = GL_FALSE;  /* saturate after rgb shift */
+   else if (need_saturate(key->unit[unit].ModeRGB))
+      rgb_saturate = GL_TRUE;
+   else
+      rgb_saturate = GL_FALSE;
+
+   if (alpha_shift)
+      alpha_saturate = GL_FALSE;  /* saturate after alpha shift */
+   else if (need_saturate(key->unit[unit].ModeA))
+      alpha_saturate = GL_TRUE;
+   else
+      alpha_saturate = GL_FALSE;
 
    /* If this is the very last calculation, emit direct to output reg:
     */
@@ -1162,7 +1208,7 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
     */
    if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&
        args_match(key, unit)) {
-      out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
+      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
 			  unit,
 			  key->unit[unit].NumArgsRGB,
 			  key->unit[unit].ModeRGB,
@@ -1170,7 +1216,7 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
    }
    else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||
 	    key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {
-      out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
+      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
 			  unit,
 			  key->unit[unit].NumArgsRGB,
 			  key->unit[unit].ModeRGB,
@@ -1180,12 +1226,12 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
       /* Need to do something to stop from re-emitting identical
        * argument calculations here:
        */
-      out = emit_combine( p, dest, WRITEMASK_XYZ, saturate,
+      out = emit_combine( p, dest, WRITEMASK_XYZ, rgb_saturate,
 			  unit,
 			  key->unit[unit].NumArgsRGB,
 			  key->unit[unit].ModeRGB,
 			  key->unit[unit].OptRGB);
-      out = emit_combine( p, dest, WRITEMASK_W, saturate,
+      out = emit_combine( p, dest, WRITEMASK_W, alpha_saturate,
 			  unit,
 			  key->unit[unit].NumArgsA,
 			  key->unit[unit].ModeA,
@@ -1196,8 +1242,7 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
     */
    if (alpha_shift || rgb_shift) {
       struct ureg shift;
-
-      saturate = GL_TRUE;  /* always saturate at this point */
+      GLboolean saturate = GL_TRUE;  /* always saturate at this point */
 
       if (rgb_shift == alpha_shift) {
 	 shift = register_scalar_const(p, (GLfloat)(1<<rgb_shift));
diff --git a/src/mesa/main/texgen.c b/src/mesa/main/texgen.c
index e3feb024c3..b3ecfc784e 100644
--- a/src/mesa/main/texgen.c
+++ b/src/mesa/main/texgen.c
@@ -35,6 +35,7 @@
 #include "main/enums.h"
 #include "main/macros.h"
 #include "main/texgen.h"
+#include "main/texstate.h"
 #include "math/m_matrix.h"
 
 
@@ -79,7 +80,7 @@ _mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    texgen = get_texgen(texUnit, coord);
    if (!texgen) {
@@ -231,7 +232,7 @@ _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    texgen = get_texgen(texUnit, coord);
    if (!texgen) {
@@ -269,7 +270,7 @@ _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    texgen = get_texgen(texUnit, coord);
    if (!texgen) {
@@ -307,7 +308,7 @@ _mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    texgen = get_texgen(texUnit, coord);
    if (!texgen) {
diff --git a/src/mesa/main/teximage.c b/src/mesa/main/teximage.c
index 8228303040..b0aa04e9aa 100644
--- a/src/mesa/main/teximage.c
+++ b/src/mesa/main/teximage.c
@@ -2075,6 +2075,23 @@ update_fbo_texture(GLcontext *ctx, struct gl_texture_object *texObj,
 }
 
 
+/**
+ * If the texture object's GenerateMipmap flag is set and we've
+ * changed the texture base level image, regenerate the rest of the
+ * mipmap levels now.
+ */
+static INLINE void
+check_gen_mipmap(GLcontext *ctx, GLenum target,
+                 struct gl_texture_object *texObj, GLint level)
+{
+   ASSERT(target != GL_TEXTURE_CUBE_MAP);
+   if (texObj->GenerateMipmap && level == texObj->BaseLevel) {
+      ASSERT(ctx->Driver.GenerateMipmap);
+      ctx->Driver.GenerateMipmap(ctx, target, texObj);
+   }
+}
+
+
 /** Debug helper: override the user-requested internal format */
 static GLenum
 override_internal_format(GLenum internalFormat, GLint width, GLint height)
@@ -2161,36 +2178,36 @@ _mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat,
 	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
 	 if (!texImage) {
 	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
-	    goto out;
-	 }
-      
-	 if (texImage->Data) {
-	    ctx->Driver.FreeTexImageData( ctx, texImage );
 	 }
+         else {
+            if (texImage->Data) {
+               ctx->Driver.FreeTexImageData( ctx, texImage );
+            }
+
+            ASSERT(texImage->Data == NULL);
+
+            clear_teximage_fields(texImage); /* not really needed, but helpful */
+            _mesa_init_teximage_fields(ctx, target, texImage,
+                                       postConvWidth, 1, 1,
+                                       border, internalFormat);
+
+            /* Give the texture to the driver.  <pixels> may be null. */
+            ASSERT(ctx->Driver.TexImage1D);
+            ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
+                                   width, border, format, type, pixels,
+                                   &ctx->Unpack, texObj, texImage);
+
+            ASSERT(texImage->TexFormat);
+
+            check_gen_mipmap(ctx, target, texObj, level);
 
-	 ASSERT(texImage->Data == NULL);
-
-	 clear_teximage_fields(texImage); /* not really needed, but helpful */
-	 _mesa_init_teximage_fields(ctx, target, texImage,
-				    postConvWidth, 1, 1,
-				    border, internalFormat);
-	 
-	 ASSERT(ctx->Driver.TexImage1D);
-
-	 /* Give the texture to the driver!  <pixels> may be null! */
-	 (*ctx->Driver.TexImage1D)(ctx, target, level, internalFormat,
-				   width, border, format, type, pixels,
-				   &ctx->Unpack, texObj, texImage);
-	 
-	 ASSERT(texImage->TexFormat);
-
-	 update_fbo_texture(ctx, texObj, face, level);
-	 
-	 /* state update */
-	 texObj->_Complete = GL_FALSE;
-	 ctx->NewState |= _NEW_TEXTURE;
-      }
-   out:
+            update_fbo_texture(ctx, texObj, face, level);
+
+            /* state update */
+            texObj->_Complete = GL_FALSE;
+            ctx->NewState |= _NEW_TEXTURE;
+         }
+      }
       _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_1D) {
@@ -2269,35 +2286,35 @@ _mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,
 	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
 	 if (!texImage) {
 	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
-	    goto out;
-	 }
-	 
-	 if (texImage->Data) {
-	    ctx->Driver.FreeTexImageData( ctx, texImage );
 	 }
-	 
-	 ASSERT(texImage->Data == NULL);
-	 clear_teximage_fields(texImage); /* not really needed, but helpful */
-	 _mesa_init_teximage_fields(ctx, target, texImage,
-				    postConvWidth, postConvHeight, 1,
-				    border, internalFormat);
-	 
-	 ASSERT(ctx->Driver.TexImage2D);
-
-	 /* Give the texture to the driver!  <pixels> may be null! */
-	 (*ctx->Driver.TexImage2D)(ctx, target, level, internalFormat,
-				   width, height, border, format, type, pixels,
-				   &ctx->Unpack, texObj, texImage);
-	 
-	 ASSERT(texImage->TexFormat);
-
-	 update_fbo_texture(ctx, texObj, face, level);
-
-	 /* state update */
-	 texObj->_Complete = GL_FALSE;
-	 ctx->NewState |= _NEW_TEXTURE;
-      }
-   out:
+         else {
+            if (texImage->Data) {
+               ctx->Driver.FreeTexImageData( ctx, texImage );
+            }
+
+            ASSERT(texImage->Data == NULL);
+            clear_teximage_fields(texImage); /* not really needed, but helpful */
+            _mesa_init_teximage_fields(ctx, target, texImage,
+                                       postConvWidth, postConvHeight, 1,
+                                       border, internalFormat);
+
+            /* Give the texture to the driver.  <pixels> may be null. */
+            ASSERT(ctx->Driver.TexImage2D);
+            ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
+                                   width, height, border, format, type,
+                                   pixels, &ctx->Unpack, texObj, texImage);
+
+            ASSERT(texImage->TexFormat);
+
+            check_gen_mipmap(ctx, target, texObj, level);
+
+            update_fbo_texture(ctx, texObj, face, level);
+
+            /* state update */
+            texObj->_Complete = GL_FALSE;
+            ctx->NewState |= _NEW_TEXTURE;
+         }
+      }
       _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_2D ||
@@ -2372,35 +2389,35 @@ _mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,
 	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
 	 if (!texImage) {
 	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
-	    goto out;
 	 }
-	 
-	 if (texImage->Data) {
-	    ctx->Driver.FreeTexImageData( ctx, texImage );
-	 }
-	 
-	 ASSERT(texImage->Data == NULL);
-	 clear_teximage_fields(texImage); /* not really needed, but helpful */
-	 _mesa_init_teximage_fields(ctx, target, texImage,
-				    width, height, depth,
-				    border, internalFormat);
+         else {
+            if (texImage->Data) {
+               ctx->Driver.FreeTexImageData( ctx, texImage );
+            }
 
-	 ASSERT(ctx->Driver.TexImage3D);
+            ASSERT(texImage->Data == NULL);
+            clear_teximage_fields(texImage); /* not really needed, but helpful */
+            _mesa_init_teximage_fields(ctx, target, texImage,
+                                       width, height, depth,
+                                       border, internalFormat);
 
-	 /* Give the texture to the driver!  <pixels> may be null! */
-	 (*ctx->Driver.TexImage3D)(ctx, target, level, internalFormat,
-				   width, height, depth, border, format, type,
-				   pixels, &ctx->Unpack, texObj, texImage);
+            /* Give the texture to the driver.  <pixels> may be null. */
+            ASSERT(ctx->Driver.TexImage3D);
+            ctx->Driver.TexImage3D(ctx, target, level, internalFormat,
+                                   width, height, depth, border, format, type,
+                                   pixels, &ctx->Unpack, texObj, texImage);
 
-	 ASSERT(texImage->TexFormat);
+            ASSERT(texImage->TexFormat);
 
-	 update_fbo_texture(ctx, texObj, face, level);
+            check_gen_mipmap(ctx, target, texObj, level);
 
-	 /* state update */
-	 texObj->_Complete = GL_FALSE;
-	 ctx->NewState |= _NEW_TEXTURE;
+            update_fbo_texture(ctx, texObj, face, level);
+
+            /* state update */
+            texObj->_Complete = GL_FALSE;
+            ctx->NewState |= _NEW_TEXTURE;
+         }
       }
-   out:
       _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_3D ||
@@ -2480,23 +2497,24 @@ _mesa_TexSubImage1D( GLenum target, GLint level,
       texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
       if (subtexture_error_check2(ctx, 1, target, level, xoffset, 0, 0,
-				  postConvWidth, 1, 1, format, type, texImage)) {
-	 goto out;   /* error was detected */
+				  postConvWidth, 1, 1,
+                                  format, type, texImage)) {
+         /* error was recorded */
       }
+      else if (width > 0) {
+         /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+         xoffset += texImage->Border;
 
-      if (width == 0)
-	 goto out;  /* no-op, not an error */
+         ASSERT(ctx->Driver.TexSubImage1D);
+         ctx->Driver.TexSubImage1D(ctx, target, level, xoffset, width,
+                                   format, type, pixels, &ctx->Unpack,
+                                   texObj, texImage);
 
-      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-      xoffset += texImage->Border;
+         check_gen_mipmap(ctx, target, texObj, level);
 
-      ASSERT(ctx->Driver.TexSubImage1D);
-      (*ctx->Driver.TexSubImage1D)(ctx, target, level, xoffset, width,
-				   format, type, pixels, &ctx->Unpack,
-				   texObj, texImage);
-      ctx->NewState |= _NEW_TEXTURE;
+         ctx->NewState |= _NEW_TEXTURE;
+      }
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -2533,30 +2551,31 @@ _mesa_TexSubImage2D( GLenum target, GLint level,
 
    texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
    _mesa_lock_texture(ctx, texObj);
    {
       texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
       if (subtexture_error_check2(ctx, 2, target, level, xoffset, yoffset, 0,
-				  postConvWidth, postConvHeight, 1, format, type, 
-				  texImage)) {
-	 goto out;   /* error was detected */
+				  postConvWidth, postConvHeight, 1,
+                                  format, type, texImage)) {
+	 /* error was recorded */
       }
+      else if (width > 0 && height >= 0) {
+         /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+         xoffset += texImage->Border;
+         yoffset += texImage->Border;
+
+         ASSERT(ctx->Driver.TexSubImage2D);
+         ctx->Driver.TexSubImage2D(ctx, target, level, xoffset, yoffset,
+                                   width, height, format, type, pixels,
+                                   &ctx->Unpack, texObj, texImage);
 
-      if (width == 0 || height == 0)
-	 goto out;  /* no-op, not an error */
+         check_gen_mipmap(ctx, target, texObj, level);
 
-      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-      xoffset += texImage->Border;
-      yoffset += texImage->Border;
-      
-      ASSERT(ctx->Driver.TexSubImage2D);
-      (*ctx->Driver.TexSubImage2D)(ctx, target, level, xoffset, yoffset,
-				   width, height, format, type, pixels,
-				   &ctx->Unpack, texObj, texImage);
-      ctx->NewState |= _NEW_TEXTURE;
+         ctx->NewState |= _NEW_TEXTURE;
+      }
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -2590,28 +2609,30 @@ _mesa_TexSubImage3D( GLenum target, GLint level,
    {
       texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
-      if (subtexture_error_check2(ctx, 3, target, level, xoffset, yoffset, zoffset,
-				  width, height, depth, format, type, texImage)) {
-	 goto out;   /* error was detected */
+      if (subtexture_error_check2(ctx, 3, target, level,
+                                  xoffset, yoffset, zoffset,
+				  width, height, depth,
+                                  format, type, texImage)) {
+         /* error was recorded */
       }
+      else if (width > 0 && height > 0 && height > 0) {
+         /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+         xoffset += texImage->Border;
+         yoffset += texImage->Border;
+         zoffset += texImage->Border;
 
-      if (width == 0 || height == 0 || height == 0)
-	 goto out;  /* no-op, not an error */
+         ASSERT(ctx->Driver.TexSubImage3D);
+         ctx->Driver.TexSubImage3D(ctx, target, level,
+                                   xoffset, yoffset, zoffset,
+                                   width, height, depth,
+                                   format, type, pixels,
+                                   &ctx->Unpack, texObj, texImage );
 
-      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-      xoffset += texImage->Border;
-      yoffset += texImage->Border;
-      zoffset += texImage->Border;
+         check_gen_mipmap(ctx, target, texObj, level);
 
-      ASSERT(ctx->Driver.TexSubImage3D);
-      (*ctx->Driver.TexSubImage3D)(ctx, target, level,
-				   xoffset, yoffset, zoffset,
-				   width, height, depth,
-				   format, type, pixels,
-				   &ctx->Unpack, texObj, texImage );
-      ctx->NewState |= _NEW_TEXTURE;
+         ctx->NewState |= _NEW_TEXTURE;
+      }
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -2646,38 +2667,39 @@ _mesa_CopyTexImage1D( GLenum target, GLint level,
 
    texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
    _mesa_lock_texture(ctx, texObj);
    {
       texImage = _mesa_get_tex_image(ctx, texObj, target, level);
       if (!texImage) {
 	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
-	 goto out;
       }
+      else {
+         if (texImage->Data) {
+            ctx->Driver.FreeTexImageData( ctx, texImage );
+         }
 
-      if (texImage->Data) {
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-      }
-      
-      ASSERT(texImage->Data == NULL);
+         ASSERT(texImage->Data == NULL);
 
-      clear_teximage_fields(texImage); /* not really needed, but helpful */
-      _mesa_init_teximage_fields(ctx, target, texImage, postConvWidth, 1, 1,
-				 border, internalFormat);
+         clear_teximage_fields(texImage); /* not really needed, but helpful */
+         _mesa_init_teximage_fields(ctx, target, texImage, postConvWidth, 1, 1,
+                                    border, internalFormat);
 
+         ASSERT(ctx->Driver.CopyTexImage1D);
+         ctx->Driver.CopyTexImage1D(ctx, target, level, internalFormat,
+                                    x, y, width, border);
 
-      ASSERT(ctx->Driver.CopyTexImage1D);
-      (*ctx->Driver.CopyTexImage1D)(ctx, target, level, internalFormat,
-				    x, y, width, border);
+         ASSERT(texImage->TexFormat);
 
-      ASSERT(texImage->TexFormat);
+         check_gen_mipmap(ctx, target, texObj, level);
 
-      update_fbo_texture(ctx, texObj, face, level);
+         update_fbo_texture(ctx, texObj, face, level);
 
-      /* state update */
-      texObj->_Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
+         /* state update */
+         texObj->_Complete = GL_FALSE;
+         ctx->NewState |= _NEW_TEXTURE;
+      }
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -2719,33 +2741,34 @@ _mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat,
 
       if (!texImage) {
 	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
-	 goto out;
       }
-      
-      if (texImage->Data) {
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-      }
-      
-      ASSERT(texImage->Data == NULL);
+      else {
+         if (texImage->Data) {
+            ctx->Driver.FreeTexImageData( ctx, texImage );
+         }
 
-      clear_teximage_fields(texImage); /* not really needed, but helpful */
-      _mesa_init_teximage_fields(ctx, target, texImage,
-				 postConvWidth, postConvHeight, 1,
-				 border, internalFormat);
-      
-      ASSERT(ctx->Driver.CopyTexImage2D);
-      (*ctx->Driver.CopyTexImage2D)(ctx, target, level, internalFormat,
-				    x, y, width, height, border);
-      
-      ASSERT(texImage->TexFormat);
+         ASSERT(texImage->Data == NULL);
 
-      update_fbo_texture(ctx, texObj, face, level);
+         clear_teximage_fields(texImage); /* not really needed, but helpful */
+         _mesa_init_teximage_fields(ctx, target, texImage,
+                                    postConvWidth, postConvHeight, 1,
+                                    border, internalFormat);
+
+         ASSERT(ctx->Driver.CopyTexImage2D);
+         ctx->Driver.CopyTexImage2D(ctx, target, level, internalFormat,
+                                    x, y, width, height, border);
+
+         ASSERT(texImage->TexFormat);
 
-      /* state update */
-      texObj->_Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
+         check_gen_mipmap(ctx, target, texObj, level);
+
+         update_fbo_texture(ctx, texObj, face, level);
+
+         /* state update */
+         texObj->_Complete = GL_FALSE;
+         ctx->NewState |= _NEW_TEXTURE;
+      }
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -2785,23 +2808,25 @@ _mesa_CopyTexSubImage1D( GLenum target, GLint level,
 
       if (copytexsubimage_error_check2(ctx, 1, target, level,
 				       xoffset, 0, 0, postConvWidth, 1,
-				       texImage))
-	 goto out;
-      
+				       texImage)) {
+         /* error was recorded */
+      }
+      else {
+         /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+         xoffset += texImage->Border;
 
-      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-      xoffset += texImage->Border;
+         if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,
+                                        &width, &height)) {
+            ASSERT(ctx->Driver.CopyTexSubImage1D);
+            ctx->Driver.CopyTexSubImage1D(ctx, target, level,
+                                          xoffset, x, y, width);
 
-      if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,
-                                     &width, &height)) {
-         ASSERT(ctx->Driver.CopyTexSubImage1D);
-         ctx->Driver.CopyTexSubImage1D(ctx, target, level,
-                                       xoffset, x, y, width);
-      }
+            check_gen_mipmap(ctx, target, texObj, level);
 
-      ctx->NewState |= _NEW_TEXTURE;
+            ctx->NewState |= _NEW_TEXTURE;
+         }
+      }
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -2839,24 +2864,29 @@ _mesa_CopyTexSubImage2D( GLenum target, GLint level,
       }
 #endif
 
-      if (copytexsubimage_error_check2(ctx, 2, target, level, xoffset, yoffset, 0,
-				       postConvWidth, postConvHeight, texImage))
-	 goto out;
+      if (copytexsubimage_error_check2(ctx, 2, target, level,
+                                       xoffset, yoffset, 0,
+				       postConvWidth, postConvHeight,
+                                       texImage)) {
+         /* error was recorded */
+      }
+      else {
+         /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+         xoffset += texImage->Border;
+         yoffset += texImage->Border;
+
+         if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,
+                                        &width, &height)) {
+            ASSERT(ctx->Driver.CopyTexSubImage2D);
+            ctx->Driver.CopyTexSubImage2D(ctx, target, level, xoffset, yoffset,
+                                          x, y, width, height);
 
-      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-      xoffset += texImage->Border;
-      yoffset += texImage->Border;
+            check_gen_mipmap(ctx, target, texObj, level);
 
-      if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,
-                                     &width, &height)) {
-         ASSERT(ctx->Driver.CopyTexSubImage2D);
-         ctx->Driver.CopyTexSubImage2D(ctx, target, level,
-				       xoffset, yoffset, x, y, width, height);
+            ctx->NewState |= _NEW_TEXTURE;
+         }
       }
-
-      ctx->NewState |= _NEW_TEXTURE;
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -2896,25 +2926,28 @@ _mesa_CopyTexSubImage3D( GLenum target, GLint level,
 
       if (copytexsubimage_error_check2(ctx, 3, target, level, xoffset, yoffset,
 				       zoffset, postConvWidth, postConvHeight,
-				       texImage))
-	 goto out;
-
-      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-      xoffset += texImage->Border;
-      yoffset += texImage->Border;
-      zoffset += texImage->Border;
-      
-      if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,
-                                     &width, &height)) {
-         ASSERT(ctx->Driver.CopyTexSubImage3D);
-         ctx->Driver.CopyTexSubImage3D(ctx, target, level,
-				       xoffset, yoffset, zoffset,
-				       x, y, width, height);
+				       texImage)) {
+         /* error was recored */
       }
+      else {
+         /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+         xoffset += texImage->Border;
+         yoffset += texImage->Border;
+         zoffset += texImage->Border;
+
+         if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,
+                                        &width, &height)) {
+            ASSERT(ctx->Driver.CopyTexSubImage3D);
+            ctx->Driver.CopyTexSubImage3D(ctx, target, level,
+                                          xoffset, yoffset, zoffset,
+                                          x, y, width, height);
+
+            check_gen_mipmap(ctx, target, texObj, level);
 
-      ctx->NewState |= _NEW_TEXTURE;
+            ctx->NewState |= _NEW_TEXTURE;
+         }
+      }
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -3142,28 +3175,29 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level,
 	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
 	 if (!texImage) {
 	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1D");
-	    goto out;
 	 }
-	 
-	 if (texImage->Data) {
-	    ctx->Driver.FreeTexImageData( ctx, texImage );
-	 }
-	 ASSERT(texImage->Data == NULL);
+         else {
+            if (texImage->Data) {
+               ctx->Driver.FreeTexImageData( ctx, texImage );
+            }
+            ASSERT(texImage->Data == NULL);
 
-	 _mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
-				    border, internalFormat);
+            _mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
+                                       border, internalFormat);
 
-	 ASSERT(ctx->Driver.CompressedTexImage1D);
-	 (*ctx->Driver.CompressedTexImage1D)(ctx, target, level,
-					     internalFormat, width, border,
-					     imageSize, data,
-					     texObj, texImage);
+            ASSERT(ctx->Driver.CompressedTexImage1D);
+            ctx->Driver.CompressedTexImage1D(ctx, target, level,
+                                             internalFormat, width, border,
+                                             imageSize, data,
+                                             texObj, texImage);
 
-	 /* state update */
-	 texObj->_Complete = GL_FALSE;
-	 ctx->NewState |= _NEW_TEXTURE;
+            check_gen_mipmap(ctx, target, texObj, level);
+
+            /* state update */
+            texObj->_Complete = GL_FALSE;
+            ctx->NewState |= _NEW_TEXTURE;
+         }
       }
-   out:
       _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_1D) {
@@ -3239,28 +3273,29 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level,
 	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
 	 if (!texImage) {
 	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2D");
-	    goto out;
-	 }
-	 
-	 if (texImage->Data) {
-	    ctx->Driver.FreeTexImageData( ctx, texImage );
 	 }
-	 ASSERT(texImage->Data == NULL);
-
-	 _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
-				    border, internalFormat);
-
-	 ASSERT(ctx->Driver.CompressedTexImage2D);
-	 (*ctx->Driver.CompressedTexImage2D)(ctx, target, level,
-					     internalFormat, width, height,
-					     border, imageSize, data,
-					     texObj, texImage);
-	 
-	 /* state update */
-	 texObj->_Complete = GL_FALSE;
-	 ctx->NewState |= _NEW_TEXTURE;
-      }
-   out:
+         else {
+            if (texImage->Data) {
+               ctx->Driver.FreeTexImageData( ctx, texImage );
+            }
+            ASSERT(texImage->Data == NULL);
+
+            _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
+                                       border, internalFormat);
+
+            ASSERT(ctx->Driver.CompressedTexImage2D);
+            ctx->Driver.CompressedTexImage2D(ctx, target, level,
+                                             internalFormat, width, height,
+                                             border, imageSize, data,
+                                             texObj, texImage);
+
+            check_gen_mipmap(ctx, target, texObj, level);
+
+            /* state update */
+            texObj->_Complete = GL_FALSE;
+            ctx->NewState |= _NEW_TEXTURE;
+         }
+      }
       _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_2D ||
@@ -3334,29 +3369,31 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level,
 	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
 	 if (!texImage) {
 	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3D");
-	    goto out;
-	 }
-	 
-	 if (texImage->Data) {
-	    ctx->Driver.FreeTexImageData( ctx, texImage );
 	 }
-	 ASSERT(texImage->Data == NULL);
-
-	 _mesa_init_teximage_fields(ctx, target, texImage, width, height, depth,
-				    border, internalFormat);
-
-	 ASSERT(ctx->Driver.CompressedTexImage3D);
-	 (*ctx->Driver.CompressedTexImage3D)(ctx, target, level,
-					     internalFormat,
-					     width, height, depth,
-					     border, imageSize, data,
-					     texObj, texImage);
-	 
-	 /* state update */
-	 texObj->_Complete = GL_FALSE;
-	 ctx->NewState |= _NEW_TEXTURE;
-      }
-   out:
+         else {
+            if (texImage->Data) {
+               ctx->Driver.FreeTexImageData( ctx, texImage );
+            }
+            ASSERT(texImage->Data == NULL);
+
+            _mesa_init_teximage_fields(ctx, target, texImage,
+                                       width, height, depth,
+                                       border, internalFormat);
+
+            ASSERT(ctx->Driver.CompressedTexImage3D);
+            ctx->Driver.CompressedTexImage3D(ctx, target, level,
+                                             internalFormat,
+                                             width, height, depth,
+                                             border, imageSize, data,
+                                             texObj, texImage);
+
+            check_gen_mipmap(ctx, target, texObj, level);
+
+            /* state update */
+            texObj->_Complete = GL_FALSE;
+            ctx->NewState |= _NEW_TEXTURE;
+         }
+      }
       _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_3D) {
@@ -3422,6 +3459,7 @@ _mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
 
    texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
    _mesa_lock_texture(ctx, texObj);
    {
       texImage = _mesa_select_tex_image(ctx, texObj, target, level);
@@ -3430,26 +3468,25 @@ _mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
       if ((GLint) format != texImage->InternalFormat) {
 	 _mesa_error(ctx, GL_INVALID_OPERATION,
 		     "glCompressedTexSubImage1D(format)");
-	 goto out;
       }
+      else if ((width == 1 || width == 2) &&
+               (GLuint) width != texImage->Width) {
+	 _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glCompressedTexSubImage1D(width)");
+      }
+      else if (width > 0) {
+         if (ctx->Driver.CompressedTexSubImage1D) {
+            ctx->Driver.CompressedTexSubImage1D(ctx, target, level,
+                                                xoffset, width,
+                                                format, imageSize, data,
+                                                texObj, texImage);
+         }
 
-      if ((width == 1 || width == 2) && (GLuint) width != texImage->Width) {
-	 _mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage1D(width)");
-	 goto out;
-      }
-      
-      if (width == 0)
-	 goto out;  /* no-op, not an error */
+         check_gen_mipmap(ctx, target, texObj, level);
 
-      if (ctx->Driver.CompressedTexSubImage1D) {
-	 (*ctx->Driver.CompressedTexSubImage1D)(ctx, target, level,
-						xoffset, width,
-						format, imageSize, data,
-						texObj, texImage);
+         ctx->NewState |= _NEW_TEXTURE;
       }
-      ctx->NewState |= _NEW_TEXTURE;
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -3479,6 +3516,7 @@ _mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
 
    texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
    _mesa_lock_texture(ctx, texObj);
    {
       texImage = _mesa_select_tex_image(ctx, texObj, target, level);
@@ -3487,27 +3525,26 @@ _mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
       if ((GLint) format != texImage->InternalFormat) {
 	 _mesa_error(ctx, GL_INVALID_OPERATION,
 		     "glCompressedTexSubImage2D(format)");
-	 goto out;
       }
-
-      if (((width == 1 || width == 2) && (GLuint) width != texImage->Width) ||
-	  ((height == 1 || height == 2) && (GLuint) height != texImage->Height)) {
+      else if (((width == 1 || width == 2)
+                && (GLuint) width != texImage->Width) ||
+               ((height == 1 || height == 2)
+                && (GLuint) height != texImage->Height)) {
 	 _mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage2D(size)");
-	 goto out;
       }
-      
-      if (width == 0 || height == 0)
-	 goto out;  /* no-op, not an error */
-
-      if (ctx->Driver.CompressedTexSubImage2D) {
-	 (*ctx->Driver.CompressedTexSubImage2D)(ctx, target, level,
+      else if (width > 0 && height > 0) {
+         if (ctx->Driver.CompressedTexSubImage2D) {
+            ctx->Driver.CompressedTexSubImage2D(ctx, target, level,
 						xoffset, yoffset, width, height,
 						format, imageSize, data,
 						texObj, texImage);
+         }
+
+         check_gen_mipmap(ctx, target, texObj, level);
+
+         ctx->NewState |= _NEW_TEXTURE;
       }
-      ctx->NewState |= _NEW_TEXTURE;
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
@@ -3536,6 +3573,7 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
 
    texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
    _mesa_lock_texture(ctx, texObj);
    {
       texImage = _mesa_select_tex_image(ctx, texObj, target, level);
@@ -3544,29 +3582,29 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
       if ((GLint) format != texImage->InternalFormat) {
 	 _mesa_error(ctx, GL_INVALID_OPERATION,
 		     "glCompressedTexSubImage3D(format)");
-	 goto out;
       }
-
-      if (((width == 1 || width == 2) && (GLuint) width != texImage->Width) ||
-	  ((height == 1 || height == 2) && (GLuint) height != texImage->Height) ||
-	  ((depth == 1 || depth == 2) && (GLuint) depth != texImage->Depth)) {
+      else if (((width == 1 || width == 2)
+                && (GLuint) width != texImage->Width) ||
+               ((height == 1 || height == 2)
+                && (GLuint) height != texImage->Height) ||
+               ((depth == 1 || depth == 2)
+                && (GLuint) depth != texImage->Depth)) {
 	 _mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage3D(size)");
-	 goto out;
       }
-      
-      if (width == 0 || height == 0 || depth == 0)
-	 goto out;  /* no-op, not an error */
-
-      if (ctx->Driver.CompressedTexSubImage3D) {
-	 (*ctx->Driver.CompressedTexSubImage3D)(ctx, target, level,
+      else if (width > 0 && height > 0 && depth > 0) {
+         if (ctx->Driver.CompressedTexSubImage3D) {
+            ctx->Driver.CompressedTexSubImage3D(ctx, target, level,
 						xoffset, yoffset, zoffset,
 						width, height, depth,
 						format, imageSize, data,
 						texObj, texImage);
+         }
+
+         check_gen_mipmap(ctx, target, texObj, level);
+
+         ctx->NewState |= _NEW_TEXTURE;
       }
-      ctx->NewState |= _NEW_TEXTURE;
    }
- out:
    _mesa_unlock_texture(ctx, texObj);
 }
 
diff --git a/src/mesa/main/texparam.c b/src/mesa/main/texparam.c
index 05d144270e..b2fbe2205b 100644
--- a/src/mesa/main/texparam.c
+++ b/src/mesa/main/texparam.c
@@ -70,7 +70,7 @@ validate_texture_wrap_mode(GLcontext * ctx, GLenum target, GLenum wrap)
       return GL_TRUE;
    }
 
-   _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param=0x%x)", wrap );
+   _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)", wrap );
    return GL_FALSE;
 }
 
@@ -210,7 +210,7 @@ set_tex_parameteri(GLcontext *ctx,
          }
          /* fall-through */
       default:
-         _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param=0x%x)",
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)",
                       params[0] );
       }
       return GL_FALSE;
@@ -225,7 +225,7 @@ set_tex_parameteri(GLcontext *ctx,
          texObj->MagFilter = params[0];
          return GL_TRUE;
       default:
-         _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param=0x%x)",
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)",
                       params[0]);
       }
       return GL_FALSE;
diff --git a/src/mesa/main/texstore.c b/src/mesa/main/texstore.c
index a22db628d3..ab9973b810 100644
--- a/src/mesa/main/texstore.c
+++ b/src/mesa/main/texstore.c
@@ -3302,32 +3302,9 @@ _mesa_set_fetch_functions(struct gl_texture_image *texImage, GLuint dims)
 }
 
 
-/**
- * Choose the actual storage format for a new texture image.
- * Mainly, this is a wrapper for the driver's ChooseTextureFormat() function.
- * Also set some other texImage fields related to texture compression, etc.
- * \param ctx  rendering context
- * \param texImage  the gl_texture_image
- * \param dims  texture dimensions (1, 2 or 3)
- * \param format  the user-specified format parameter
- * \param type  the user-specified type parameter
- * \param internalFormat  the user-specified internal format hint
- */
 static void
-choose_texture_format(GLcontext *ctx, struct gl_texture_image *texImage,
-                      GLuint dims,
-                      GLenum format, GLenum type, GLint internalFormat)
+compute_texture_size(GLcontext *ctx, struct gl_texture_image *texImage)
 {
-   ASSERT(dims == 1 || dims == 2 || dims == 3);
-   ASSERT(ctx->Driver.ChooseTextureFormat);
-
-   texImage->TexFormat
-      = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);
-
-   ASSERT(texImage->TexFormat);
-
-   _mesa_set_fetch_functions(texImage, dims);
-
    if (texImage->TexFormat->TexelBytes == 0) {
       /* must be a compressed format */
       texImage->IsCompressed = GL_TRUE;
@@ -3365,7 +3342,12 @@ _mesa_store_teximage1d(GLcontext *ctx, GLenum target, GLint level,
    GLint sizeInBytes;
    (void) border;
 
-   choose_texture_format(ctx, texImage, 1, format, type, internalFormat);
+   texImage->TexFormat
+      = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);
+   ASSERT(texImage->TexFormat);
+
+   _mesa_set_fetch_functions(texImage, 1);
+   compute_texture_size(ctx, texImage);
 
    /* allocate memory */
    if (texImage->IsCompressed)
@@ -3403,11 +3385,6 @@ _mesa_store_teximage1d(GLcontext *ctx, GLenum target, GLint level,
       }
    }
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-
    _mesa_unmap_teximage_pbo(ctx, packing);
 }
 
@@ -3434,7 +3411,12 @@ _mesa_store_teximage2d(GLcontext *ctx, GLenum target, GLint level,
    GLint texelBytes, sizeInBytes;
    (void) border;
 
-   choose_texture_format(ctx, texImage, 2, format, type, internalFormat);
+   texImage->TexFormat
+      = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);
+   ASSERT(texImage->TexFormat);
+
+   _mesa_set_fetch_functions(texImage, 2);
+   compute_texture_size(ctx, texImage);
 
    texelBytes = texImage->TexFormat->TexelBytes;
 
@@ -3481,11 +3463,6 @@ _mesa_store_teximage2d(GLcontext *ctx, GLenum target, GLint level,
       }
    }
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-
    _mesa_unmap_teximage_pbo(ctx, packing);
 }
 
@@ -3508,7 +3485,12 @@ _mesa_store_teximage3d(GLcontext *ctx, GLenum target, GLint level,
    GLint texelBytes, sizeInBytes;
    (void) border;
 
-   choose_texture_format(ctx, texImage, 3, format, type, internalFormat);
+   texImage->TexFormat
+      = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);
+   ASSERT(texImage->TexFormat);
+
+   _mesa_set_fetch_functions(texImage, 3);
+   compute_texture_size(ctx, texImage);
 
    texelBytes = texImage->TexFormat->TexelBytes;
 
@@ -3555,11 +3537,6 @@ _mesa_store_teximage3d(GLcontext *ctx, GLenum target, GLint level,
       }
    }
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-
    _mesa_unmap_teximage_pbo(ctx, packing);
 }
 
@@ -3601,11 +3578,6 @@ _mesa_store_texsubimage1d(GLcontext *ctx, GLenum target, GLint level,
       }
    }
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-
    _mesa_unmap_teximage_pbo(ctx, packing);
 }
 
@@ -3654,11 +3626,6 @@ _mesa_store_texsubimage2d(GLcontext *ctx, GLenum target, GLint level,
       }
    }
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-
    _mesa_unmap_teximage_pbo(ctx, packing);
 }
 
@@ -3707,11 +3674,6 @@ _mesa_store_texsubimage3d(GLcontext *ctx, GLenum target, GLint level,
       }
    }
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-
    _mesa_unmap_teximage_pbo(ctx, packing);
 }
 
@@ -3762,7 +3724,12 @@ _mesa_store_compressed_teximage2d(GLcontext *ctx, GLenum target, GLint level,
    ASSERT(texImage->Depth == 1);
    ASSERT(texImage->Data == NULL); /* was freed in glCompressedTexImage2DARB */
 
-   choose_texture_format(ctx, texImage, 2, 0, 0, internalFormat);
+   texImage->TexFormat
+      = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, 0, 0);
+   ASSERT(texImage->TexFormat);
+
+   _mesa_set_fetch_functions(texImage, 2);
+   compute_texture_size(ctx, texImage);
 
    /* allocate storage */
    texImage->Data = _mesa_alloc_texmemory(imageSize);
@@ -3781,11 +3748,6 @@ _mesa_store_compressed_teximage2d(GLcontext *ctx, GLenum target, GLint level,
    ASSERT(texImage->CompressedSize == (GLuint) imageSize);
    MEMCPY(texImage->Data, data, imageSize);
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-
    _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
 }
 
@@ -3891,11 +3853,6 @@ _mesa_store_compressed_texsubimage2d(GLcontext *ctx, GLenum target,
       src += srcRowStride;
    }
 
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-
    _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
 }
 
diff --git a/src/mesa/main/varray.h b/src/mesa/main/varray.h
index becc67c29d..ef790c504e 100644
--- a/src/mesa/main/varray.h
+++ b/src/mesa/main/varray.h
@@ -129,6 +129,11 @@ extern void GLAPIENTRY
 _mesa_MultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type,
                             const GLvoid **indices, GLsizei primcount );
 
+extern void GLAPIENTRY
+_mesa_MultiDrawElementsBaseVertex( GLenum mode,
+				   const GLsizei *count, GLenum type,
+				   const GLvoid **indices, GLsizei primcount,
+				   const GLint *basevertex);
 
 extern void GLAPIENTRY
 _mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first,
@@ -159,6 +164,16 @@ extern void GLAPIENTRY
 _mesa_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
                         GLenum type, const GLvoid *indices);
 
+extern void GLAPIENTRY
+_mesa_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+			     const GLvoid *indices, GLint basevertex);
+
+extern void GLAPIENTRY
+_mesa_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
+				  GLsizei count, GLenum type,
+				  const GLvoid *indices,
+				  GLint basevertex);
+
 
 extern void
 _mesa_copy_client_array(GLcontext *ctx,
diff --git a/src/mesa/main/version.h b/src/mesa/main/version.h
index d4d3dd1a94..0cae1860a3 100644
--- a/src/mesa/main/version.h
+++ b/src/mesa/main/version.h
@@ -1,6 +1,6 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.6
+ * Version:  7.7
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
@@ -30,9 +30,9 @@
 
 /* Mesa version */
 #define MESA_MAJOR 7
-#define MESA_MINOR 6
+#define MESA_MINOR 7
 #define MESA_PATCH 0
-#define MESA_VERSION_STRING "7.6-devel"
+#define MESA_VERSION_STRING "7.7-devel"
 
 /* To make version comparison easy */
 #define MESA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
diff --git a/src/mesa/main/vtxfmt.c b/src/mesa/main/vtxfmt.c
index 8d6f560a80..91412f138a 100644
--- a/src/mesa/main/vtxfmt.c
+++ b/src/mesa/main/vtxfmt.c
@@ -134,6 +134,9 @@ install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt )
    SET_DrawElements(tab, vfmt->DrawElements);
    SET_DrawRangeElements(tab, vfmt->DrawRangeElements);
    SET_MultiDrawElementsEXT(tab, vfmt->MultiDrawElementsEXT);
+   SET_DrawElementsBaseVertex(tab, vfmt->DrawElementsBaseVertex);
+   SET_DrawRangeElementsBaseVertex(tab, vfmt->DrawRangeElementsBaseVertex);
+   SET_MultiDrawElementsBaseVertex(tab, vfmt->MultiDrawElementsBaseVertex);
    SET_EvalMesh1(tab, vfmt->EvalMesh1);
    SET_EvalMesh2(tab, vfmt->EvalMesh2);
    ASSERT(tab->EvalMesh2);
diff --git a/src/mesa/main/vtxfmt_tmp.h b/src/mesa/main/vtxfmt_tmp.h
index 1308d0aa46..d56a2bb95e 100644
--- a/src/mesa/main/vtxfmt_tmp.h
+++ b/src/mesa/main/vtxfmt_tmp.h
@@ -354,6 +354,44 @@ static void GLAPIENTRY TAG(DrawRangeElements)( GLenum mode, GLuint start,
    CALL_DrawRangeElements(GET_DISPATCH(), ( mode, start, end, count, type, indices ));
 }
 
+static void GLAPIENTRY TAG(DrawElementsBaseVertex)( GLenum mode,
+						    GLsizei count,
+						    GLenum type,
+						    const GLvoid *indices,
+						    GLint basevertex)
+{
+   PRE_LOOPBACK( DrawElementsBaseVertex );
+   CALL_DrawElementsBaseVertex(GET_DISPATCH(), ( mode, count, type,
+						 indices, basevertex ));
+}
+
+static void GLAPIENTRY TAG(DrawRangeElementsBaseVertex)( GLenum mode,
+							 GLuint start,
+							 GLuint end,
+							 GLsizei count,
+							 GLenum type,
+							 const GLvoid *indices,
+							 GLint basevertex)
+{
+   PRE_LOOPBACK( DrawRangeElementsBaseVertex );
+   CALL_DrawRangeElementsBaseVertex(GET_DISPATCH(), ( mode, start, end,
+						      count, type, indices,
+						      basevertex ));
+}
+
+static void GLAPIENTRY TAG(MultiDrawElementsBaseVertex)( GLenum mode,
+							 const GLsizei *count,
+							 GLenum type,
+							 const GLvoid **indices,
+							 GLsizei primcount,
+							 const GLint *basevertex)
+{
+   PRE_LOOPBACK( MultiDrawElementsBaseVertex );
+   CALL_MultiDrawElementsBaseVertex(GET_DISPATCH(), ( mode, count, type,
+						      indices,
+						      primcount, basevertex ));
+}
+
 static void GLAPIENTRY TAG(EvalMesh1)( GLenum mode, GLint i1, GLint i2 )
 {
    PRE_LOOPBACK( EvalMesh1 );
@@ -534,6 +572,9 @@ static GLvertexformat TAG(vtxfmt) = {
    TAG(DrawElements),
    TAG(DrawRangeElements),
    TAG(MultiDrawElementsEXT),
+   TAG(DrawElementsBaseVertex),
+   TAG(DrawRangeElementsBaseVertex),
+   TAG(MultiDrawElementsBaseVertex),
    TAG(EvalMesh1),
    TAG(EvalMesh2)
 };
diff --git a/src/mesa/math/m_clip_tmp.h b/src/mesa/math/m_clip_tmp.h
index f3a589be05..2e30964057 100644
--- a/src/mesa/math/m_clip_tmp.h
+++ b/src/mesa/math/m_clip_tmp.h
@@ -44,7 +44,8 @@ static GLvector4f * _XFORMAPI TAG(cliptest_points4)( GLvector4f *clip_vec,
                                                      GLvector4f *proj_vec,
                                                      GLubyte clipMask[],
                                                      GLubyte *orMask,
-                                                     GLubyte *andMask )
+                                                     GLubyte *andMask,
+						     GLboolean viewport_z_clip )
 {
    const GLuint stride = clip_vec->stride;
    const GLfloat *from = (GLfloat *)clip_vec->start;
@@ -66,16 +67,20 @@ static GLvector4f * _XFORMAPI TAG(cliptest_points4)( GLvector4f *clip_vec,
       mask |= (((cw < -cx) << CLIP_LEFT_SHIFT));
       mask |= (((cw < cy) << CLIP_TOP_SHIFT));
       mask |= (((cw < -cy) << CLIP_BOTTOM_SHIFT));
-      mask |= (((cw < cz) << CLIP_FAR_SHIFT));
-      mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+      if (viewport_z_clip) {
+	 mask |= (((cw < cz) << CLIP_FAR_SHIFT));
+	 mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+      }
 #else /* !defined(macintosh)) */
       GLubyte mask = 0;
       if (-cx + cw < 0) mask |= CLIP_RIGHT_BIT;
       if ( cx + cw < 0) mask |= CLIP_LEFT_BIT;
       if (-cy + cw < 0) mask |= CLIP_TOP_BIT;
       if ( cy + cw < 0) mask |= CLIP_BOTTOM_BIT;
-      if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
-      if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+      if (viewport_z_clip) {
+	 if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
+	 if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+      }
 #endif /* defined(macintosh) */
 
       clipMask[i] = mask;
@@ -119,7 +124,8 @@ static GLvector4f * _XFORMAPI TAG(cliptest_np_points4)( GLvector4f *clip_vec,
 							GLvector4f *proj_vec,
 							GLubyte clipMask[],
 							GLubyte *orMask,
-							GLubyte *andMask )
+							GLubyte *andMask,
+							GLboolean viewport_z_clip )
 {
    const GLuint stride = clip_vec->stride;
    const GLuint count = clip_vec->count;
@@ -141,16 +147,20 @@ static GLvector4f * _XFORMAPI TAG(cliptest_np_points4)( GLvector4f *clip_vec,
       mask |= (((cw < -cx) << CLIP_LEFT_SHIFT));
       mask |= (((cw < cy) << CLIP_TOP_SHIFT));
       mask |= (((cw < -cy) << CLIP_BOTTOM_SHIFT));
-      mask |= (((cw < cz) << CLIP_FAR_SHIFT));
-      mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+      if (viewport_z_clip) {
+	 mask |= (((cw < cz) << CLIP_FAR_SHIFT));
+	 mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+      }
 #else /* !defined(macintosh)) */
       GLubyte mask = 0;
       if (-cx + cw < 0) mask |= CLIP_RIGHT_BIT;
       if ( cx + cw < 0) mask |= CLIP_LEFT_BIT;
       if (-cy + cw < 0) mask |= CLIP_TOP_BIT;
       if ( cy + cw < 0) mask |= CLIP_BOTTOM_BIT;
-      if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
-      if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+      if (viewport_z_clip) {
+	 if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
+	 if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+      }
 #endif /* defined(macintosh) */
 
       clipMask[i] = mask;
@@ -171,7 +181,8 @@ static GLvector4f * _XFORMAPI TAG(cliptest_points3)( GLvector4f *clip_vec,
                                                      GLvector4f *proj_vec,
                                                      GLubyte clipMask[],
                                                      GLubyte *orMask,
-                                                     GLubyte *andMask )
+                                                     GLubyte *andMask,
+						     GLboolean viewport_z_clip )
 {
    const GLuint stride = clip_vec->stride;
    const GLuint count = clip_vec->count;
@@ -187,8 +198,10 @@ static GLvector4f * _XFORMAPI TAG(cliptest_points3)( GLvector4f *clip_vec,
       else if (cx < -1.0)  mask |= CLIP_LEFT_BIT;
       if (cy >  1.0)       mask |= CLIP_TOP_BIT;
       else if (cy < -1.0)  mask |= CLIP_BOTTOM_BIT;
-      if (cz >  1.0)       mask |= CLIP_FAR_BIT;
-      else if (cz < -1.0)  mask |= CLIP_NEAR_BIT;
+      if (viewport_z_clip) {
+	 if (cz >  1.0)       mask |= CLIP_FAR_BIT;
+	 else if (cz < -1.0)  mask |= CLIP_NEAR_BIT;
+      }
       clipMask[i] = mask;
       tmpOrMask |= mask;
       tmpAndMask &= mask;
@@ -204,7 +217,8 @@ static GLvector4f * _XFORMAPI TAG(cliptest_points2)( GLvector4f *clip_vec,
                                                      GLvector4f *proj_vec,
                                                      GLubyte clipMask[],
                                                      GLubyte *orMask,
-                                                     GLubyte *andMask )
+                                                     GLubyte *andMask,
+						     GLboolean viewport_z_clip )
 {
    const GLuint stride = clip_vec->stride;
    const GLuint count = clip_vec->count;
@@ -231,7 +245,7 @@ static GLvector4f * _XFORMAPI TAG(cliptest_points2)( GLvector4f *clip_vec,
 }
 
 
-static void TAG(init_c_cliptest)( void )
+void TAG(init_c_cliptest)( void )
 {
    _mesa_clip_tab[4] = TAG(cliptest_points4);
    _mesa_clip_tab[3] = TAG(cliptest_points3);
diff --git a/src/mesa/math/m_debug_clip.c b/src/mesa/math/m_debug_clip.c
index 460fed4a75..95ae5a347d 100644
--- a/src/mesa/math/m_debug_clip.c
+++ b/src/mesa/math/m_debug_clip.c
@@ -67,7 +67,8 @@ static GLvector4f *ref_cliptest_points4( GLvector4f *clip_vec,
 					 GLvector4f *proj_vec,
 					 GLubyte clipMask[],
 					 GLubyte *orMask,
-					 GLubyte *andMask )
+					 GLubyte *andMask,
+					 GLboolean viewport_z_clip )
 {
    const GLuint stride = clip_vec->stride;
    const GLuint count = clip_vec->count;
@@ -87,8 +88,10 @@ static GLvector4f *ref_cliptest_points4( GLvector4f *clip_vec,
       if (  cx + cw < 0 ) mask |= CLIP_LEFT_BIT;
       if ( -cy + cw < 0 ) mask |= CLIP_TOP_BIT;
       if (  cy + cw < 0 ) mask |= CLIP_BOTTOM_BIT;
-      if ( -cz + cw < 0 ) mask |= CLIP_FAR_BIT;
-      if (  cz + cw < 0 ) mask |= CLIP_NEAR_BIT;
+      if (viewport_z_clip) {
+	 if ( -cz + cw < 0 ) mask |= CLIP_FAR_BIT;
+	 if (  cz + cw < 0 ) mask |= CLIP_NEAR_BIT;
+      }
       clipMask[i] = mask;
       if ( mask ) {
 	 c++;
@@ -122,7 +125,8 @@ static GLvector4f *ref_cliptest_points3( GLvector4f *clip_vec,
 					 GLvector4f *proj_vec,
 					 GLubyte clipMask[],
 					 GLubyte *orMask,
-					 GLubyte *andMask )
+					 GLubyte *andMask,
+                                         GLboolean viewport_z_clip )
 {
    const GLuint stride = clip_vec->stride;
    const GLuint count = clip_vec->count;
@@ -138,8 +142,10 @@ static GLvector4f *ref_cliptest_points3( GLvector4f *clip_vec,
       else if ( cx < -1.0 )	mask |= CLIP_LEFT_BIT;
       if ( cy >  1.0 )		mask |= CLIP_TOP_BIT;
       else if ( cy < -1.0 )	mask |= CLIP_BOTTOM_BIT;
-      if ( cz >  1.0 )		mask |= CLIP_FAR_BIT;
-      else if ( cz < -1.0 )	mask |= CLIP_NEAR_BIT;
+      if (viewport_z_clip) {
+         if ( cz >  1.0 )		mask |= CLIP_FAR_BIT;
+         else if ( cz < -1.0 )	mask |= CLIP_NEAR_BIT;
+      }
       clipMask[i] = mask;
       tmpOrMask |= mask;
       tmpAndMask &= mask;
@@ -154,7 +160,8 @@ static GLvector4f * ref_cliptest_points2( GLvector4f *clip_vec,
 					  GLvector4f *proj_vec,
 					  GLubyte clipMask[],
 					  GLubyte *orMask,
-					  GLubyte *andMask )
+					  GLubyte *andMask,
+                                          GLboolean viewport_z_clip )
 {
    const GLuint stride = clip_vec->stride;
    const GLuint count = clip_vec->count;
@@ -163,6 +170,9 @@ static GLvector4f * ref_cliptest_points2( GLvector4f *clip_vec,
    GLubyte tmpOrMask = *orMask;
    GLubyte tmpAndMask = *andMask;
    GLuint i;
+
+   (void) viewport_z_clip;
+
    for ( i = 0 ; i < count ; i++, STRIDE_F(from, stride) ) {
       const GLfloat cx = from[0], cy = from[1];
       GLubyte mask = 0;
@@ -208,6 +218,7 @@ static int test_cliptest_function( clip_func func, int np,
 #ifdef  RUN_DEBUG_BENCHMARK
    int cycle_i;                /* the counter for the benchmarks we run */
 #endif
+   GLboolean viewport_z_clip = GL_TRUE;
 
    (void) cycles;
 
@@ -247,15 +258,15 @@ static int test_cliptest_function( clip_func func, int np,
    dco = rco = 0;
    dca = rca = CLIP_FRUSTUM_BITS;
 
-   ref_cliptest[psize]( source, ref, rm, &rco, &rca );
+   ref_cliptest[psize]( source, ref, rm, &rco, &rca, viewport_z_clip );
 
    if ( mesa_profile ) {
       BEGIN_RACE( *cycles );
-      func( source, dest, dm, &dco, &dca );
+      func( source, dest, dm, &dco, &dca, viewport_z_clip );
       END_RACE( *cycles );
    }
    else {
-      func( source, dest, dm, &dco, &dca );
+      func( source, dest, dm, &dco, &dca, viewport_z_clip );
    }
 
    if ( dco != rco ) {
diff --git a/src/mesa/math/m_xform.h b/src/mesa/math/m_xform.h
index 7ef76e0b92..33421ad1c0 100644
--- a/src/mesa/math/m_xform.h
+++ b/src/mesa/math/m_xform.h
@@ -43,7 +43,8 @@
 
 extern void
 _math_init_transformation(void);
-
+extern void
+init_c_cliptest(void);
 
 /* KW: Clip functions now do projective divide as well.  The projected
  * coordinates are very useful to us because they let us cull
@@ -102,7 +103,8 @@ typedef GLvector4f * (_XFORMAPIP clip_func)( GLvector4f *vClip,
 					     GLvector4f *vProj,
 					     GLubyte clipMask[],
 					     GLubyte *orMask,
-					     GLubyte *andMask );
+					     GLubyte *andMask,
+					     GLboolean viewport_z_clip );
 
 typedef void (*dotprod_func)( GLfloat *out,
 			      GLuint out_stride,
diff --git a/src/mesa/shader/lex.yy.c b/src/mesa/shader/lex.yy.c
index 709426f3a6..283ba8d26e 100644
--- a/src/mesa/shader/lex.yy.c
+++ b/src/mesa/shader/lex.yy.c
@@ -912,6 +912,10 @@ static yyconst flex_int16_t yy_chk[1023] =
 #define require_rect   (yyextra->option.TexRect)
 #define require_texarray        (yyextra->option.TexArray)
 
+#ifndef HAVE_UNISTD_H
+#define YY_NO_UNISTD_H
+#endif
+
 #define return_token_or_IDENTIFIER(condition, token)	\
    do {							\
       if (condition) {					\
diff --git a/src/mesa/shader/prog_instruction.h b/src/mesa/shader/prog_instruction.h
index 39a221eeab..1c687bc16c 100644
--- a/src/mesa/shader/prog_instruction.h
+++ b/src/mesa/shader/prog_instruction.h
@@ -121,7 +121,6 @@
 /*@{*/
 #define SATURATE_OFF            0
 #define SATURATE_ZERO_ONE       1
-#define SATURATE_PLUS_MINUS_ONE 2
 /*@}*/
 
 
diff --git a/src/mesa/shader/program.c b/src/mesa/shader/program.c
index 963478fccd..2cd6eb8a38 100644
--- a/src/mesa/shader/program.c
+++ b/src/mesa/shader/program.c
@@ -502,6 +502,7 @@ _mesa_clone_program(GLcontext *ctx, const struct gl_program *prog)
             = (const struct gl_vertex_program *) prog;
          struct gl_vertex_program *vpc = (struct gl_vertex_program *) clone;
          vpc->IsPositionInvariant = vp->IsPositionInvariant;
+         vpc->IsNVProgram = vp->IsNVProgram;
       }
       break;
    case GL_FRAGMENT_PROGRAM_ARB:
diff --git a/src/mesa/shader/program_lexer.l b/src/mesa/shader/program_lexer.l
index d240217481..612f99a42d 100644
--- a/src/mesa/shader/program_lexer.l
+++ b/src/mesa/shader/program_lexer.l
@@ -34,6 +34,10 @@
 #define require_rect   (yyextra->option.TexRect)
 #define require_texarray        (yyextra->option.TexArray)
 
+#ifndef HAVE_UNISTD_H
+#define YY_NO_UNISTD_H
+#endif
+
 #define return_token_or_IDENTIFIER(condition, token)	\
    do {							\
       if (condition) {					\
diff --git a/src/mesa/shader/program_parse.tab.c b/src/mesa/shader/program_parse.tab.c
index 9f2d4de90f..2de950b73b 100644
--- a/src/mesa/shader/program_parse.tab.c
+++ b/src/mesa/shader/program_parse.tab.c
@@ -769,27 +769,27 @@ static const yytype_uint16 yyrline[] =
      440,   447,   453,   454,   455,   456,   457,   458,   459,   460,
      461,   462,   463,   464,   467,   480,   493,   506,   528,   537,
      570,   577,   592,   642,   684,   695,   716,   726,   732,   763,
-     780,   780,   782,   789,   801,   802,   803,   806,   818,   830,
-     848,   859,   871,   873,   874,   875,   876,   879,   879,   879,
-     879,   880,   883,   884,   885,   886,   887,   888,   891,   909,
-     913,   919,   923,   927,   931,   940,   949,   953,   958,   964,
-     975,   975,   976,   978,   982,   986,   990,   996,   996,   998,
-    1014,  1037,  1040,  1051,  1057,  1063,  1064,  1071,  1077,  1083,
-    1091,  1097,  1103,  1111,  1117,  1123,  1131,  1132,  1135,  1136,
-    1137,  1138,  1139,  1140,  1141,  1142,  1143,  1144,  1145,  1148,
-    1157,  1161,  1165,  1171,  1180,  1184,  1188,  1197,  1201,  1207,
-    1213,  1220,  1225,  1233,  1243,  1245,  1253,  1259,  1263,  1267,
-    1273,  1284,  1293,  1297,  1302,  1306,  1310,  1314,  1320,  1327,
-    1331,  1337,  1345,  1356,  1363,  1367,  1373,  1383,  1394,  1398,
-    1416,  1425,  1428,  1434,  1438,  1442,  1448,  1459,  1464,  1469,
-    1474,  1479,  1484,  1492,  1495,  1500,  1513,  1521,  1532,  1540,
-    1540,  1542,  1542,  1544,  1554,  1559,  1566,  1576,  1585,  1590,
-    1597,  1607,  1617,  1629,  1629,  1630,  1630,  1632,  1642,  1650,
-    1660,  1668,  1676,  1685,  1696,  1700,  1706,  1707,  1708,  1711,
-    1711,  1714,  1714,  1717,  1723,  1731,  1744,  1753,  1762,  1766,
-    1775,  1784,  1795,  1802,  1807,  1816,  1828,  1831,  1840,  1851,
-    1852,  1853,  1856,  1857,  1858,  1861,  1862,  1865,  1866,  1869,
-    1870,  1873,  1884,  1895,  1906
+     780,   780,   782,   789,   801,   802,   803,   806,   820,   834,
+     852,   863,   875,   877,   878,   879,   880,   883,   883,   883,
+     883,   884,   887,   888,   889,   890,   891,   892,   895,   913,
+     917,   923,   927,   931,   935,   944,   953,   957,   962,   968,
+     979,   979,   980,   982,   986,   990,   994,  1000,  1000,  1002,
+    1018,  1041,  1044,  1055,  1061,  1067,  1068,  1075,  1081,  1087,
+    1095,  1101,  1107,  1115,  1121,  1127,  1135,  1136,  1139,  1140,
+    1141,  1142,  1143,  1144,  1145,  1146,  1147,  1148,  1149,  1152,
+    1161,  1165,  1169,  1175,  1184,  1188,  1192,  1201,  1205,  1211,
+    1217,  1224,  1229,  1237,  1247,  1249,  1257,  1263,  1267,  1271,
+    1277,  1288,  1297,  1301,  1306,  1310,  1314,  1318,  1324,  1331,
+    1335,  1341,  1349,  1360,  1367,  1371,  1377,  1387,  1398,  1402,
+    1420,  1429,  1432,  1438,  1442,  1446,  1452,  1463,  1468,  1473,
+    1478,  1483,  1488,  1496,  1499,  1504,  1517,  1525,  1536,  1544,
+    1544,  1546,  1546,  1548,  1558,  1563,  1570,  1580,  1589,  1594,
+    1601,  1611,  1621,  1633,  1633,  1634,  1634,  1636,  1646,  1654,
+    1664,  1672,  1680,  1689,  1700,  1704,  1710,  1711,  1712,  1715,
+    1715,  1718,  1718,  1721,  1727,  1735,  1748,  1757,  1766,  1770,
+    1779,  1788,  1799,  1806,  1811,  1820,  1832,  1835,  1844,  1855,
+    1856,  1857,  1860,  1861,  1862,  1865,  1866,  1869,  1870,  1873,
+    1874,  1877,  1888,  1899,  1910
 };
 #endif
 
@@ -2791,8 +2791,10 @@ yyreduce:
 #line 807 "program_parse.y"
     {
 	   if (((yyvsp[(1) - (1)].integer) < 0) || ((yyvsp[(1) - (1)].integer) > 63)) {
-	      yyerror(& (yylsp[(1) - (1)]), state,
-		      "relative address offset too large (positive)");
+              char s[100];
+              _mesa_snprintf(s, sizeof(s),
+                             "relative address offset too large (%d)", (yyvsp[(1) - (1)].integer));
+	      yyerror(& (yylsp[(1) - (1)]), state, s);
 	      YYERROR;
 	   } else {
 	      (yyval.integer) = (yyvsp[(1) - (1)].integer);
@@ -2803,11 +2805,13 @@ yyreduce:
   case 68:
 
 /* Line 1455 of yacc.c  */
-#line 819 "program_parse.y"
+#line 821 "program_parse.y"
     {
 	   if (((yyvsp[(1) - (1)].integer) < 0) || ((yyvsp[(1) - (1)].integer) > 64)) {
-	      yyerror(& (yylsp[(1) - (1)]), state,
-		      "relative address offset too large (negative)");
+              char s[100];
+              _mesa_snprintf(s, sizeof(s),
+                             "relative address offset too large (%d)", (yyvsp[(1) - (1)].integer));
+	      yyerror(& (yylsp[(1) - (1)]), state, s);
 	      YYERROR;
 	   } else {
 	      (yyval.integer) = (yyvsp[(1) - (1)].integer);
@@ -2818,7 +2822,7 @@ yyreduce:
   case 69:
 
 /* Line 1455 of yacc.c  */
-#line 831 "program_parse.y"
+#line 835 "program_parse.y"
     {
 	   struct asm_symbol *const s = (struct asm_symbol *)
 	      _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(1) - (1)].string));
@@ -2839,7 +2843,7 @@ yyreduce:
   case 70:
 
 /* Line 1455 of yacc.c  */
-#line 849 "program_parse.y"
+#line 853 "program_parse.y"
     {
 	   if ((yyvsp[(1) - (1)].swiz_mask).mask != WRITEMASK_X) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid address component selector");
@@ -2853,7 +2857,7 @@ yyreduce:
   case 71:
 
 /* Line 1455 of yacc.c  */
-#line 860 "program_parse.y"
+#line 864 "program_parse.y"
     {
 	   if ((yyvsp[(1) - (1)].swiz_mask).mask != WRITEMASK_X) {
 	      yyerror(& (yylsp[(1) - (1)]), state,
@@ -2868,21 +2872,21 @@ yyreduce:
   case 76:
 
 /* Line 1455 of yacc.c  */
-#line 876 "program_parse.y"
+#line 880 "program_parse.y"
     { (yyval.swiz_mask).swizzle = SWIZZLE_NOOP; (yyval.swiz_mask).mask = WRITEMASK_XYZW; ;}
     break;
 
   case 81:
 
 /* Line 1455 of yacc.c  */
-#line 880 "program_parse.y"
+#line 884 "program_parse.y"
     { (yyval.swiz_mask).swizzle = SWIZZLE_NOOP; (yyval.swiz_mask).mask = WRITEMASK_XYZW; ;}
     break;
 
   case 88:
 
 /* Line 1455 of yacc.c  */
-#line 892 "program_parse.y"
+#line 896 "program_parse.y"
     {
 	   struct asm_symbol *const s =
 	      declare_variable(state, (yyvsp[(2) - (4)].string), at_attrib, & (yylsp[(2) - (4)]));
@@ -2903,7 +2907,7 @@ yyreduce:
   case 89:
 
 /* Line 1455 of yacc.c  */
-#line 910 "program_parse.y"
+#line 914 "program_parse.y"
     {
 	   (yyval.attrib) = (yyvsp[(2) - (2)].attrib);
 	;}
@@ -2912,7 +2916,7 @@ yyreduce:
   case 90:
 
 /* Line 1455 of yacc.c  */
-#line 914 "program_parse.y"
+#line 918 "program_parse.y"
     {
 	   (yyval.attrib) = (yyvsp[(2) - (2)].attrib);
 	;}
@@ -2921,7 +2925,7 @@ yyreduce:
   case 91:
 
 /* Line 1455 of yacc.c  */
-#line 920 "program_parse.y"
+#line 924 "program_parse.y"
     {
 	   (yyval.attrib) = VERT_ATTRIB_POS;
 	;}
@@ -2930,7 +2934,7 @@ yyreduce:
   case 92:
 
 /* Line 1455 of yacc.c  */
-#line 924 "program_parse.y"
+#line 928 "program_parse.y"
     {
 	   (yyval.attrib) = VERT_ATTRIB_WEIGHT;
 	;}
@@ -2939,7 +2943,7 @@ yyreduce:
   case 93:
 
 /* Line 1455 of yacc.c  */
-#line 928 "program_parse.y"
+#line 932 "program_parse.y"
     {
 	   (yyval.attrib) = VERT_ATTRIB_NORMAL;
 	;}
@@ -2948,7 +2952,7 @@ yyreduce:
   case 94:
 
 /* Line 1455 of yacc.c  */
-#line 932 "program_parse.y"
+#line 936 "program_parse.y"
     {
 	   if (!state->ctx->Extensions.EXT_secondary_color) {
 	      yyerror(& (yylsp[(2) - (2)]), state, "GL_EXT_secondary_color not supported");
@@ -2962,7 +2966,7 @@ yyreduce:
   case 95:
 
 /* Line 1455 of yacc.c  */
-#line 941 "program_parse.y"
+#line 945 "program_parse.y"
     {
 	   if (!state->ctx->Extensions.EXT_fog_coord) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "GL_EXT_fog_coord not supported");
@@ -2976,7 +2980,7 @@ yyreduce:
   case 96:
 
 /* Line 1455 of yacc.c  */
-#line 950 "program_parse.y"
+#line 954 "program_parse.y"
     {
 	   (yyval.attrib) = VERT_ATTRIB_TEX0 + (yyvsp[(2) - (2)].integer);
 	;}
@@ -2985,7 +2989,7 @@ yyreduce:
   case 97:
 
 /* Line 1455 of yacc.c  */
-#line 954 "program_parse.y"
+#line 958 "program_parse.y"
     {
 	   yyerror(& (yylsp[(1) - (4)]), state, "GL_ARB_matrix_palette not supported");
 	   YYERROR;
@@ -2995,7 +2999,7 @@ yyreduce:
   case 98:
 
 /* Line 1455 of yacc.c  */
-#line 959 "program_parse.y"
+#line 963 "program_parse.y"
     {
 	   (yyval.attrib) = VERT_ATTRIB_GENERIC0 + (yyvsp[(3) - (4)].integer);
 	;}
@@ -3004,7 +3008,7 @@ yyreduce:
   case 99:
 
 /* Line 1455 of yacc.c  */
-#line 965 "program_parse.y"
+#line 969 "program_parse.y"
     {
 	   if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxAttribs) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid vertex attribute reference");
@@ -3018,7 +3022,7 @@ yyreduce:
   case 103:
 
 /* Line 1455 of yacc.c  */
-#line 979 "program_parse.y"
+#line 983 "program_parse.y"
     {
 	   (yyval.attrib) = FRAG_ATTRIB_WPOS;
 	;}
@@ -3027,7 +3031,7 @@ yyreduce:
   case 104:
 
 /* Line 1455 of yacc.c  */
-#line 983 "program_parse.y"
+#line 987 "program_parse.y"
     {
 	   (yyval.attrib) = FRAG_ATTRIB_COL0 + (yyvsp[(2) - (2)].integer);
 	;}
@@ -3036,7 +3040,7 @@ yyreduce:
   case 105:
 
 /* Line 1455 of yacc.c  */
-#line 987 "program_parse.y"
+#line 991 "program_parse.y"
     {
 	   (yyval.attrib) = FRAG_ATTRIB_FOGC;
 	;}
@@ -3045,7 +3049,7 @@ yyreduce:
   case 106:
 
 /* Line 1455 of yacc.c  */
-#line 991 "program_parse.y"
+#line 995 "program_parse.y"
     {
 	   (yyval.attrib) = FRAG_ATTRIB_TEX0 + (yyvsp[(2) - (2)].integer);
 	;}
@@ -3054,7 +3058,7 @@ yyreduce:
   case 109:
 
 /* Line 1455 of yacc.c  */
-#line 999 "program_parse.y"
+#line 1003 "program_parse.y"
     {
 	   struct asm_symbol *const s =
 	      declare_variable(state, (yyvsp[(2) - (3)].string), at_param, & (yylsp[(2) - (3)]));
@@ -3073,7 +3077,7 @@ yyreduce:
   case 110:
 
 /* Line 1455 of yacc.c  */
-#line 1015 "program_parse.y"
+#line 1019 "program_parse.y"
     {
 	   if (((yyvsp[(4) - (6)].integer) != 0) && ((unsigned) (yyvsp[(4) - (6)].integer) != (yyvsp[(6) - (6)].temp_sym).param_binding_length)) {
 	      yyerror(& (yylsp[(4) - (6)]), state, 
@@ -3098,7 +3102,7 @@ yyreduce:
   case 111:
 
 /* Line 1455 of yacc.c  */
-#line 1037 "program_parse.y"
+#line 1041 "program_parse.y"
     {
 	   (yyval.integer) = 0;
 	;}
@@ -3107,7 +3111,7 @@ yyreduce:
   case 112:
 
 /* Line 1455 of yacc.c  */
-#line 1041 "program_parse.y"
+#line 1045 "program_parse.y"
     {
 	   if (((yyvsp[(1) - (1)].integer) < 1) || ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxParameters)) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid parameter array size");
@@ -3121,7 +3125,7 @@ yyreduce:
   case 113:
 
 /* Line 1455 of yacc.c  */
-#line 1052 "program_parse.y"
+#line 1056 "program_parse.y"
     {
 	   (yyval.temp_sym) = (yyvsp[(2) - (2)].temp_sym);
 	;}
@@ -3130,7 +3134,7 @@ yyreduce:
   case 114:
 
 /* Line 1455 of yacc.c  */
-#line 1058 "program_parse.y"
+#line 1062 "program_parse.y"
     {
 	   (yyval.temp_sym) = (yyvsp[(3) - (4)].temp_sym);
 	;}
@@ -3139,7 +3143,7 @@ yyreduce:
   case 116:
 
 /* Line 1455 of yacc.c  */
-#line 1065 "program_parse.y"
+#line 1069 "program_parse.y"
     {
 	   (yyvsp[(1) - (3)].temp_sym).param_binding_length += (yyvsp[(3) - (3)].temp_sym).param_binding_length;
 	   (yyval.temp_sym) = (yyvsp[(1) - (3)].temp_sym);
@@ -3149,7 +3153,7 @@ yyreduce:
   case 117:
 
 /* Line 1455 of yacc.c  */
-#line 1072 "program_parse.y"
+#line 1076 "program_parse.y"
     {
 	   memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
 	   (yyval.temp_sym).param_binding_begin = ~0;
@@ -3160,7 +3164,7 @@ yyreduce:
   case 118:
 
 /* Line 1455 of yacc.c  */
-#line 1078 "program_parse.y"
+#line 1082 "program_parse.y"
     {
 	   memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
 	   (yyval.temp_sym).param_binding_begin = ~0;
@@ -3171,7 +3175,7 @@ yyreduce:
   case 119:
 
 /* Line 1455 of yacc.c  */
-#line 1084 "program_parse.y"
+#line 1088 "program_parse.y"
     {
 	   memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
 	   (yyval.temp_sym).param_binding_begin = ~0;
@@ -3182,7 +3186,7 @@ yyreduce:
   case 120:
 
 /* Line 1455 of yacc.c  */
-#line 1092 "program_parse.y"
+#line 1096 "program_parse.y"
     {
 	   memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
 	   (yyval.temp_sym).param_binding_begin = ~0;
@@ -3193,7 +3197,7 @@ yyreduce:
   case 121:
 
 /* Line 1455 of yacc.c  */
-#line 1098 "program_parse.y"
+#line 1102 "program_parse.y"
     {
 	   memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
 	   (yyval.temp_sym).param_binding_begin = ~0;
@@ -3204,7 +3208,7 @@ yyreduce:
   case 122:
 
 /* Line 1455 of yacc.c  */
-#line 1104 "program_parse.y"
+#line 1108 "program_parse.y"
     {
 	   memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
 	   (yyval.temp_sym).param_binding_begin = ~0;
@@ -3215,7 +3219,7 @@ yyreduce:
   case 123:
 
 /* Line 1455 of yacc.c  */
-#line 1112 "program_parse.y"
+#line 1116 "program_parse.y"
     {
 	   memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
 	   (yyval.temp_sym).param_binding_begin = ~0;
@@ -3226,7 +3230,7 @@ yyreduce:
   case 124:
 
 /* Line 1455 of yacc.c  */
-#line 1118 "program_parse.y"
+#line 1122 "program_parse.y"
     {
 	   memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
 	   (yyval.temp_sym).param_binding_begin = ~0;
@@ -3237,7 +3241,7 @@ yyreduce:
   case 125:
 
 /* Line 1455 of yacc.c  */
-#line 1124 "program_parse.y"
+#line 1128 "program_parse.y"
     {
 	   memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym)));
 	   (yyval.temp_sym).param_binding_begin = ~0;
@@ -3248,98 +3252,98 @@ yyreduce:
   case 126:
 
 /* Line 1455 of yacc.c  */
-#line 1131 "program_parse.y"
+#line 1135 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(1) - (1)].state), sizeof((yyval.state))); ;}
     break;
 
   case 127:
 
 /* Line 1455 of yacc.c  */
-#line 1132 "program_parse.y"
+#line 1136 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 128:
 
 /* Line 1455 of yacc.c  */
-#line 1135 "program_parse.y"
+#line 1139 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 129:
 
 /* Line 1455 of yacc.c  */
-#line 1136 "program_parse.y"
+#line 1140 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 130:
 
 /* Line 1455 of yacc.c  */
-#line 1137 "program_parse.y"
+#line 1141 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 131:
 
 /* Line 1455 of yacc.c  */
-#line 1138 "program_parse.y"
+#line 1142 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 132:
 
 /* Line 1455 of yacc.c  */
-#line 1139 "program_parse.y"
+#line 1143 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 133:
 
 /* Line 1455 of yacc.c  */
-#line 1140 "program_parse.y"
+#line 1144 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 134:
 
 /* Line 1455 of yacc.c  */
-#line 1141 "program_parse.y"
+#line 1145 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 135:
 
 /* Line 1455 of yacc.c  */
-#line 1142 "program_parse.y"
+#line 1146 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 136:
 
 /* Line 1455 of yacc.c  */
-#line 1143 "program_parse.y"
+#line 1147 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 137:
 
 /* Line 1455 of yacc.c  */
-#line 1144 "program_parse.y"
+#line 1148 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 138:
 
 /* Line 1455 of yacc.c  */
-#line 1145 "program_parse.y"
+#line 1149 "program_parse.y"
     { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); ;}
     break;
 
   case 139:
 
 /* Line 1455 of yacc.c  */
-#line 1149 "program_parse.y"
+#line 1153 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = STATE_MATERIAL;
@@ -3351,7 +3355,7 @@ yyreduce:
   case 140:
 
 /* Line 1455 of yacc.c  */
-#line 1158 "program_parse.y"
+#line 1162 "program_parse.y"
     {
 	   (yyval.integer) = (yyvsp[(1) - (1)].integer);
 	;}
@@ -3360,7 +3364,7 @@ yyreduce:
   case 141:
 
 /* Line 1455 of yacc.c  */
-#line 1162 "program_parse.y"
+#line 1166 "program_parse.y"
     {
 	   (yyval.integer) = STATE_EMISSION;
 	;}
@@ -3369,7 +3373,7 @@ yyreduce:
   case 142:
 
 /* Line 1455 of yacc.c  */
-#line 1166 "program_parse.y"
+#line 1170 "program_parse.y"
     {
 	   (yyval.integer) = STATE_SHININESS;
 	;}
@@ -3378,7 +3382,7 @@ yyreduce:
   case 143:
 
 /* Line 1455 of yacc.c  */
-#line 1172 "program_parse.y"
+#line 1176 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = STATE_LIGHT;
@@ -3390,7 +3394,7 @@ yyreduce:
   case 144:
 
 /* Line 1455 of yacc.c  */
-#line 1181 "program_parse.y"
+#line 1185 "program_parse.y"
     {
 	   (yyval.integer) = (yyvsp[(1) - (1)].integer);
 	;}
@@ -3399,7 +3403,7 @@ yyreduce:
   case 145:
 
 /* Line 1455 of yacc.c  */
-#line 1185 "program_parse.y"
+#line 1189 "program_parse.y"
     {
 	   (yyval.integer) = STATE_POSITION;
 	;}
@@ -3408,7 +3412,7 @@ yyreduce:
   case 146:
 
 /* Line 1455 of yacc.c  */
-#line 1189 "program_parse.y"
+#line 1193 "program_parse.y"
     {
 	   if (!state->ctx->Extensions.EXT_point_parameters) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "GL_ARB_point_parameters not supported");
@@ -3422,7 +3426,7 @@ yyreduce:
   case 147:
 
 /* Line 1455 of yacc.c  */
-#line 1198 "program_parse.y"
+#line 1202 "program_parse.y"
     {
 	   (yyval.integer) = (yyvsp[(2) - (2)].integer);
 	;}
@@ -3431,7 +3435,7 @@ yyreduce:
   case 148:
 
 /* Line 1455 of yacc.c  */
-#line 1202 "program_parse.y"
+#line 1206 "program_parse.y"
     {
 	   (yyval.integer) = STATE_HALF_VECTOR;
 	;}
@@ -3440,7 +3444,7 @@ yyreduce:
   case 149:
 
 /* Line 1455 of yacc.c  */
-#line 1208 "program_parse.y"
+#line 1212 "program_parse.y"
     {
 	   (yyval.integer) = STATE_SPOT_DIRECTION;
 	;}
@@ -3449,7 +3453,7 @@ yyreduce:
   case 150:
 
 /* Line 1455 of yacc.c  */
-#line 1214 "program_parse.y"
+#line 1218 "program_parse.y"
     {
 	   (yyval.state)[0] = (yyvsp[(2) - (2)].state)[0];
 	   (yyval.state)[1] = (yyvsp[(2) - (2)].state)[1];
@@ -3459,7 +3463,7 @@ yyreduce:
   case 151:
 
 /* Line 1455 of yacc.c  */
-#line 1221 "program_parse.y"
+#line 1225 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = STATE_LIGHTMODEL_AMBIENT;
@@ -3469,7 +3473,7 @@ yyreduce:
   case 152:
 
 /* Line 1455 of yacc.c  */
-#line 1226 "program_parse.y"
+#line 1230 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = STATE_LIGHTMODEL_SCENECOLOR;
@@ -3480,7 +3484,7 @@ yyreduce:
   case 153:
 
 /* Line 1455 of yacc.c  */
-#line 1234 "program_parse.y"
+#line 1238 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = STATE_LIGHTPROD;
@@ -3493,7 +3497,7 @@ yyreduce:
   case 155:
 
 /* Line 1455 of yacc.c  */
-#line 1246 "program_parse.y"
+#line 1250 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = (yyvsp[(3) - (3)].integer);
@@ -3504,7 +3508,7 @@ yyreduce:
   case 156:
 
 /* Line 1455 of yacc.c  */
-#line 1254 "program_parse.y"
+#line 1258 "program_parse.y"
     {
 	   (yyval.integer) = STATE_TEXENV_COLOR;
 	;}
@@ -3513,7 +3517,7 @@ yyreduce:
   case 157:
 
 /* Line 1455 of yacc.c  */
-#line 1260 "program_parse.y"
+#line 1264 "program_parse.y"
     {
 	   (yyval.integer) = STATE_AMBIENT;
 	;}
@@ -3522,7 +3526,7 @@ yyreduce:
   case 158:
 
 /* Line 1455 of yacc.c  */
-#line 1264 "program_parse.y"
+#line 1268 "program_parse.y"
     {
 	   (yyval.integer) = STATE_DIFFUSE;
 	;}
@@ -3531,7 +3535,7 @@ yyreduce:
   case 159:
 
 /* Line 1455 of yacc.c  */
-#line 1268 "program_parse.y"
+#line 1272 "program_parse.y"
     {
 	   (yyval.integer) = STATE_SPECULAR;
 	;}
@@ -3540,7 +3544,7 @@ yyreduce:
   case 160:
 
 /* Line 1455 of yacc.c  */
-#line 1274 "program_parse.y"
+#line 1278 "program_parse.y"
     {
 	   if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxLights) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid light selector");
@@ -3554,7 +3558,7 @@ yyreduce:
   case 161:
 
 /* Line 1455 of yacc.c  */
-#line 1285 "program_parse.y"
+#line 1289 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = STATE_TEXGEN;
@@ -3566,7 +3570,7 @@ yyreduce:
   case 162:
 
 /* Line 1455 of yacc.c  */
-#line 1294 "program_parse.y"
+#line 1298 "program_parse.y"
     {
 	   (yyval.integer) = STATE_TEXGEN_EYE_S;
 	;}
@@ -3575,7 +3579,7 @@ yyreduce:
   case 163:
 
 /* Line 1455 of yacc.c  */
-#line 1298 "program_parse.y"
+#line 1302 "program_parse.y"
     {
 	   (yyval.integer) = STATE_TEXGEN_OBJECT_S;
 	;}
@@ -3584,7 +3588,7 @@ yyreduce:
   case 164:
 
 /* Line 1455 of yacc.c  */
-#line 1303 "program_parse.y"
+#line 1307 "program_parse.y"
     {
 	   (yyval.integer) = STATE_TEXGEN_EYE_S - STATE_TEXGEN_EYE_S;
 	;}
@@ -3593,7 +3597,7 @@ yyreduce:
   case 165:
 
 /* Line 1455 of yacc.c  */
-#line 1307 "program_parse.y"
+#line 1311 "program_parse.y"
     {
 	   (yyval.integer) = STATE_TEXGEN_EYE_T - STATE_TEXGEN_EYE_S;
 	;}
@@ -3602,7 +3606,7 @@ yyreduce:
   case 166:
 
 /* Line 1455 of yacc.c  */
-#line 1311 "program_parse.y"
+#line 1315 "program_parse.y"
     {
 	   (yyval.integer) = STATE_TEXGEN_EYE_R - STATE_TEXGEN_EYE_S;
 	;}
@@ -3611,7 +3615,7 @@ yyreduce:
   case 167:
 
 /* Line 1455 of yacc.c  */
-#line 1315 "program_parse.y"
+#line 1319 "program_parse.y"
     {
 	   (yyval.integer) = STATE_TEXGEN_EYE_Q - STATE_TEXGEN_EYE_S;
 	;}
@@ -3620,7 +3624,7 @@ yyreduce:
   case 168:
 
 /* Line 1455 of yacc.c  */
-#line 1321 "program_parse.y"
+#line 1325 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = (yyvsp[(2) - (2)].integer);
@@ -3630,7 +3634,7 @@ yyreduce:
   case 169:
 
 /* Line 1455 of yacc.c  */
-#line 1328 "program_parse.y"
+#line 1332 "program_parse.y"
     {
 	   (yyval.integer) = STATE_FOG_COLOR;
 	;}
@@ -3639,7 +3643,7 @@ yyreduce:
   case 170:
 
 /* Line 1455 of yacc.c  */
-#line 1332 "program_parse.y"
+#line 1336 "program_parse.y"
     {
 	   (yyval.integer) = STATE_FOG_PARAMS;
 	;}
@@ -3648,7 +3652,7 @@ yyreduce:
   case 171:
 
 /* Line 1455 of yacc.c  */
-#line 1338 "program_parse.y"
+#line 1342 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = STATE_CLIPPLANE;
@@ -3659,7 +3663,7 @@ yyreduce:
   case 172:
 
 /* Line 1455 of yacc.c  */
-#line 1346 "program_parse.y"
+#line 1350 "program_parse.y"
     {
 	   if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxClipPlanes) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid clip plane selector");
@@ -3673,7 +3677,7 @@ yyreduce:
   case 173:
 
 /* Line 1455 of yacc.c  */
-#line 1357 "program_parse.y"
+#line 1361 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = (yyvsp[(2) - (2)].integer);
@@ -3683,7 +3687,7 @@ yyreduce:
   case 174:
 
 /* Line 1455 of yacc.c  */
-#line 1364 "program_parse.y"
+#line 1368 "program_parse.y"
     {
 	   (yyval.integer) = STATE_POINT_SIZE;
 	;}
@@ -3692,7 +3696,7 @@ yyreduce:
   case 175:
 
 /* Line 1455 of yacc.c  */
-#line 1368 "program_parse.y"
+#line 1372 "program_parse.y"
     {
 	   (yyval.integer) = STATE_POINT_ATTENUATION;
 	;}
@@ -3701,7 +3705,7 @@ yyreduce:
   case 176:
 
 /* Line 1455 of yacc.c  */
-#line 1374 "program_parse.y"
+#line 1378 "program_parse.y"
     {
 	   (yyval.state)[0] = (yyvsp[(1) - (5)].state)[0];
 	   (yyval.state)[1] = (yyvsp[(1) - (5)].state)[1];
@@ -3714,7 +3718,7 @@ yyreduce:
   case 177:
 
 /* Line 1455 of yacc.c  */
-#line 1384 "program_parse.y"
+#line 1388 "program_parse.y"
     {
 	   (yyval.state)[0] = (yyvsp[(1) - (2)].state)[0];
 	   (yyval.state)[1] = (yyvsp[(1) - (2)].state)[1];
@@ -3727,7 +3731,7 @@ yyreduce:
   case 178:
 
 /* Line 1455 of yacc.c  */
-#line 1394 "program_parse.y"
+#line 1398 "program_parse.y"
     {
 	   (yyval.state)[2] = 0;
 	   (yyval.state)[3] = 3;
@@ -3737,7 +3741,7 @@ yyreduce:
   case 179:
 
 /* Line 1455 of yacc.c  */
-#line 1399 "program_parse.y"
+#line 1403 "program_parse.y"
     {
 	   /* It seems logical that the matrix row range specifier would have
 	    * to specify a range or more than one row (i.e., $5 > $3).
@@ -3758,7 +3762,7 @@ yyreduce:
   case 180:
 
 /* Line 1455 of yacc.c  */
-#line 1417 "program_parse.y"
+#line 1421 "program_parse.y"
     {
 	   (yyval.state)[0] = (yyvsp[(2) - (3)].state)[0];
 	   (yyval.state)[1] = (yyvsp[(2) - (3)].state)[1];
@@ -3769,7 +3773,7 @@ yyreduce:
   case 181:
 
 /* Line 1455 of yacc.c  */
-#line 1425 "program_parse.y"
+#line 1429 "program_parse.y"
     {
 	   (yyval.integer) = 0;
 	;}
@@ -3778,7 +3782,7 @@ yyreduce:
   case 182:
 
 /* Line 1455 of yacc.c  */
-#line 1429 "program_parse.y"
+#line 1433 "program_parse.y"
     {
 	   (yyval.integer) = (yyvsp[(1) - (1)].integer);
 	;}
@@ -3787,7 +3791,7 @@ yyreduce:
   case 183:
 
 /* Line 1455 of yacc.c  */
-#line 1435 "program_parse.y"
+#line 1439 "program_parse.y"
     {
 	   (yyval.integer) = STATE_MATRIX_INVERSE;
 	;}
@@ -3796,7 +3800,7 @@ yyreduce:
   case 184:
 
 /* Line 1455 of yacc.c  */
-#line 1439 "program_parse.y"
+#line 1443 "program_parse.y"
     {
 	   (yyval.integer) = STATE_MATRIX_TRANSPOSE;
 	;}
@@ -3805,7 +3809,7 @@ yyreduce:
   case 185:
 
 /* Line 1455 of yacc.c  */
-#line 1443 "program_parse.y"
+#line 1447 "program_parse.y"
     {
 	   (yyval.integer) = STATE_MATRIX_INVTRANS;
 	;}
@@ -3814,7 +3818,7 @@ yyreduce:
   case 186:
 
 /* Line 1455 of yacc.c  */
-#line 1449 "program_parse.y"
+#line 1453 "program_parse.y"
     {
 	   if ((yyvsp[(1) - (1)].integer) > 3) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid matrix row reference");
@@ -3828,7 +3832,7 @@ yyreduce:
   case 187:
 
 /* Line 1455 of yacc.c  */
-#line 1460 "program_parse.y"
+#line 1464 "program_parse.y"
     {
 	   (yyval.state)[0] = STATE_MODELVIEW_MATRIX;
 	   (yyval.state)[1] = (yyvsp[(2) - (2)].integer);
@@ -3838,7 +3842,7 @@ yyreduce:
   case 188:
 
 /* Line 1455 of yacc.c  */
-#line 1465 "program_parse.y"
+#line 1469 "program_parse.y"
     {
 	   (yyval.state)[0] = STATE_PROJECTION_MATRIX;
 	   (yyval.state)[1] = 0;
@@ -3848,7 +3852,7 @@ yyreduce:
   case 189:
 
 /* Line 1455 of yacc.c  */
-#line 1470 "program_parse.y"
+#line 1474 "program_parse.y"
     {
 	   (yyval.state)[0] = STATE_MVP_MATRIX;
 	   (yyval.state)[1] = 0;
@@ -3858,7 +3862,7 @@ yyreduce:
   case 190:
 
 /* Line 1455 of yacc.c  */
-#line 1475 "program_parse.y"
+#line 1479 "program_parse.y"
     {
 	   (yyval.state)[0] = STATE_TEXTURE_MATRIX;
 	   (yyval.state)[1] = (yyvsp[(2) - (2)].integer);
@@ -3868,7 +3872,7 @@ yyreduce:
   case 191:
 
 /* Line 1455 of yacc.c  */
-#line 1480 "program_parse.y"
+#line 1484 "program_parse.y"
     {
 	   yyerror(& (yylsp[(1) - (4)]), state, "GL_ARB_matrix_palette not supported");
 	   YYERROR;
@@ -3878,7 +3882,7 @@ yyreduce:
   case 192:
 
 /* Line 1455 of yacc.c  */
-#line 1485 "program_parse.y"
+#line 1489 "program_parse.y"
     {
 	   (yyval.state)[0] = STATE_PROGRAM_MATRIX;
 	   (yyval.state)[1] = (yyvsp[(3) - (4)].integer);
@@ -3888,7 +3892,7 @@ yyreduce:
   case 193:
 
 /* Line 1455 of yacc.c  */
-#line 1492 "program_parse.y"
+#line 1496 "program_parse.y"
     {
 	   (yyval.integer) = 0;
 	;}
@@ -3897,7 +3901,7 @@ yyreduce:
   case 194:
 
 /* Line 1455 of yacc.c  */
-#line 1496 "program_parse.y"
+#line 1500 "program_parse.y"
     {
 	   (yyval.integer) = (yyvsp[(2) - (3)].integer);
 	;}
@@ -3906,7 +3910,7 @@ yyreduce:
   case 195:
 
 /* Line 1455 of yacc.c  */
-#line 1501 "program_parse.y"
+#line 1505 "program_parse.y"
     {
 	   /* Since GL_ARB_vertex_blend isn't supported, only modelview matrix
 	    * zero is valid.
@@ -3923,7 +3927,7 @@ yyreduce:
   case 196:
 
 /* Line 1455 of yacc.c  */
-#line 1514 "program_parse.y"
+#line 1518 "program_parse.y"
     {
 	   /* Since GL_ARB_matrix_palette isn't supported, just let any value
 	    * through here.  The error will be generated later.
@@ -3935,7 +3939,7 @@ yyreduce:
   case 197:
 
 /* Line 1455 of yacc.c  */
-#line 1522 "program_parse.y"
+#line 1526 "program_parse.y"
     {
 	   if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxProgramMatrices) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid program matrix selector");
@@ -3949,7 +3953,7 @@ yyreduce:
   case 198:
 
 /* Line 1455 of yacc.c  */
-#line 1533 "program_parse.y"
+#line 1537 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = STATE_DEPTH_RANGE;
@@ -3959,7 +3963,7 @@ yyreduce:
   case 203:
 
 /* Line 1455 of yacc.c  */
-#line 1545 "program_parse.y"
+#line 1549 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = state->state_param_enum;
@@ -3972,7 +3976,7 @@ yyreduce:
   case 204:
 
 /* Line 1455 of yacc.c  */
-#line 1555 "program_parse.y"
+#line 1559 "program_parse.y"
     {
 	   (yyval.state)[0] = (yyvsp[(1) - (1)].integer);
 	   (yyval.state)[1] = (yyvsp[(1) - (1)].integer);
@@ -3982,7 +3986,7 @@ yyreduce:
   case 205:
 
 /* Line 1455 of yacc.c  */
-#line 1560 "program_parse.y"
+#line 1564 "program_parse.y"
     {
 	   (yyval.state)[0] = (yyvsp[(1) - (3)].integer);
 	   (yyval.state)[1] = (yyvsp[(3) - (3)].integer);
@@ -3992,7 +3996,7 @@ yyreduce:
   case 206:
 
 /* Line 1455 of yacc.c  */
-#line 1567 "program_parse.y"
+#line 1571 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = state->state_param_enum;
@@ -4005,7 +4009,7 @@ yyreduce:
   case 207:
 
 /* Line 1455 of yacc.c  */
-#line 1577 "program_parse.y"
+#line 1581 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = state->state_param_enum;
@@ -4018,7 +4022,7 @@ yyreduce:
   case 208:
 
 /* Line 1455 of yacc.c  */
-#line 1586 "program_parse.y"
+#line 1590 "program_parse.y"
     {
 	   (yyval.state)[0] = (yyvsp[(1) - (1)].integer);
 	   (yyval.state)[1] = (yyvsp[(1) - (1)].integer);
@@ -4028,7 +4032,7 @@ yyreduce:
   case 209:
 
 /* Line 1455 of yacc.c  */
-#line 1591 "program_parse.y"
+#line 1595 "program_parse.y"
     {
 	   (yyval.state)[0] = (yyvsp[(1) - (3)].integer);
 	   (yyval.state)[1] = (yyvsp[(3) - (3)].integer);
@@ -4038,7 +4042,7 @@ yyreduce:
   case 210:
 
 /* Line 1455 of yacc.c  */
-#line 1598 "program_parse.y"
+#line 1602 "program_parse.y"
     {
 	   memset((yyval.state), 0, sizeof((yyval.state)));
 	   (yyval.state)[0] = state->state_param_enum;
@@ -4051,7 +4055,7 @@ yyreduce:
   case 211:
 
 /* Line 1455 of yacc.c  */
-#line 1608 "program_parse.y"
+#line 1612 "program_parse.y"
     {
 	   if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxEnvParams) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid environment parameter reference");
@@ -4064,7 +4068,7 @@ yyreduce:
   case 212:
 
 /* Line 1455 of yacc.c  */
-#line 1618 "program_parse.y"
+#line 1622 "program_parse.y"
     {
 	   if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxLocalParams) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid local parameter reference");
@@ -4077,7 +4081,7 @@ yyreduce:
   case 217:
 
 /* Line 1455 of yacc.c  */
-#line 1633 "program_parse.y"
+#line 1637 "program_parse.y"
     {
 	   (yyval.vector).count = 4;
 	   (yyval.vector).data[0] = (yyvsp[(1) - (1)].real);
@@ -4090,7 +4094,7 @@ yyreduce:
   case 218:
 
 /* Line 1455 of yacc.c  */
-#line 1643 "program_parse.y"
+#line 1647 "program_parse.y"
     {
 	   (yyval.vector).count = 1;
 	   (yyval.vector).data[0] = (yyvsp[(1) - (1)].real);
@@ -4103,7 +4107,7 @@ yyreduce:
   case 219:
 
 /* Line 1455 of yacc.c  */
-#line 1651 "program_parse.y"
+#line 1655 "program_parse.y"
     {
 	   (yyval.vector).count = 1;
 	   (yyval.vector).data[0] = (float) (yyvsp[(1) - (1)].integer);
@@ -4116,7 +4120,7 @@ yyreduce:
   case 220:
 
 /* Line 1455 of yacc.c  */
-#line 1661 "program_parse.y"
+#line 1665 "program_parse.y"
     {
 	   (yyval.vector).count = 4;
 	   (yyval.vector).data[0] = (yyvsp[(2) - (3)].real);
@@ -4129,7 +4133,7 @@ yyreduce:
   case 221:
 
 /* Line 1455 of yacc.c  */
-#line 1669 "program_parse.y"
+#line 1673 "program_parse.y"
     {
 	   (yyval.vector).count = 4;
 	   (yyval.vector).data[0] = (yyvsp[(2) - (5)].real);
@@ -4142,7 +4146,7 @@ yyreduce:
   case 222:
 
 /* Line 1455 of yacc.c  */
-#line 1678 "program_parse.y"
+#line 1682 "program_parse.y"
     {
 	   (yyval.vector).count = 4;
 	   (yyval.vector).data[0] = (yyvsp[(2) - (7)].real);
@@ -4155,7 +4159,7 @@ yyreduce:
   case 223:
 
 /* Line 1455 of yacc.c  */
-#line 1687 "program_parse.y"
+#line 1691 "program_parse.y"
     {
 	   (yyval.vector).count = 4;
 	   (yyval.vector).data[0] = (yyvsp[(2) - (9)].real);
@@ -4168,7 +4172,7 @@ yyreduce:
   case 224:
 
 /* Line 1455 of yacc.c  */
-#line 1697 "program_parse.y"
+#line 1701 "program_parse.y"
     {
 	   (yyval.real) = ((yyvsp[(1) - (2)].negate)) ? -(yyvsp[(2) - (2)].real) : (yyvsp[(2) - (2)].real);
 	;}
@@ -4177,7 +4181,7 @@ yyreduce:
   case 225:
 
 /* Line 1455 of yacc.c  */
-#line 1701 "program_parse.y"
+#line 1705 "program_parse.y"
     {
 	   (yyval.real) = (float)(((yyvsp[(1) - (2)].negate)) ? -(yyvsp[(2) - (2)].integer) : (yyvsp[(2) - (2)].integer));
 	;}
@@ -4186,42 +4190,42 @@ yyreduce:
   case 226:
 
 /* Line 1455 of yacc.c  */
-#line 1706 "program_parse.y"
+#line 1710 "program_parse.y"
     { (yyval.negate) = FALSE; ;}
     break;
 
   case 227:
 
 /* Line 1455 of yacc.c  */
-#line 1707 "program_parse.y"
+#line 1711 "program_parse.y"
     { (yyval.negate) = TRUE;  ;}
     break;
 
   case 228:
 
 /* Line 1455 of yacc.c  */
-#line 1708 "program_parse.y"
+#line 1712 "program_parse.y"
     { (yyval.negate) = FALSE; ;}
     break;
 
   case 229:
 
 /* Line 1455 of yacc.c  */
-#line 1711 "program_parse.y"
+#line 1715 "program_parse.y"
     { (yyval.integer) = (yyvsp[(1) - (1)].integer); ;}
     break;
 
   case 231:
 
 /* Line 1455 of yacc.c  */
-#line 1714 "program_parse.y"
+#line 1718 "program_parse.y"
     { (yyval.integer) = (yyvsp[(1) - (1)].integer); ;}
     break;
 
   case 233:
 
 /* Line 1455 of yacc.c  */
-#line 1718 "program_parse.y"
+#line 1722 "program_parse.y"
     {
 	   if (!declare_variable(state, (yyvsp[(3) - (3)].string), (yyvsp[(0) - (3)].integer), & (yylsp[(3) - (3)]))) {
 	      YYERROR;
@@ -4232,7 +4236,7 @@ yyreduce:
   case 234:
 
 /* Line 1455 of yacc.c  */
-#line 1724 "program_parse.y"
+#line 1728 "program_parse.y"
     {
 	   if (!declare_variable(state, (yyvsp[(1) - (1)].string), (yyvsp[(0) - (1)].integer), & (yylsp[(1) - (1)]))) {
 	      YYERROR;
@@ -4243,7 +4247,7 @@ yyreduce:
   case 235:
 
 /* Line 1455 of yacc.c  */
-#line 1732 "program_parse.y"
+#line 1736 "program_parse.y"
     {
 	   struct asm_symbol *const s =
 	      declare_variable(state, (yyvsp[(2) - (4)].string), at_output, & (yylsp[(2) - (4)]));
@@ -4259,7 +4263,7 @@ yyreduce:
   case 236:
 
 /* Line 1455 of yacc.c  */
-#line 1745 "program_parse.y"
+#line 1749 "program_parse.y"
     {
 	   if (state->mode == ARB_vertex) {
 	      (yyval.result) = VERT_RESULT_HPOS;
@@ -4273,7 +4277,7 @@ yyreduce:
   case 237:
 
 /* Line 1455 of yacc.c  */
-#line 1754 "program_parse.y"
+#line 1758 "program_parse.y"
     {
 	   if (state->mode == ARB_vertex) {
 	      (yyval.result) = VERT_RESULT_FOGC;
@@ -4287,7 +4291,7 @@ yyreduce:
   case 238:
 
 /* Line 1455 of yacc.c  */
-#line 1763 "program_parse.y"
+#line 1767 "program_parse.y"
     {
 	   (yyval.result) = (yyvsp[(2) - (2)].result);
 	;}
@@ -4296,7 +4300,7 @@ yyreduce:
   case 239:
 
 /* Line 1455 of yacc.c  */
-#line 1767 "program_parse.y"
+#line 1771 "program_parse.y"
     {
 	   if (state->mode == ARB_vertex) {
 	      (yyval.result) = VERT_RESULT_PSIZ;
@@ -4310,7 +4314,7 @@ yyreduce:
   case 240:
 
 /* Line 1455 of yacc.c  */
-#line 1776 "program_parse.y"
+#line 1780 "program_parse.y"
     {
 	   if (state->mode == ARB_vertex) {
 	      (yyval.result) = VERT_RESULT_TEX0 + (yyvsp[(3) - (3)].integer);
@@ -4324,7 +4328,7 @@ yyreduce:
   case 241:
 
 /* Line 1455 of yacc.c  */
-#line 1785 "program_parse.y"
+#line 1789 "program_parse.y"
     {
 	   if (state->mode == ARB_fragment) {
 	      (yyval.result) = FRAG_RESULT_DEPTH;
@@ -4338,7 +4342,7 @@ yyreduce:
   case 242:
 
 /* Line 1455 of yacc.c  */
-#line 1796 "program_parse.y"
+#line 1800 "program_parse.y"
     {
 	   (yyval.result) = (yyvsp[(2) - (3)].integer) + (yyvsp[(3) - (3)].integer);
 	;}
@@ -4347,7 +4351,7 @@ yyreduce:
   case 243:
 
 /* Line 1455 of yacc.c  */
-#line 1802 "program_parse.y"
+#line 1806 "program_parse.y"
     {
 	   (yyval.integer) = (state->mode == ARB_vertex)
 	      ? VERT_RESULT_COL0
@@ -4358,7 +4362,7 @@ yyreduce:
   case 244:
 
 /* Line 1455 of yacc.c  */
-#line 1808 "program_parse.y"
+#line 1812 "program_parse.y"
     {
 	   if (state->mode == ARB_vertex) {
 	      (yyval.integer) = VERT_RESULT_COL0;
@@ -4372,7 +4376,7 @@ yyreduce:
   case 245:
 
 /* Line 1455 of yacc.c  */
-#line 1817 "program_parse.y"
+#line 1821 "program_parse.y"
     {
 	   if (state->mode == ARB_vertex) {
 	      (yyval.integer) = VERT_RESULT_BFC0;
@@ -4386,7 +4390,7 @@ yyreduce:
   case 246:
 
 /* Line 1455 of yacc.c  */
-#line 1828 "program_parse.y"
+#line 1832 "program_parse.y"
     {
 	   (yyval.integer) = 0; 
 	;}
@@ -4395,7 +4399,7 @@ yyreduce:
   case 247:
 
 /* Line 1455 of yacc.c  */
-#line 1832 "program_parse.y"
+#line 1836 "program_parse.y"
     {
 	   if (state->mode == ARB_vertex) {
 	      (yyval.integer) = 0;
@@ -4409,7 +4413,7 @@ yyreduce:
   case 248:
 
 /* Line 1455 of yacc.c  */
-#line 1841 "program_parse.y"
+#line 1845 "program_parse.y"
     {
 	   if (state->mode == ARB_vertex) {
 	      (yyval.integer) = 1;
@@ -4423,91 +4427,91 @@ yyreduce:
   case 249:
 
 /* Line 1455 of yacc.c  */
-#line 1851 "program_parse.y"
+#line 1855 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
   case 250:
 
 /* Line 1455 of yacc.c  */
-#line 1852 "program_parse.y"
+#line 1856 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
   case 251:
 
 /* Line 1455 of yacc.c  */
-#line 1853 "program_parse.y"
+#line 1857 "program_parse.y"
     { (yyval.integer) = 1; ;}
     break;
 
   case 252:
 
 /* Line 1455 of yacc.c  */
-#line 1856 "program_parse.y"
+#line 1860 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
   case 253:
 
 /* Line 1455 of yacc.c  */
-#line 1857 "program_parse.y"
+#line 1861 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
   case 254:
 
 /* Line 1455 of yacc.c  */
-#line 1858 "program_parse.y"
+#line 1862 "program_parse.y"
     { (yyval.integer) = 1; ;}
     break;
 
   case 255:
 
 /* Line 1455 of yacc.c  */
-#line 1861 "program_parse.y"
+#line 1865 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
   case 256:
 
 /* Line 1455 of yacc.c  */
-#line 1862 "program_parse.y"
+#line 1866 "program_parse.y"
     { (yyval.integer) = (yyvsp[(2) - (3)].integer); ;}
     break;
 
   case 257:
 
 /* Line 1455 of yacc.c  */
-#line 1865 "program_parse.y"
+#line 1869 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
   case 258:
 
 /* Line 1455 of yacc.c  */
-#line 1866 "program_parse.y"
+#line 1870 "program_parse.y"
     { (yyval.integer) = (yyvsp[(2) - (3)].integer); ;}
     break;
 
   case 259:
 
 /* Line 1455 of yacc.c  */
-#line 1869 "program_parse.y"
+#line 1873 "program_parse.y"
     { (yyval.integer) = 0; ;}
     break;
 
   case 260:
 
 /* Line 1455 of yacc.c  */
-#line 1870 "program_parse.y"
+#line 1874 "program_parse.y"
     { (yyval.integer) = (yyvsp[(2) - (3)].integer); ;}
     break;
 
   case 261:
 
 /* Line 1455 of yacc.c  */
-#line 1874 "program_parse.y"
+#line 1878 "program_parse.y"
     {
 	   if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxTextureCoordUnits) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid texture coordinate unit selector");
@@ -4521,7 +4525,7 @@ yyreduce:
   case 262:
 
 /* Line 1455 of yacc.c  */
-#line 1885 "program_parse.y"
+#line 1889 "program_parse.y"
     {
 	   if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxTextureImageUnits) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid texture image unit selector");
@@ -4535,7 +4539,7 @@ yyreduce:
   case 263:
 
 /* Line 1455 of yacc.c  */
-#line 1896 "program_parse.y"
+#line 1900 "program_parse.y"
     {
 	   if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxTextureUnits) {
 	      yyerror(& (yylsp[(1) - (1)]), state, "invalid texture unit selector");
@@ -4549,7 +4553,7 @@ yyreduce:
   case 264:
 
 /* Line 1455 of yacc.c  */
-#line 1907 "program_parse.y"
+#line 1911 "program_parse.y"
     {
 	   struct asm_symbol *exist = (struct asm_symbol *)
 	      _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(2) - (4)].string));
@@ -4573,7 +4577,7 @@ yyreduce:
 
 
 /* Line 1455 of yacc.c  */
-#line 4577 "program_parse.tab.c"
+#line 4581 "program_parse.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
@@ -4792,7 +4796,7 @@ yyreturn:
 
 
 /* Line 1675 of yacc.c  */
-#line 1927 "program_parse.y"
+#line 1931 "program_parse.y"
 
 
 struct asm_instruction *
diff --git a/src/mesa/shader/program_parse.y b/src/mesa/shader/program_parse.y
index 06c1915fbe..89da91064b 100644
--- a/src/mesa/shader/program_parse.y
+++ b/src/mesa/shader/program_parse.y
@@ -806,8 +806,10 @@ addrRegRelOffset:              { $$ = 0; }
 addrRegPosOffset: INTEGER
 	{
 	   if (($1 < 0) || ($1 > 63)) {
-	      yyerror(& @1, state,
-		      "relative address offset too large (positive)");
+              char s[100];
+              _mesa_snprintf(s, sizeof(s),
+                             "relative address offset too large (%d)", $1);
+	      yyerror(& @1, state, s);
 	      YYERROR;
 	   } else {
 	      $$ = $1;
@@ -818,8 +820,10 @@ addrRegPosOffset: INTEGER
 addrRegNegOffset: INTEGER
 	{
 	   if (($1 < 0) || ($1 > 64)) {
-	      yyerror(& @1, state,
-		      "relative address offset too large (negative)");
+              char s[100];
+              _mesa_snprintf(s, sizeof(s),
+                             "relative address offset too large (%d)", $1);
+	      yyerror(& @1, state, s);
 	      YYERROR;
 	   } else {
 	      $$ = $1;
diff --git a/src/mesa/shader/shader_api.c b/src/mesa/shader/shader_api.c
index 54a25dfaf0..178b7d0dba 100644
--- a/src/mesa/shader/shader_api.c
+++ b/src/mesa/shader/shader_api.c
@@ -1474,6 +1474,21 @@ _mesa_link_program(GLcontext *ctx, GLuint program)
    FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 
    _slang_link(ctx, program, shProg);
+
+   /* debug code */
+   if (0) {
+      GLuint i;
+
+      _mesa_printf("Link %u shaders in program %u: %s\n",
+                   shProg->NumShaders, shProg->Name,
+                   shProg->LinkStatus ? "Success" : "Failed");
+
+      for (i = 0; i < shProg->NumShaders; i++) {
+         _mesa_printf(" shader %u, type 0x%x\n",
+                      shProg->Shaders[i]->Name,
+                      shProg->Shaders[i]->Type);
+      }
+   }
 }
 
 
diff --git a/src/mesa/shader/slang/slang_link.c b/src/mesa/shader/slang/slang_link.c
index 169c07f8ce..8f2b40d5df 100644
--- a/src/mesa/shader/slang/slang_link.c
+++ b/src/mesa/shader/slang/slang_link.c
@@ -546,6 +546,32 @@ _slang_update_inputs_outputs(struct gl_program *prog)
 
 
 
+/**
+ * Remove extra #version directives from the concatenated source string.
+ * Disable the extra ones by converting first two chars to //, a comment.
+ * This is a bit of hack to work around a preprocessor bug that only
+ * allows one #version directive per source.
+ */
+static void
+remove_extra_version_directives(GLchar *source)
+{
+   GLuint verCount = 0;
+   while (1) {
+      char *ver = _mesa_strstr(source, "#version");
+      if (ver) {
+         verCount++;
+         if (verCount > 1) {
+            ver[0] = '/';
+            ver[1] = '/';
+         }
+         source += 8;
+      }
+      else {
+         break;
+      }
+   }
+}
+
 
 
 /**
@@ -593,6 +619,8 @@ concat_shaders(struct gl_shader_program *shProg, GLenum shaderType)
    _mesa_printf("---NEW CONCATENATED SHADER---:\n%s\n------------\n", source);
    */
 
+   remove_extra_version_directives(source);
+
    newShader = CALLOC_STRUCT(gl_shader);
    newShader->Type = shaderType;
    newShader->Source = source;
diff --git a/src/mesa/sources.mak b/src/mesa/sources.mak
index fa2a6307a4..7107538cee 100644
--- a/src/mesa/sources.mak
+++ b/src/mesa/sources.mak
@@ -115,7 +115,6 @@ SWRAST_SOURCES = \
 	swrast/s_feedback.c \
 	swrast/s_fog.c \
 	swrast/s_fragprog.c \
-	swrast/s_imaging.c \
 	swrast/s_lines.c \
 	swrast/s_logic.c \
 	swrast/s_masking.c \
@@ -125,7 +124,6 @@ SWRAST_SOURCES = \
 	swrast/s_stencil.c \
 	swrast/s_texcombine.c \
 	swrast/s_texfilter.c \
-	swrast/s_texstore.c \
 	swrast/s_triangle.c \
 	swrast/s_zoom.c
 
diff --git a/src/mesa/sparc/clip.S b/src/mesa/sparc/clip.S
index 208843c606..dc239171ff 100644
--- a/src/mesa/sparc/clip.S
+++ b/src/mesa/sparc/clip.S
@@ -58,7 +58,8 @@ clip_table:
 	.byte	31, 29, 31, 30, 27, 25, 27, 26
 
 /* GLvector4f *clip_vec, GLvector4f *proj_vec, 
-   GLubyte clipMask[], GLubyte *orMask, GLubyte *andMask */
+   GLubyte clipMask[], GLubyte *orMask, GLubyte *andMask,
+   GLboolean viewport_z_enable */
 
 	.align		64
 __pc_tramp:
diff --git a/src/mesa/sparc/glapi_sparc.S b/src/mesa/sparc/glapi_sparc.S
index 5b2c9e4a9a..aaa17e6a3b 100644
--- a/src/mesa/sparc/glapi_sparc.S
+++ b/src/mesa/sparc/glapi_sparc.S
@@ -771,23 +771,26 @@ gl_dispatch_functions_start:
 	GL_STUB(glGetSynciv, _gloffset_GetSynciv)
 	GL_STUB(glIsSync, _gloffset_IsSync)
 	GL_STUB(glWaitSync, _gloffset_WaitSync)
+	GL_STUB(glDrawElementsBaseVertex, _gloffset_DrawElementsBaseVertex)
+	GL_STUB(glDrawRangeElementsBaseVertex, _gloffset_DrawRangeElementsBaseVertex)
+	GL_STUB(glMultiDrawElementsBaseVertex, _gloffset_MultiDrawElementsBaseVertex)
 	GL_STUB(glPolygonOffsetEXT, _gloffset_PolygonOffsetEXT)
-	GL_STUB(gl_dispatch_stub_575, _gloffset_GetPixelTexGenParameterfvSGIS)
-	HIDDEN(gl_dispatch_stub_575)
-	GL_STUB(gl_dispatch_stub_576, _gloffset_GetPixelTexGenParameterivSGIS)
-	HIDDEN(gl_dispatch_stub_576)
-	GL_STUB(gl_dispatch_stub_577, _gloffset_PixelTexGenParameterfSGIS)
-	HIDDEN(gl_dispatch_stub_577)
-	GL_STUB(gl_dispatch_stub_578, _gloffset_PixelTexGenParameterfvSGIS)
+	GL_STUB(gl_dispatch_stub_578, _gloffset_GetPixelTexGenParameterfvSGIS)
 	HIDDEN(gl_dispatch_stub_578)
-	GL_STUB(gl_dispatch_stub_579, _gloffset_PixelTexGenParameteriSGIS)
+	GL_STUB(gl_dispatch_stub_579, _gloffset_GetPixelTexGenParameterivSGIS)
 	HIDDEN(gl_dispatch_stub_579)
-	GL_STUB(gl_dispatch_stub_580, _gloffset_PixelTexGenParameterivSGIS)
+	GL_STUB(gl_dispatch_stub_580, _gloffset_PixelTexGenParameterfSGIS)
 	HIDDEN(gl_dispatch_stub_580)
-	GL_STUB(gl_dispatch_stub_581, _gloffset_SampleMaskSGIS)
+	GL_STUB(gl_dispatch_stub_581, _gloffset_PixelTexGenParameterfvSGIS)
 	HIDDEN(gl_dispatch_stub_581)
-	GL_STUB(gl_dispatch_stub_582, _gloffset_SamplePatternSGIS)
+	GL_STUB(gl_dispatch_stub_582, _gloffset_PixelTexGenParameteriSGIS)
 	HIDDEN(gl_dispatch_stub_582)
+	GL_STUB(gl_dispatch_stub_583, _gloffset_PixelTexGenParameterivSGIS)
+	HIDDEN(gl_dispatch_stub_583)
+	GL_STUB(gl_dispatch_stub_584, _gloffset_SampleMaskSGIS)
+	HIDDEN(gl_dispatch_stub_584)
+	GL_STUB(gl_dispatch_stub_585, _gloffset_SamplePatternSGIS)
+	HIDDEN(gl_dispatch_stub_585)
 	GL_STUB(glColorPointerEXT, _gloffset_ColorPointerEXT)
 	GL_STUB(glEdgeFlagPointerEXT, _gloffset_EdgeFlagPointerEXT)
 	GL_STUB(glIndexPointerEXT, _gloffset_IndexPointerEXT)
@@ -798,10 +801,10 @@ gl_dispatch_functions_start:
 	GL_STUB(glPointParameterfvEXT, _gloffset_PointParameterfvEXT)
 	GL_STUB(glLockArraysEXT, _gloffset_LockArraysEXT)
 	GL_STUB(glUnlockArraysEXT, _gloffset_UnlockArraysEXT)
-	GL_STUB(gl_dispatch_stub_593, _gloffset_CullParameterdvEXT)
-	HIDDEN(gl_dispatch_stub_593)
-	GL_STUB(gl_dispatch_stub_594, _gloffset_CullParameterfvEXT)
-	HIDDEN(gl_dispatch_stub_594)
+	GL_STUB(gl_dispatch_stub_596, _gloffset_CullParameterdvEXT)
+	HIDDEN(gl_dispatch_stub_596)
+	GL_STUB(gl_dispatch_stub_597, _gloffset_CullParameterfvEXT)
+	HIDDEN(gl_dispatch_stub_597)
 	GL_STUB(glSecondaryColor3bEXT, _gloffset_SecondaryColor3bEXT)
 	GL_STUB(glSecondaryColor3bvEXT, _gloffset_SecondaryColor3bvEXT)
 	GL_STUB(glSecondaryColor3dEXT, _gloffset_SecondaryColor3dEXT)
@@ -826,8 +829,8 @@ gl_dispatch_functions_start:
 	GL_STUB(glFogCoorddvEXT, _gloffset_FogCoorddvEXT)
 	GL_STUB(glFogCoordfEXT, _gloffset_FogCoordfEXT)
 	GL_STUB(glFogCoordfvEXT, _gloffset_FogCoordfvEXT)
-	GL_STUB(gl_dispatch_stub_619, _gloffset_PixelTexGenSGIX)
-	HIDDEN(gl_dispatch_stub_619)
+	GL_STUB(gl_dispatch_stub_622, _gloffset_PixelTexGenSGIX)
+	HIDDEN(gl_dispatch_stub_622)
 	GL_STUB(glBlendFuncSeparateEXT, _gloffset_BlendFuncSeparateEXT)
 	GL_STUB(glFlushVertexArrayRangeNV, _gloffset_FlushVertexArrayRangeNV)
 	GL_STUB(glVertexArrayRangeNV, _gloffset_VertexArrayRangeNV)
@@ -869,24 +872,24 @@ gl_dispatch_functions_start:
 	GL_STUB(glWindowPos4ivMESA, _gloffset_WindowPos4ivMESA)
 	GL_STUB(glWindowPos4sMESA, _gloffset_WindowPos4sMESA)
 	GL_STUB(glWindowPos4svMESA, _gloffset_WindowPos4svMESA)
-	GL_STUB(gl_dispatch_stub_661, _gloffset_MultiModeDrawArraysIBM)
-	HIDDEN(gl_dispatch_stub_661)
-	GL_STUB(gl_dispatch_stub_662, _gloffset_MultiModeDrawElementsIBM)
-	HIDDEN(gl_dispatch_stub_662)
-	GL_STUB(gl_dispatch_stub_663, _gloffset_DeleteFencesNV)
-	HIDDEN(gl_dispatch_stub_663)
-	GL_STUB(gl_dispatch_stub_664, _gloffset_FinishFenceNV)
+	GL_STUB(gl_dispatch_stub_664, _gloffset_MultiModeDrawArraysIBM)
 	HIDDEN(gl_dispatch_stub_664)
-	GL_STUB(gl_dispatch_stub_665, _gloffset_GenFencesNV)
+	GL_STUB(gl_dispatch_stub_665, _gloffset_MultiModeDrawElementsIBM)
 	HIDDEN(gl_dispatch_stub_665)
-	GL_STUB(gl_dispatch_stub_666, _gloffset_GetFenceivNV)
+	GL_STUB(gl_dispatch_stub_666, _gloffset_DeleteFencesNV)
 	HIDDEN(gl_dispatch_stub_666)
-	GL_STUB(gl_dispatch_stub_667, _gloffset_IsFenceNV)
+	GL_STUB(gl_dispatch_stub_667, _gloffset_FinishFenceNV)
 	HIDDEN(gl_dispatch_stub_667)
-	GL_STUB(gl_dispatch_stub_668, _gloffset_SetFenceNV)
+	GL_STUB(gl_dispatch_stub_668, _gloffset_GenFencesNV)
 	HIDDEN(gl_dispatch_stub_668)
-	GL_STUB(gl_dispatch_stub_669, _gloffset_TestFenceNV)
+	GL_STUB(gl_dispatch_stub_669, _gloffset_GetFenceivNV)
 	HIDDEN(gl_dispatch_stub_669)
+	GL_STUB(gl_dispatch_stub_670, _gloffset_IsFenceNV)
+	HIDDEN(gl_dispatch_stub_670)
+	GL_STUB(gl_dispatch_stub_671, _gloffset_SetFenceNV)
+	HIDDEN(gl_dispatch_stub_671)
+	GL_STUB(gl_dispatch_stub_672, _gloffset_TestFenceNV)
+	HIDDEN(gl_dispatch_stub_672)
 	GL_STUB(glAreProgramsResidentNV, _gloffset_AreProgramsResidentNV)
 	GL_STUB(glBindProgramNV, _gloffset_BindProgramNV)
 	GL_STUB(glDeleteProgramsNV, _gloffset_DeleteProgramsNV)
@@ -967,26 +970,26 @@ gl_dispatch_functions_start:
 	GL_STUB(glSetFragmentShaderConstantATI, _gloffset_SetFragmentShaderConstantATI)
 	GL_STUB(glPointParameteriNV, _gloffset_PointParameteriNV)
 	GL_STUB(glPointParameterivNV, _gloffset_PointParameterivNV)
-	GL_STUB(gl_dispatch_stub_750, _gloffset_ActiveStencilFaceEXT)
-	HIDDEN(gl_dispatch_stub_750)
-	GL_STUB(gl_dispatch_stub_751, _gloffset_BindVertexArrayAPPLE)
-	HIDDEN(gl_dispatch_stub_751)
-	GL_STUB(gl_dispatch_stub_752, _gloffset_DeleteVertexArraysAPPLE)
-	HIDDEN(gl_dispatch_stub_752)
-	GL_STUB(gl_dispatch_stub_753, _gloffset_GenVertexArraysAPPLE)
+	GL_STUB(gl_dispatch_stub_753, _gloffset_ActiveStencilFaceEXT)
 	HIDDEN(gl_dispatch_stub_753)
-	GL_STUB(gl_dispatch_stub_754, _gloffset_IsVertexArrayAPPLE)
+	GL_STUB(gl_dispatch_stub_754, _gloffset_BindVertexArrayAPPLE)
 	HIDDEN(gl_dispatch_stub_754)
+	GL_STUB(gl_dispatch_stub_755, _gloffset_DeleteVertexArraysAPPLE)
+	HIDDEN(gl_dispatch_stub_755)
+	GL_STUB(gl_dispatch_stub_756, _gloffset_GenVertexArraysAPPLE)
+	HIDDEN(gl_dispatch_stub_756)
+	GL_STUB(gl_dispatch_stub_757, _gloffset_IsVertexArrayAPPLE)
+	HIDDEN(gl_dispatch_stub_757)
 	GL_STUB(glGetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV)
 	GL_STUB(glGetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV)
 	GL_STUB(glProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV)
 	GL_STUB(glProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV)
 	GL_STUB(glProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV)
 	GL_STUB(glProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV)
-	GL_STUB(gl_dispatch_stub_761, _gloffset_DepthBoundsEXT)
-	HIDDEN(gl_dispatch_stub_761)
-	GL_STUB(gl_dispatch_stub_762, _gloffset_BlendEquationSeparateEXT)
-	HIDDEN(gl_dispatch_stub_762)
+	GL_STUB(gl_dispatch_stub_764, _gloffset_DepthBoundsEXT)
+	HIDDEN(gl_dispatch_stub_764)
+	GL_STUB(gl_dispatch_stub_765, _gloffset_BlendEquationSeparateEXT)
+	HIDDEN(gl_dispatch_stub_765)
 	GL_STUB(glBindFramebufferEXT, _gloffset_BindFramebufferEXT)
 	GL_STUB(glBindRenderbufferEXT, _gloffset_BindRenderbufferEXT)
 	GL_STUB(glCheckFramebufferStatusEXT, _gloffset_CheckFramebufferStatusEXT)
@@ -1004,28 +1007,28 @@ gl_dispatch_functions_start:
 	GL_STUB(glIsFramebufferEXT, _gloffset_IsFramebufferEXT)
 	GL_STUB(glIsRenderbufferEXT, _gloffset_IsRenderbufferEXT)
 	GL_STUB(glRenderbufferStorageEXT, _gloffset_RenderbufferStorageEXT)
-	GL_STUB(gl_dispatch_stub_780, _gloffset_BlitFramebufferEXT)
-	HIDDEN(gl_dispatch_stub_780)
-	GL_STUB(gl_dispatch_stub_781, _gloffset_BufferParameteriAPPLE)
-	HIDDEN(gl_dispatch_stub_781)
-	GL_STUB(gl_dispatch_stub_782, _gloffset_FlushMappedBufferRangeAPPLE)
-	HIDDEN(gl_dispatch_stub_782)
+	GL_STUB(gl_dispatch_stub_783, _gloffset_BlitFramebufferEXT)
+	HIDDEN(gl_dispatch_stub_783)
+	GL_STUB(gl_dispatch_stub_784, _gloffset_BufferParameteriAPPLE)
+	HIDDEN(gl_dispatch_stub_784)
+	GL_STUB(gl_dispatch_stub_785, _gloffset_FlushMappedBufferRangeAPPLE)
+	HIDDEN(gl_dispatch_stub_785)
 	GL_STUB(glFramebufferTextureLayerEXT, _gloffset_FramebufferTextureLayerEXT)
 	GL_STUB(glProvokingVertexEXT, _gloffset_ProvokingVertexEXT)
-	GL_STUB(gl_dispatch_stub_785, _gloffset_GetTexParameterPointervAPPLE)
-	HIDDEN(gl_dispatch_stub_785)
-	GL_STUB(gl_dispatch_stub_786, _gloffset_TextureRangeAPPLE)
-	HIDDEN(gl_dispatch_stub_786)
-	GL_STUB(gl_dispatch_stub_787, _gloffset_StencilFuncSeparateATI)
-	HIDDEN(gl_dispatch_stub_787)
-	GL_STUB(gl_dispatch_stub_788, _gloffset_ProgramEnvParameters4fvEXT)
+	GL_STUB(gl_dispatch_stub_788, _gloffset_GetTexParameterPointervAPPLE)
 	HIDDEN(gl_dispatch_stub_788)
-	GL_STUB(gl_dispatch_stub_789, _gloffset_ProgramLocalParameters4fvEXT)
+	GL_STUB(gl_dispatch_stub_789, _gloffset_TextureRangeAPPLE)
 	HIDDEN(gl_dispatch_stub_789)
-	GL_STUB(gl_dispatch_stub_790, _gloffset_GetQueryObjecti64vEXT)
+	GL_STUB(gl_dispatch_stub_790, _gloffset_StencilFuncSeparateATI)
 	HIDDEN(gl_dispatch_stub_790)
-	GL_STUB(gl_dispatch_stub_791, _gloffset_GetQueryObjectui64vEXT)
+	GL_STUB(gl_dispatch_stub_791, _gloffset_ProgramEnvParameters4fvEXT)
 	HIDDEN(gl_dispatch_stub_791)
+	GL_STUB(gl_dispatch_stub_792, _gloffset_ProgramLocalParameters4fvEXT)
+	HIDDEN(gl_dispatch_stub_792)
+	GL_STUB(gl_dispatch_stub_793, _gloffset_GetQueryObjecti64vEXT)
+	HIDDEN(gl_dispatch_stub_793)
+	GL_STUB(gl_dispatch_stub_794, _gloffset_GetQueryObjectui64vEXT)
+	HIDDEN(gl_dispatch_stub_794)
 	GL_STUB_ALIAS(glArrayElementEXT, glArrayElement)
 	GL_STUB_ALIAS(glBindTextureEXT, glBindTexture)
 	GL_STUB_ALIAS(glDrawArraysEXT, glDrawArrays)
@@ -1359,6 +1362,7 @@ gl_dispatch_functions_start:
 	GL_STUB_ALIAS(glIsRenderbuffer, glIsRenderbufferEXT)
 	GL_STUB_ALIAS(glRenderbufferStorage, glRenderbufferStorageEXT)
 	GL_STUB_ALIAS(glFramebufferTextureLayer, glFramebufferTextureLayerEXT)
+	GL_STUB_ALIAS(glProvokingVertex, glProvokingVertexEXT)
 
 	.globl	gl_dispatch_functions_end
 	HIDDEN(gl_dispatch_functions_end)
diff --git a/src/mesa/sparc/sparc.c b/src/mesa/sparc/sparc.c
index d2286a2c83..cea0c7cecf 100644
--- a/src/mesa/sparc/sparc.c
+++ b/src/mesa/sparc/sparc.c
@@ -78,13 +78,15 @@ extern GLvector4f  *_mesa_sparc_cliptest_points4(GLvector4f *clip_vec,
 						 GLvector4f *proj_vec,
 						 GLubyte clipMask[],
 						 GLubyte *orMask,
-						 GLubyte *andMask);
+						 GLubyte *andMask,
+						 GLboolean viewport_z_clip);
 
 extern GLvector4f  *_mesa_sparc_cliptest_points4_np(GLvector4f *clip_vec,
 						    GLvector4f *proj_vec,
 						    GLubyte clipMask[],
 						    GLubyte *orMask,
-						    GLubyte *andMask);
+						    GLubyte *andMask,
+						    GLboolean viewport_z_clip);
 
 #define NORM_ARGS	const GLmatrix *mat,				\
 			GLfloat scale,					\
diff --git a/src/mesa/state_tracker/st_cb_blit.c b/src/mesa/state_tracker/st_cb_blit.c
index c741940bcf..5626e25323 100644
--- a/src/mesa/state_tracker/st_cb_blit.c
+++ b/src/mesa/state_tracker/st_cb_blit.c
@@ -39,6 +39,7 @@
 #include "shader/prog_print.h"
 
 #include "st_context.h"
+#include "st_texture.h"
 #include "st_program.h"
 #include "st_cb_blit.h"
 #include "st_cb_fbo.h"
@@ -110,17 +111,50 @@ st_BlitFramebuffer(GLcontext *ctx,
    }
 
    if (mask & GL_COLOR_BUFFER_BIT) {
-      struct st_renderbuffer *srcRb = 
-         st_renderbuffer(readFB->_ColorReadBuffer);
-      struct st_renderbuffer *dstRb = 
-         st_renderbuffer(drawFB->_ColorDrawBuffers[0]);
-      struct pipe_surface *srcSurf = srcRb->surface;
-      struct pipe_surface *dstSurf = dstRb->surface;
-
-      util_blit_pixels(st->blit,
-                       srcSurf, srcX0, srcY0, srcX1, srcY1,
-                       dstSurf, dstX0, dstY0, dstX1, dstY1,
-                       0.0, pFilter);
+      struct gl_renderbuffer_attachment *srcAtt =
+         &readFB->Attachment[readFB->_ColorReadBufferIndex];
+
+      if(srcAtt->Type == GL_TEXTURE) {
+         struct pipe_screen *screen = ctx->st->pipe->screen;
+         const struct st_texture_object *srcObj =
+            st_texture_object(srcAtt->Texture);
+         struct st_renderbuffer *dstRb =
+            st_renderbuffer(drawFB->_ColorDrawBuffers[0]);
+         struct pipe_surface *srcSurf;
+         struct pipe_surface *dstSurf = dstRb->surface;
+
+         if (!srcObj->pt)
+            return;
+
+         srcSurf = screen->get_tex_surface(screen,
+                                           srcObj->pt,
+                                           srcAtt->CubeMapFace,
+                                           srcAtt->TextureLevel,
+                                           srcAtt->Zoffset,
+                                           PIPE_BUFFER_USAGE_GPU_READ);
+         if(!srcSurf)
+            return;
+
+         util_blit_pixels(st->blit,
+                          srcSurf, srcX0, srcY0, srcX1, srcY1,
+                          dstSurf, dstX0, dstY0, dstX1, dstY1,
+                          0.0, pFilter);
+
+         pipe_surface_reference(&srcSurf, NULL);
+      }
+      else {
+         struct st_renderbuffer *srcRb =
+            st_renderbuffer(readFB->_ColorReadBuffer);
+         struct st_renderbuffer *dstRb =
+            st_renderbuffer(drawFB->_ColorDrawBuffers[0]);
+         struct pipe_surface *srcSurf = srcRb->surface;
+         struct pipe_surface *dstSurf = dstRb->surface;
+
+         util_blit_pixels(st->blit,
+                          srcSurf, srcX0, srcY0, srcX1, srcY1,
+                          dstSurf, dstX0, dstY0, dstX1, dstY1,
+                          0.0, pFilter);
+      }
    }
 
    if (mask & depthStencil) {
diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c
index a9cafbf8cd..99f3ba678b 100644
--- a/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -98,7 +98,7 @@ is_passthrough_program(const struct gl_fragment_program *prog)
 static struct st_fragment_program *
 combined_drawpix_fragment_program(GLcontext *ctx)
 {
-   struct st_context *st = ctx->st;
+   struct st_context *st = st_context(ctx);
    struct st_fragment_program *stfp;
 
    if (st->pixel_xfer.program->serialNo == st->pixel_xfer.xfer_prog_sn
@@ -445,8 +445,8 @@ draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
           GLfloat x1, GLfloat y1, const GLfloat *color,
           GLboolean invertTex, GLfloat maxXcoord, GLfloat maxYcoord)
 {
-   struct st_context *st = ctx->st;
-   struct pipe_context *pipe = ctx->st->pipe;
+   struct st_context *st = st_context(ctx);
+   struct pipe_context *pipe = st->pipe;
    GLfloat verts[4][3][4]; /* four verts, three attribs, XYZW */
 
    /* setup vertex data */
@@ -540,9 +540,9 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
                    const GLfloat *color,
                    GLboolean invertTex)
 {
-   struct st_context *st = ctx->st;
-   struct pipe_context *pipe = ctx->st->pipe;
-   struct cso_context *cso = ctx->st->cso_context;
+   struct st_context *st = st_context(ctx);
+   struct pipe_context *pipe = st->pipe;
+   struct cso_context *cso = st->cso_context;
    GLfloat x0, y0, x1, y1;
    GLsizei maxSize;
 
@@ -652,7 +652,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
                     const struct gl_pixelstore_attrib *unpack,
                     const GLvoid *pixels)
 {
-   struct st_context *st = ctx->st;
+   struct st_context *st = st_context(ctx);
    struct pipe_context *pipe = st->pipe;
    struct pipe_screen *screen = pipe->screen;
    struct st_renderbuffer *strb;
@@ -793,7 +793,7 @@ st_DrawPixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
 {
    struct st_fragment_program *stfp;
    struct st_vertex_program *stvp;
-   struct st_context *st = ctx->st;
+   struct st_context *st = st_context(ctx);
    struct pipe_surface *ps;
    const GLfloat *color;
 
@@ -811,21 +811,21 @@ st_DrawPixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
 
    if (format == GL_DEPTH_COMPONENT) {
       ps = st->state.framebuffer.zsbuf;
-      stfp = make_fragment_shader_z(ctx->st);
-      stvp = st_make_passthrough_vertex_shader(ctx->st, GL_TRUE);
+      stfp = make_fragment_shader_z(st);
+      stvp = st_make_passthrough_vertex_shader(st, GL_TRUE);
       color = ctx->Current.RasterColor;
    }
    else {
       ps = st->state.framebuffer.cbufs[0];
       stfp = combined_drawpix_fragment_program(ctx);
-      stvp = st_make_passthrough_vertex_shader(ctx->st, GL_FALSE);
+      stvp = st_make_passthrough_vertex_shader(st, GL_FALSE);
       color = NULL;
    }
 
    /* draw with textured quad */
    {
       struct pipe_texture *pt
-         = make_texture(ctx->st, width, height, format, type, unpack, pixels);
+         = make_texture(st, width, height, format, type, unpack, pixels);
       if (pt) {
          draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],
                             width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
@@ -942,7 +942,7 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
               GLsizei width, GLsizei height,
               GLint dstx, GLint dsty, GLenum type)
 {
-   struct st_context *st = ctx->st;
+   struct st_context *st = st_context(ctx);
    struct pipe_context *pipe = st->pipe;
    struct pipe_screen *screen = pipe->screen;
    struct st_renderbuffer *rbRead;
@@ -995,14 +995,14 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
       rbRead = st_get_color_read_renderbuffer(ctx);
       color = NULL;
       stfp = combined_drawpix_fragment_program(ctx);
-      stvp = st_make_passthrough_vertex_shader(ctx->st, GL_FALSE);
+      stvp = st_make_passthrough_vertex_shader(st, GL_FALSE);
    }
    else {
       assert(type == GL_DEPTH);
       rbRead = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);
       color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
-      stfp = make_fragment_shader_z(ctx->st);
-      stvp = st_make_passthrough_vertex_shader(ctx->st, GL_TRUE);
+      stfp = make_fragment_shader_z(st);
+      stvp = st_make_passthrough_vertex_shader(st, GL_TRUE);
    }
 
    srcFormat = rbRead->texture->format;
@@ -1059,7 +1059,7 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
       assert(pth <= maxSize);
    }
 
-   pt = st_texture_create(ctx->st, PIPE_TEXTURE_2D, texFormat, 0,
+   pt = st_texture_create(st, PIPE_TEXTURE_2D, texFormat, 0,
                           ptw, pth, 1,
                           PIPE_TEXTURE_USAGE_SAMPLER);
    if (!pt)
diff --git a/src/mesa/state_tracker/st_cb_fbo.c b/src/mesa/state_tracker/st_cb_fbo.c
index a96602878e..fe0a121493 100644
--- a/src/mesa/state_tracker/st_cb_fbo.c
+++ b/src/mesa/state_tracker/st_cb_fbo.c
@@ -258,6 +258,7 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)
    strb->Base.ClassID = 0x4242; /* just a unique value */
    strb->Base.NumSamples = samples;
    strb->format = format;
+   init_renderbuffer_bits(strb, format);
    strb->software = sw;
    
    switch (format) {
diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c
index abaf9d2c35..3520c986b4 100644
--- a/src/mesa/state_tracker/st_cb_texture.c
+++ b/src/mesa/state_tracker/st_cb_texture.c
@@ -658,8 +658,10 @@ st_TexImage(GLcontext * ctx,
 					   format, type,
 					   pixels, unpack, "glTexImage");
    }
-   if (!pixels)
-      return;
+
+   /* Note: we can't check for pixels==NULL until after we've allocated
+    * memory for the texture.
+    */
 
    /* See if we can do texture compression with a blit/render.
     */
@@ -670,6 +672,9 @@ st_TexImage(GLcontext * ctx,
                                    stImage->pt->format,
                                    stImage->pt->target,
                                    PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
+      if (!pixels)
+         goto done;
+
       if (compress_with_blit(ctx, target, level, 0, 0, 0, width, height, depth,
                              format, type, pixels, unpack, texImage)) {
          goto done;
@@ -711,6 +716,9 @@ st_TexImage(GLcontext * ctx,
       return;
    }
 
+   if (!pixels)
+      goto done;
+
    DBG("Upload image %dx%dx%d row_len %x pitch %x\n",
        width, height, depth, width * texelBytes, dstRowStride);
 
@@ -753,17 +761,13 @@ st_TexImage(GLcontext * ctx,
       }
    }
 
+done:
    _mesa_unmap_teximage_pbo(ctx, unpack);
 
-done:
    if (stImage->pt && texImage->Data) {
       st_texture_image_unmap(ctx->st, stImage);
       texImage->Data = NULL;
    }
-
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
 }
 
 
@@ -1096,7 +1100,7 @@ st_TexSubimage(GLcontext *ctx, GLint dims, GLenum target, GLint level,
 
    if (!texImage->Data) {
       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
-      return;
+      goto done;
    }
 
    src = (const GLubyte *) pixels;
@@ -1127,17 +1131,13 @@ st_TexSubimage(GLcontext *ctx, GLint dims, GLenum target, GLint level,
       }
    }
 
+done:
    _mesa_unmap_teximage_pbo(ctx, packing);
 
-done:
    if (stImage->pt) {
       st_texture_image_unmap(ctx->st, stImage);
       texImage->Data = NULL;
    }
-
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
 }
 
 
@@ -1601,10 +1601,6 @@ st_copy_texsubimage(GLcontext *ctx,
                                 destX, destY, destZ,
                                 srcX, srcY, width, height);
    }
-
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
 }
 
 
diff --git a/src/mesa/state_tracker/st_framebuffer.c b/src/mesa/state_tracker/st_framebuffer.c
index ca32b2e573..5c0d335d62 100644
--- a/src/mesa/state_tracker/st_framebuffer.c
+++ b/src/mesa/state_tracker/st_framebuffer.c
@@ -66,7 +66,7 @@ st_create_framebuffer( const __GLcontextModes *visual,
       else {
          /* Only allocate front buffer right now if we're single buffered.
           * If double-buffered, allocate front buffer on demand later.
-          * See check_create_front_buffers().
+          * See check_create_front_buffers() and st_set_framebuffer_surface().
           */
          struct gl_renderbuffer *rb
             = st_new_renderbuffer_fb(colorFormat, samples, FALSE);
@@ -170,8 +170,20 @@ st_set_framebuffer_surface(struct st_framebuffer *stfb,
 
    strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
 
-   /* fail */
-   if (!strb) return;
+   if (!strb) {
+      if (surfIndex == ST_SURFACE_FRONT_LEFT) {
+         /* Delayed creation when the window system supplies a fake front buffer */
+         struct st_renderbuffer *strb_back
+            = st_renderbuffer(stfb->Base.Attachment[ST_SURFACE_BACK_LEFT].Renderbuffer);
+         struct gl_renderbuffer *rb
+            = st_new_renderbuffer_fb(surf->format, strb_back->Base.NumSamples, FALSE);
+         _mesa_add_renderbuffer(&stfb->Base, BUFFER_FRONT_LEFT, rb);
+         strb = st_renderbuffer(rb);
+      } else {
+         /* fail */
+         return;
+      }
+   }
 
    /* replace the renderbuffer's surface/texture pointers */
    pipe_surface_reference( &strb->surface, surf );
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.c b/src/mesa/state_tracker/st_mesa_to_tgsi.c
index 2ab12d3cf3..04be57f8ff 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.c
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.c
@@ -27,836 +27,648 @@
 
 /*
  * \author
- * Michal Krol
+ * Michal Krol,
+ * Keith Whitwell
  */
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_shader_tokens.h"
-#include "tgsi/tgsi_parse.h"
-#include "tgsi/tgsi_build.h"
-#include "tgsi/tgsi_util.h"
-#include "tgsi/tgsi_dump.h"
-#include "tgsi/tgsi_sanity.h"
+#include "pipe/p_state.h"
+#include "tgsi/tgsi_ureg.h"
 #include "st_mesa_to_tgsi.h"
 #include "shader/prog_instruction.h"
 #include "shader/prog_parameter.h"
 #include "shader/prog_print.h"
 #include "util/u_debug.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+
+struct label {
+   unsigned branch_target;
+   unsigned token;
+};
+
+struct st_translate {
+   struct ureg_program *ureg;
+
+   struct ureg_dst temps[MAX_PROGRAM_TEMPS];
+   struct ureg_src *constants;
+   struct ureg_dst outputs[PIPE_MAX_SHADER_OUTPUTS];
+   struct ureg_src inputs[PIPE_MAX_SHADER_INPUTS];
+   struct ureg_dst address[1];
+   struct ureg_src samplers[PIPE_MAX_SAMPLERS];
+
+   const GLuint *inputMapping;
+   const GLuint *outputMapping;
+
+   /* For every instruction that contains a label (eg CALL), keep
+    * details so that we can go back afterwards and emit the correct
+    * tgsi instruction number for each label.
+    */
+   struct label *labels;
+   unsigned labels_size;
+   unsigned labels_count;
+
+   /* Keep a record of the tgsi instruction number that each mesa
+    * instruction starts at, will be used to fix up labels after
+    * translation.
+    */
+   unsigned *insn;
+   unsigned insn_size;
+   unsigned insn_count;
+
+   unsigned procType;  /**< TGSI_PROCESSOR_VERTEX/FRAGMENT */
+
+   boolean error;
+};
+
+
+static unsigned *get_label( struct st_translate *t,
+                            unsigned branch_target )
+{
+   unsigned i;
+
+   if (t->labels_count + 1 >= t->labels_size) {
+      unsigned old_size = t->labels_size;
+      t->labels_size = 1 << (util_logbase2(t->labels_size) + 1);
+      t->labels = REALLOC( t->labels, 
+                           old_size * sizeof t->labels[0], 
+                           t->labels_size * sizeof t->labels[0] );
+      if (t->labels == NULL) {
+         static unsigned dummy;
+         t->error = TRUE;
+         return &dummy;
+      }
+   }
+
+   i = t->labels_count++;
+   t->labels[i].branch_target = branch_target;
+   return &t->labels[i].token;
+}
+
+
+static void set_insn_start( struct st_translate *t,
+                            unsigned start )
+{
+   if (t->insn_count + 1 >= t->insn_size) {
+      unsigned old_size = t->insn_size;
+      t->insn_size = 1 << (util_logbase2(t->insn_size) + 1);
+      t->insn = REALLOC( t->insn, 
+                         old_size * sizeof t->insn[0], 
+                         t->insn_size * sizeof t->insn[0] );
+      if (t->insn == NULL) {
+         t->error = TRUE;
+         return;
+      }
+   }
+
+   t->insn[t->insn_count++] = start;
+}
+
 
 /*
  * Map mesa register file to TGSI register file.
  */
-static GLuint
-map_register_file(
-   gl_register_file file,
-   GLuint index,
-   const GLuint immediateMapping[],
-   GLboolean indirectAccess )
+static struct ureg_dst
+dst_register( struct st_translate *t,
+              gl_register_file file,
+              GLuint index )
 {
    switch( file ) {
    case PROGRAM_UNDEFINED:
-      return TGSI_FILE_NULL;
+      return ureg_dst_undef();
+
    case PROGRAM_TEMPORARY:
-      return TGSI_FILE_TEMPORARY;
-   /*case PROGRAM_LOCAL_PARAM:*/
-   /*case PROGRAM_ENV_PARAM:*/
-
-      /* Because of the longstanding problem with mesa arb shaders
-       * where constants, immediates and state variables are all
-       * bundled together as PROGRAM_STATE_VAR, we can't tell from the
-       * mesa register file whether this is a CONSTANT or an
-       * IMMEDIATE, hence we need all the other information.
-       */
-   case PROGRAM_STATE_VAR:
-   case PROGRAM_NAMED_PARAM:
-   case PROGRAM_UNIFORM:
-      if (!indirectAccess && immediateMapping && immediateMapping[index] != ~0)
-         return TGSI_FILE_IMMEDIATE;
-      else
-	 return TGSI_FILE_CONSTANT;
-   case PROGRAM_CONSTANT:
-      if (indirectAccess)
-         return TGSI_FILE_CONSTANT;
-      assert(immediateMapping[index] != ~0);
-      return TGSI_FILE_IMMEDIATE;
-   case PROGRAM_INPUT:
-      return TGSI_FILE_INPUT;
+      if (ureg_dst_is_undef(t->temps[index]))
+         t->temps[index] = ureg_DECL_temporary( t->ureg );
+
+      return t->temps[index];
+
    case PROGRAM_OUTPUT:
-      return TGSI_FILE_OUTPUT;
+      return t->outputs[t->outputMapping[index]];
+
    case PROGRAM_ADDRESS:
-      return TGSI_FILE_ADDRESS;
+      return t->address[index];
+
    default:
       assert( 0 );
-      return TGSI_FILE_NULL;
+      return ureg_dst_undef();
    }
 }
 
-/**
- * Map mesa register file index to TGSI index.
- * Take special care when processing input and output indices.
- * \param file  one of TGSI_FILE_x
- * \param index  the mesa register file index
- * \param inputMapping  maps Mesa input indexes to TGSI input indexes
- * \param outputMapping  maps Mesa output indexes to TGSI output indexes
- */
-static GLuint
-map_register_file_index(
-   GLuint procType,
-   GLuint file,
-   GLuint index,
-   GLuint *swizzle,
-   const GLuint inputMapping[],
-   const GLuint outputMapping[],
-   const GLuint immediateMapping[],
-   GLboolean indirectAccess )
+
+static struct ureg_src
+src_register( struct st_translate *t,
+              gl_register_file file,
+              GLuint index )
 {
    switch( file ) {
-   case TGSI_FILE_INPUT:
-      /* inputs are mapped according to the user-defined map */
-      return inputMapping[index];
+   case PROGRAM_UNDEFINED:
+      return ureg_src_undef();
+
+   case PROGRAM_TEMPORARY:
+      if (ureg_dst_is_undef(t->temps[index]))
+         t->temps[index] = ureg_DECL_temporary( t->ureg );
+      return ureg_src(t->temps[index]);
 
-   case TGSI_FILE_OUTPUT:
-      return outputMapping[index];
+   case PROGRAM_STATE_VAR:
+   case PROGRAM_NAMED_PARAM:
+   case PROGRAM_UNIFORM:
+   case PROGRAM_CONSTANT:
+      return t->constants[index];
 
-   case TGSI_FILE_IMMEDIATE:
-      if (indirectAccess)
-         return index;
-      assert(immediateMapping[index] != ~0);
-      return immediateMapping[index];
+   case PROGRAM_INPUT:
+      return t->inputs[t->inputMapping[index]];
+
+   case PROGRAM_OUTPUT:
+      return ureg_src(t->outputs[t->outputMapping[index]]); /* not needed? */
+
+   case PROGRAM_ADDRESS:
+      return ureg_src(t->address[index]);
 
    default:
-      return index;
+      assert( 0 );
+      return ureg_src_undef();
    }
 }
 
-/*
+
+/**
  * Map mesa texture target to TGSI texture target.
  */
-static GLuint
-map_texture_target(
-    GLuint textarget,
-    GLboolean shadow )
+static unsigned
+translate_texture_target( GLuint textarget,
+                          GLboolean shadow )
 {
-   switch( textarget ) {
-   case TEXTURE_1D_INDEX:
-      if (shadow)
-         return TGSI_TEXTURE_SHADOW1D;
-      else
-         return TGSI_TEXTURE_1D;
-   case TEXTURE_2D_INDEX:
-      if (shadow)
-         return TGSI_TEXTURE_SHADOW2D;
-      else
-         return TGSI_TEXTURE_2D;
-   case TEXTURE_3D_INDEX:
-      return TGSI_TEXTURE_3D;
-   case TEXTURE_CUBE_INDEX:
-      return TGSI_TEXTURE_CUBE;
-   case TEXTURE_RECT_INDEX:
-      if (shadow)
-         return TGSI_TEXTURE_SHADOWRECT;
-      else
-         return TGSI_TEXTURE_RECT;
-   default:
-      assert( 0 );
+   if (shadow) {
+      switch( textarget ) {
+      case TEXTURE_1D_INDEX:   return TGSI_TEXTURE_SHADOW1D;
+      case TEXTURE_2D_INDEX:   return TGSI_TEXTURE_SHADOW2D;
+      case TEXTURE_RECT_INDEX: return TGSI_TEXTURE_SHADOWRECT;
+      default: break;
+      }
    }
 
-   return TGSI_TEXTURE_1D;
-}
-
-static GLuint
-convert_sat(
-   GLuint sat )
-{
-   switch( sat ) {
-   case SATURATE_OFF:
-      return TGSI_SAT_NONE;
-   case SATURATE_ZERO_ONE:
-      return TGSI_SAT_ZERO_ONE;
-   case SATURATE_PLUS_MINUS_ONE:
-      return TGSI_SAT_MINUS_PLUS_ONE;
+   switch( textarget ) {
+   case TEXTURE_1D_INDEX:   return TGSI_TEXTURE_1D;
+   case TEXTURE_2D_INDEX:   return TGSI_TEXTURE_2D;
+   case TEXTURE_3D_INDEX:   return TGSI_TEXTURE_3D;
+   case TEXTURE_CUBE_INDEX: return TGSI_TEXTURE_CUBE;
+   case TEXTURE_RECT_INDEX: return TGSI_TEXTURE_RECT;
    default:
       assert( 0 );
-      return TGSI_SAT_NONE;
+      return TGSI_TEXTURE_1D;
    }
 }
 
-static GLuint
-convert_writemask(
-   GLuint writemask )
+
+static struct ureg_dst
+translate_dst( struct st_translate *t,
+               const struct prog_dst_register *DstReg,
+               boolean saturate )
 {
-   assert( WRITEMASK_X == TGSI_WRITEMASK_X );
-   assert( WRITEMASK_Y == TGSI_WRITEMASK_Y );
-   assert( WRITEMASK_Z == TGSI_WRITEMASK_Z );
-   assert( WRITEMASK_W == TGSI_WRITEMASK_W );
-   assert( (writemask & ~TGSI_WRITEMASK_XYZW) == 0 );
+   struct ureg_dst dst = dst_register( t, 
+                                       DstReg->File,
+                                       DstReg->Index );
+
+   dst = ureg_writemask( dst, 
+                         DstReg->WriteMask );
+   
+   if (saturate)
+      dst = ureg_saturate( dst );
+
+   if (DstReg->RelAddr)
+      dst = ureg_dst_indirect( dst, ureg_src(t->address[0]) );
 
-   return writemask;
+   return dst;
 }
 
-static struct tgsi_full_immediate
-make_immediate(const float *value, uint size)
+
+static struct ureg_src
+translate_src( struct st_translate *t,
+               const struct prog_src_register *SrcReg )
 {
-   struct tgsi_full_immediate imm;
-   unsigned i;
+   struct ureg_src src = src_register( t, SrcReg->File, SrcReg->Index );
 
-   imm = tgsi_default_full_immediate();
-   imm.Immediate.NrTokens += size;
-   imm.Immediate.DataType = TGSI_IMM_FLOAT32;
+   src = ureg_swizzle( src,
+                       GET_SWZ( SrcReg->Swizzle, 0 ) & 0x3,
+                       GET_SWZ( SrcReg->Swizzle, 1 ) & 0x3,
+                       GET_SWZ( SrcReg->Swizzle, 2 ) & 0x3,
+                       GET_SWZ( SrcReg->Swizzle, 3 ) & 0x3);
 
-   for (i = 0; i < size; i++)
-      imm.u[i].Float = value[i];
+   if (SrcReg->Negate == NEGATE_XYZW)
+      src = ureg_negate(src);
 
-   return imm;
+   if (SrcReg->Abs) 
+      src = ureg_abs(src);
+
+   if (SrcReg->RelAddr) 
+      src = ureg_src_indirect( src, ureg_src(t->address[0]));
+   
+   return src;
 }
 
-static void
-compile_instruction(
-   const struct prog_instruction *inst,
-   struct tgsi_full_instruction *fullinst,
-   const GLuint inputMapping[],
-   const GLuint outputMapping[],
-   const GLuint immediateMapping[],
-   GLboolean indirectAccess,
-   GLuint preamble_size,
-   GLuint procType,
-   GLboolean *insideSubroutine,
-   GLint wposTemp)
+
+static struct ureg_src swizzle_4v( struct ureg_src src,
+                                   const unsigned *swz )
 {
-   GLuint i;
-   struct tgsi_full_dst_register *fulldst;
-   struct tgsi_full_src_register *fullsrc;
-
-   *fullinst = tgsi_default_full_instruction();
-
-   fullinst->Instruction.Saturate = convert_sat( inst->SaturateMode );
-   fullinst->Instruction.NumDstRegs = _mesa_num_inst_dst_regs( inst->Opcode );
-   fullinst->Instruction.NumSrcRegs = _mesa_num_inst_src_regs( inst->Opcode );
-
-   fulldst = &fullinst->FullDstRegisters[0];
-   fulldst->DstRegister.File = map_register_file( inst->DstReg.File, 0, NULL, GL_FALSE );
-   fulldst->DstRegister.Index = map_register_file_index(
-      procType,
-      fulldst->DstRegister.File,
-      inst->DstReg.Index,
-      NULL,
-      inputMapping,
-      outputMapping,
-      NULL,
-      GL_FALSE );
-   fulldst->DstRegister.WriteMask = convert_writemask( inst->DstReg.WriteMask );
-   if (inst->DstReg.RelAddr) {
-      fulldst->DstRegister.Indirect = 1;
-      fulldst->DstRegisterInd.File = TGSI_FILE_ADDRESS;
-      fulldst->DstRegisterInd.Index = 0;
+   return ureg_swizzle( src, swz[0], swz[1], swz[2], swz[3] );
+}
+
+
+/**
+ * Translate SWZ instructions into a single MAD.  EG:
+ *
+ *   SWZ dst, src.x-y10 
+ * 
+ * becomes:
+ *
+ *   MAD dst {1,-1,0,0}, src.xyxx, {0,0,1,0}
+ */
+static void emit_swz( struct st_translate *t,
+                      struct ureg_dst dst,
+                      const struct prog_src_register *SrcReg )
+{
+   struct ureg_program *ureg = t->ureg;
+   struct ureg_src src = src_register( t, SrcReg->File, SrcReg->Index );
+
+   unsigned negate_mask =  SrcReg->Negate;
+
+   unsigned one_mask = ((GET_SWZ(SrcReg->Swizzle, 0) == SWIZZLE_ONE) << 0 |
+                        (GET_SWZ(SrcReg->Swizzle, 1) == SWIZZLE_ONE) << 1 |
+                        (GET_SWZ(SrcReg->Swizzle, 2) == SWIZZLE_ONE) << 2 |
+                        (GET_SWZ(SrcReg->Swizzle, 3) == SWIZZLE_ONE) << 3);
+
+   unsigned zero_mask = ((GET_SWZ(SrcReg->Swizzle, 0) == SWIZZLE_ZERO) << 0 |
+                         (GET_SWZ(SrcReg->Swizzle, 1) == SWIZZLE_ZERO) << 1 |
+                         (GET_SWZ(SrcReg->Swizzle, 2) == SWIZZLE_ZERO) << 2 |
+                         (GET_SWZ(SrcReg->Swizzle, 3) == SWIZZLE_ZERO) << 3);
+
+   unsigned negative_one_mask = one_mask & negate_mask;
+   unsigned positive_one_mask = one_mask & ~negate_mask;
+   
+   struct ureg_src imm;
+   unsigned i;
+   unsigned mul_swizzle[4] = {0,0,0,0};
+   unsigned add_swizzle[4] = {0,0,0,0};
+   unsigned src_swizzle[4] = {0,0,0,0};
+   boolean need_add = FALSE;
+   boolean need_mul = FALSE;
+
+   if (dst.WriteMask == 0)
+      return;
+
+   /* Is this just a MOV?
+    */
+   if (zero_mask == 0 &&
+       one_mask == 0 &&
+       (negate_mask == 0 || negate_mask == TGSI_WRITEMASK_XYZW)) 
+   {
+      ureg_MOV( ureg, dst, translate_src( t, SrcReg ));
+      return;
    }
 
-   for (i = 0; i < fullinst->Instruction.NumSrcRegs; i++) {
-      GLuint j;
-      GLuint swizzle = inst->SrcReg[i].Swizzle;
+#define IMM_ZERO    0
+#define IMM_ONE     1
+#define IMM_NEG_ONE 2
 
-      fullsrc = &fullinst->FullSrcRegisters[i];
+   imm = ureg_imm3f( ureg, 0, 1, -1 );
 
-      if (procType == TGSI_PROCESSOR_FRAGMENT &&
-          inst->SrcReg[i].File == PROGRAM_INPUT &&
-          inst->SrcReg[i].Index == FRAG_ATTRIB_WPOS) {
-         /* special case of INPUT[WPOS] */
-         fullsrc->SrcRegister.File = TGSI_FILE_TEMPORARY;
-         fullsrc->SrcRegister.Index = wposTemp;
-      }
-      else {
-         /* any other src register */
-         fullsrc->SrcRegister.File = map_register_file(
-            inst->SrcReg[i].File,
-            inst->SrcReg[i].Index,
-            immediateMapping,
-            indirectAccess );
-         fullsrc->SrcRegister.Index = map_register_file_index(
-            procType,
-            fullsrc->SrcRegister.File,
-            inst->SrcReg[i].Index,
-            &swizzle,
-            inputMapping,
-            outputMapping,
-            immediateMapping,
-            indirectAccess );
-      }
+   for (i = 0; i < 4; i++) {
+      unsigned bit = 1 << i;
 
-      /* swizzle (ext swizzle also depends on negation) */
-      {
-         GLuint swz[4];
-         GLboolean extended = (inst->SrcReg[i].Negate != NEGATE_NONE &&
-                               inst->SrcReg[i].Negate != NEGATE_XYZW);
-         for( j = 0; j < 4; j++ ) {
-            swz[j] = GET_SWZ( swizzle, j );
-            if (swz[j] > SWIZZLE_W)
-               extended = GL_TRUE;
+      if (dst.WriteMask & bit) {
+         if (positive_one_mask & bit) {
+            mul_swizzle[i] = IMM_ZERO;
+            add_swizzle[i] = IMM_ONE;
+            need_add = TRUE;
          }
-         if (extended) {
-            for (j = 0; j < 4; j++) {
-               tgsi_util_set_src_register_extswizzle(&fullsrc->SrcRegisterExtSwz,
-                                                     swz[j], j);
-            }
+         else if (negative_one_mask & bit) {
+            mul_swizzle[i] = IMM_ZERO;
+            add_swizzle[i] = IMM_NEG_ONE;
+            need_add = TRUE;
+         }
+         else if (zero_mask & bit) {
+            mul_swizzle[i] = IMM_ZERO;
+            add_swizzle[i] = IMM_ZERO;
+            need_add = TRUE;
          }
          else {
-            for (j = 0; j < 4; j++) {
-               tgsi_util_set_src_register_swizzle(&fullsrc->SrcRegister,
-                                                  swz[j], j);
+            add_swizzle[i] = IMM_ZERO;
+            src_swizzle[i] = GET_SWZ(SrcReg->Swizzle, i);
+            need_mul = TRUE;
+            if (negate_mask & bit) {
+               mul_swizzle[i] = IMM_NEG_ONE;
+            }
+            else {
+               mul_swizzle[i] = IMM_ONE;
             }
          }
       }
+   }
 
-      if( inst->SrcReg[i].Negate == NEGATE_XYZW ) {
-         fullsrc->SrcRegister.Negate = 1;
-      }
-      else if( inst->SrcReg[i].Negate != NEGATE_NONE ) {
-         if( inst->SrcReg[i].Negate & NEGATE_X ) {
-            fullsrc->SrcRegisterExtSwz.NegateX = 1;
-         }
-         if( inst->SrcReg[i].Negate & NEGATE_Y ) {
-            fullsrc->SrcRegisterExtSwz.NegateY = 1;
-         }
-         if( inst->SrcReg[i].Negate & NEGATE_Z ) {
-            fullsrc->SrcRegisterExtSwz.NegateZ = 1;
-         }
-         if( inst->SrcReg[i].Negate & NEGATE_W ) {
-            fullsrc->SrcRegisterExtSwz.NegateW = 1;
-         }
-      }
+   if (need_mul && need_add) {
+      ureg_MAD( ureg, 
+                dst,
+                swizzle_4v( src, src_swizzle ),
+                swizzle_4v( imm, mul_swizzle ),
+                swizzle_4v( imm, add_swizzle ) );
+   }
+   else if (need_mul) {
+      ureg_MUL( ureg, 
+                dst,
+                swizzle_4v( src, src_swizzle ),
+                swizzle_4v( imm, mul_swizzle ) );
+   }
+   else if (need_add) {
+      ureg_MOV( ureg, 
+                dst,
+                swizzle_4v( imm, add_swizzle ) );
+   }
+   else {
+      assert(0);
+   }
 
-      if( inst->SrcReg[i].Abs ) {
-         fullsrc->SrcRegisterExtMod.Absolute = 1;
-      }
+#undef IMM_ZERO
+#undef IMM_ONE
+#undef IMM_NEG_ONE
+}
 
-      if( inst->SrcReg[i].RelAddr ) {
-         fullsrc->SrcRegister.Indirect = 1;
 
-         fullsrc->SrcRegisterInd.File = TGSI_FILE_ADDRESS;
-         fullsrc->SrcRegisterInd.Index = 0;
-      }
-   }
 
-   switch( inst->Opcode ) {
+static unsigned
+translate_opcode( unsigned op )
+{
+   switch( op ) {
    case OPCODE_ARL:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_ARL;
-      break;
+      return TGSI_OPCODE_ARL;
    case OPCODE_ABS:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_ABS;
-      break;
+      return TGSI_OPCODE_ABS;
    case OPCODE_ADD:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_ADD;
-      break;
+      return TGSI_OPCODE_ADD;
    case OPCODE_BGNLOOP:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_BGNLOOP;
-      fullinst->InstructionExtLabel.Label = inst->BranchTarget + preamble_size;
-      break;
+      return TGSI_OPCODE_BGNLOOP;
    case OPCODE_BGNSUB:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_BGNSUB;
-      *insideSubroutine = GL_TRUE;
-      break;
+      return TGSI_OPCODE_BGNSUB;
    case OPCODE_BRA:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_BRA;
-      break;
+      return TGSI_OPCODE_BRA;
    case OPCODE_BRK:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_BRK;
-      break;
+      return TGSI_OPCODE_BRK;
    case OPCODE_CAL:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_CAL;
-      fullinst->InstructionExtLabel.Label = inst->BranchTarget + preamble_size;
-      break;
+      return TGSI_OPCODE_CAL;
    case OPCODE_CMP:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_CMP;
-      break;
+      return TGSI_OPCODE_CMP;
    case OPCODE_CONT:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_CONT;
-      break;
+      return TGSI_OPCODE_CONT;
    case OPCODE_COS:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_COS;
-      break;
+      return TGSI_OPCODE_COS;
    case OPCODE_DDX:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_DDX;
-      break;
+      return TGSI_OPCODE_DDX;
    case OPCODE_DDY:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_DDY;
-      break;
+      return TGSI_OPCODE_DDY;
    case OPCODE_DP2:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_DP2;
-      break;
+      return TGSI_OPCODE_DP2;
    case OPCODE_DP2A:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_DP2A;
-      break;
+      return TGSI_OPCODE_DP2A;
    case OPCODE_DP3:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_DP3;
-      break;
+      return TGSI_OPCODE_DP3;
    case OPCODE_DP4:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_DP4;
-      break;
+      return TGSI_OPCODE_DP4;
    case OPCODE_DPH:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_DPH;
-      break;
+      return TGSI_OPCODE_DPH;
    case OPCODE_DST:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_DST;
-      break;
+      return TGSI_OPCODE_DST;
    case OPCODE_ELSE:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_ELSE;
-      fullinst->InstructionExtLabel.Label = inst->BranchTarget + preamble_size;
-      break;
+      return TGSI_OPCODE_ELSE;
    case OPCODE_ENDIF:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_ENDIF;
-      break;
+      return TGSI_OPCODE_ENDIF;
    case OPCODE_ENDLOOP:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_ENDLOOP;
-      fullinst->InstructionExtLabel.Label = inst->BranchTarget + preamble_size;
-      break;
+      return TGSI_OPCODE_ENDLOOP;
    case OPCODE_ENDSUB:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_ENDSUB;
-      *insideSubroutine = GL_FALSE;
-      break;
+      return TGSI_OPCODE_ENDSUB;
    case OPCODE_EX2:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_EX2;
-      break;
+      return TGSI_OPCODE_EX2;
    case OPCODE_EXP:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_EXP;
-      break;
+      return TGSI_OPCODE_EXP;
    case OPCODE_FLR:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_FLR;
-      break;
+      return TGSI_OPCODE_FLR;
    case OPCODE_FRC:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_FRC;
-      break;
+      return TGSI_OPCODE_FRC;
    case OPCODE_IF:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_IF;
-      fullinst->InstructionExtLabel.Label = inst->BranchTarget + preamble_size;
-      break;
+      return TGSI_OPCODE_IF;
    case OPCODE_TRUNC:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_TRUNC;
-      break;
+      return TGSI_OPCODE_TRUNC;
    case OPCODE_KIL:
-      /* conditional */
-      fullinst->Instruction.Opcode = TGSI_OPCODE_KIL;
-      break;
+      return TGSI_OPCODE_KIL;
    case OPCODE_KIL_NV:
-      /* predicated */
-      assert(inst->DstReg.CondMask == COND_TR);
-      fullinst->Instruction.Opcode = TGSI_OPCODE_KILP;
-      break;
+      return TGSI_OPCODE_KILP;
    case OPCODE_LG2:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_LG2;
-      break;
+      return TGSI_OPCODE_LG2;
    case OPCODE_LOG:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_LOG;
-      break;
+      return TGSI_OPCODE_LOG;
    case OPCODE_LIT:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_LIT;
-      break;
+      return TGSI_OPCODE_LIT;
    case OPCODE_LRP:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_LRP;
-      break;
+      return TGSI_OPCODE_LRP;
    case OPCODE_MAD:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_MAD;
-      break;
+      return TGSI_OPCODE_MAD;
    case OPCODE_MAX:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_MAX;
-      break;
+      return TGSI_OPCODE_MAX;
    case OPCODE_MIN:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_MIN;
-      break;
+      return TGSI_OPCODE_MIN;
    case OPCODE_MOV:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_MOV;
-      break;
+      return TGSI_OPCODE_MOV;
    case OPCODE_MUL:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_MUL;
-      break;
+      return TGSI_OPCODE_MUL;
    case OPCODE_NOISE1:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_NOISE1;
-      break;
+      return TGSI_OPCODE_NOISE1;
    case OPCODE_NOISE2:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_NOISE2;
-      break;
+      return TGSI_OPCODE_NOISE2;
    case OPCODE_NOISE3:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_NOISE3;
-      break;
+      return TGSI_OPCODE_NOISE3;
    case OPCODE_NOISE4:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_NOISE4;
-      break;
+      return TGSI_OPCODE_NOISE4;
    case OPCODE_NOP:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_NOP;
-      break;
+      return TGSI_OPCODE_NOP;
    case OPCODE_NRM3:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_NRM;
-      break;
+      return TGSI_OPCODE_NRM;
    case OPCODE_NRM4:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_NRM4;
-      break;
+      return TGSI_OPCODE_NRM4;
    case OPCODE_POW:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_POW;
-      break;
+      return TGSI_OPCODE_POW;
    case OPCODE_RCP:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_RCP;
-      break;
+      return TGSI_OPCODE_RCP;
    case OPCODE_RET:
-      /* If RET is used inside main (not a real subroutine) we may want
-       * to execute END instead of RET.  TBD...
-       */
-      if (1 /*  *insideSubroutine */) {
-         fullinst->Instruction.Opcode = TGSI_OPCODE_RET;
-      }
-      else {
-         /* inside main() pseudo-function */
-         fullinst->Instruction.Opcode = TGSI_OPCODE_END;
-      }
-      break;
+      return TGSI_OPCODE_RET;
    case OPCODE_RSQ:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_RSQ;
-      break;
+      return TGSI_OPCODE_RSQ;
    case OPCODE_SCS:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SCS;
-      fulldst->DstRegister.WriteMask &= TGSI_WRITEMASK_XY;
-      break;
+      return TGSI_OPCODE_SCS;
    case OPCODE_SEQ:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SEQ;
-      break;
+      return TGSI_OPCODE_SEQ;
    case OPCODE_SGE:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SGE;
-      break;
+      return TGSI_OPCODE_SGE;
    case OPCODE_SGT:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SGT;
-      break;
+      return TGSI_OPCODE_SGT;
    case OPCODE_SIN:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SIN;
-      break;
+      return TGSI_OPCODE_SIN;
    case OPCODE_SLE:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SLE;
-      break;
+      return TGSI_OPCODE_SLE;
    case OPCODE_SLT:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SLT;
-      break;
+      return TGSI_OPCODE_SLT;
    case OPCODE_SNE:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SNE;
-      break;
+      return TGSI_OPCODE_SNE;
    case OPCODE_SSG:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SSG;
-      break;
+      return TGSI_OPCODE_SSG;
    case OPCODE_SUB:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SUB;
-      break;
+      return TGSI_OPCODE_SUB;
    case OPCODE_SWZ:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_SWZ;
-      break;
+      return TGSI_OPCODE_SWZ;
    case OPCODE_TEX:
-      /* ordinary texture lookup */
-      fullinst->Instruction.Opcode = TGSI_OPCODE_TEX;
-      fullinst->Instruction.NumSrcRegs = 2;
-      fullinst->InstructionExtTexture.Texture =
-         map_texture_target( inst->TexSrcTarget, inst->TexShadow );
-      fullinst->FullSrcRegisters[1].SrcRegister.File = TGSI_FILE_SAMPLER;
-      fullinst->FullSrcRegisters[1].SrcRegister.Index = inst->TexSrcUnit;
-      break;
+      return TGSI_OPCODE_TEX;
    case OPCODE_TXB:
-      /* texture lookup with LOD bias */
-      fullinst->Instruction.Opcode = TGSI_OPCODE_TXB;
-      fullinst->Instruction.NumSrcRegs = 2;
-      fullinst->InstructionExtTexture.Texture =
-         map_texture_target( inst->TexSrcTarget, inst->TexShadow );
-      fullinst->FullSrcRegisters[1].SrcRegister.File = TGSI_FILE_SAMPLER;
-      fullinst->FullSrcRegisters[1].SrcRegister.Index = inst->TexSrcUnit;
-      break;
+      return TGSI_OPCODE_TXB;
    case OPCODE_TXD:
-      /* texture lookup with explicit partial derivatives */
-      fullinst->Instruction.Opcode = TGSI_OPCODE_TXD;
-      fullinst->Instruction.NumSrcRegs = 4;
-      fullinst->InstructionExtTexture.Texture =
-         map_texture_target( inst->TexSrcTarget, inst->TexShadow );
-      /* src[0] = coord, src[1] = d[strq]/dx, src[2] = d[strq]/dy */
-      fullinst->FullSrcRegisters[3].SrcRegister.File = TGSI_FILE_SAMPLER;
-      fullinst->FullSrcRegisters[3].SrcRegister.Index = inst->TexSrcUnit;
-      break;
+      return TGSI_OPCODE_TXD;
    case OPCODE_TXL:
-      /* texture lookup with explicit LOD */
-      fullinst->Instruction.Opcode = TGSI_OPCODE_TXL;
-      fullinst->Instruction.NumSrcRegs = 2;
-      fullinst->InstructionExtTexture.Texture =
-         map_texture_target( inst->TexSrcTarget, inst->TexShadow );
-      fullinst->FullSrcRegisters[1].SrcRegister.File = TGSI_FILE_SAMPLER;
-      fullinst->FullSrcRegisters[1].SrcRegister.Index = inst->TexSrcUnit;
-      break;
+      return TGSI_OPCODE_TXL;
    case OPCODE_TXP:
-      /* texture lookup with divide by Q component */
-      /* convert to TEX w/ special flag for division */
-      fullinst->Instruction.Opcode = TGSI_OPCODE_TXP;
-      fullinst->Instruction.NumSrcRegs = 2;
-      fullinst->InstructionExtTexture.Texture =
-         map_texture_target( inst->TexSrcTarget, inst->TexShadow );
-      fullinst->FullSrcRegisters[1].SrcRegister.File = TGSI_FILE_SAMPLER;
-      fullinst->FullSrcRegisters[1].SrcRegister.Index = inst->TexSrcUnit;
-      break;
+      return TGSI_OPCODE_TXP;
    case OPCODE_XPD:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_XPD;
-      fulldst->DstRegister.WriteMask &= TGSI_WRITEMASK_XYZ;
-      break;
+      return TGSI_OPCODE_XPD;
    case OPCODE_END:
-      fullinst->Instruction.Opcode = TGSI_OPCODE_END;
-      break;
+      return TGSI_OPCODE_END;
    default:
       assert( 0 );
+      return TGSI_OPCODE_NOP;
    }
 }
 
-/**
- * \param usage_mask  bitfield of TGSI_WRITEMASK_{XYZW} tokens
- */
-static struct tgsi_full_declaration
-make_input_decl(
-   GLuint index,
-   GLboolean interpolate_info,
-   GLuint interpolate,
-   GLuint usage_mask,
-   GLboolean semantic_info,
-   GLuint semantic_name,
-   GLbitfield semantic_index,
-   GLbitfield input_flags)
-{
-   struct tgsi_full_declaration decl;
-
-   assert(semantic_name < TGSI_SEMANTIC_COUNT);
-
-   decl = tgsi_default_full_declaration();
-   decl.Declaration.File = TGSI_FILE_INPUT;
-   decl.Declaration.UsageMask = usage_mask;
-   decl.Declaration.Semantic = semantic_info;
-   decl.DeclarationRange.First = index;
-   decl.DeclarationRange.Last = index;
-   if (semantic_info) {
-      decl.Semantic.SemanticName = semantic_name;
-      decl.Semantic.SemanticIndex = semantic_index;
-   }
-   if (interpolate_info) {
-      decl.Declaration.Interpolate = interpolate;
-   }
-   if (input_flags & PROG_PARAM_BIT_CENTROID)
-      decl.Declaration.Centroid = 1;
-   if (input_flags & PROG_PARAM_BIT_INVARIANT)
-      decl.Declaration.Invariant = 1;
-
-   return decl;
-}
-
-/**
- * \param usage_mask  bitfield of TGSI_WRITEMASK_{XYZW} tokens
- */
-static struct tgsi_full_declaration
-make_output_decl(
-   GLuint index,
-   GLuint semantic_name,
-   GLuint semantic_index,
-   GLuint usage_mask,
-   GLbitfield output_flags)
-{
-   struct tgsi_full_declaration decl;
-
-   assert(semantic_name < TGSI_SEMANTIC_COUNT);
-
-   decl = tgsi_default_full_declaration();
-   decl.Declaration.File = TGSI_FILE_OUTPUT;
-   decl.Declaration.UsageMask = usage_mask;
-   decl.Declaration.Semantic = 1;
-   decl.DeclarationRange.First = index;
-   decl.DeclarationRange.Last = index;
-   decl.Semantic.SemanticName = semantic_name;
-   decl.Semantic.SemanticIndex = semantic_index;
-   if (output_flags & PROG_PARAM_BIT_CENTROID)
-      decl.Declaration.Centroid = 1;
-   if (output_flags & PROG_PARAM_BIT_INVARIANT)
-      decl.Declaration.Invariant = 1;
-
-   return decl;
-}
-
 
-static struct tgsi_full_declaration
-make_temp_decl(
-   GLuint start_index,
-   GLuint end_index )
+static void
+compile_instruction(
+   struct st_translate *t,
+   const struct prog_instruction *inst )
 {
-   struct tgsi_full_declaration decl;
-   decl = tgsi_default_full_declaration();
-   decl.Declaration.File = TGSI_FILE_TEMPORARY;
-   decl.DeclarationRange.First = start_index;
-   decl.DeclarationRange.Last = end_index;
-   return decl;
-}
+   struct ureg_program *ureg = t->ureg;
+   GLuint i;
+   struct ureg_dst dst[1];
+   struct ureg_src src[4];
+   unsigned num_dst;
+   unsigned num_src;
 
-static struct tgsi_full_declaration
-make_addr_decl(
-   GLuint start_index,
-   GLuint end_index )
-{
-   struct tgsi_full_declaration decl;
+   num_dst = _mesa_num_inst_dst_regs( inst->Opcode );
+   num_src = _mesa_num_inst_src_regs( inst->Opcode );
 
-   decl = tgsi_default_full_declaration();
-   decl.Declaration.File = TGSI_FILE_ADDRESS;
-   decl.DeclarationRange.First = start_index;
-   decl.DeclarationRange.Last = end_index;
-   return decl;
-}
+   if (num_dst) 
+      dst[0] = translate_dst( t, 
+                              &inst->DstReg,
+                              inst->SaturateMode );
 
-static struct tgsi_full_declaration
-make_sampler_decl(GLuint index)
-{
-   struct tgsi_full_declaration decl;
-   decl = tgsi_default_full_declaration();
-   decl.Declaration.File = TGSI_FILE_SAMPLER;
-   decl.DeclarationRange.First = index;
-   decl.DeclarationRange.Last = index;
-   return decl;
-}
+   for (i = 0; i < num_src; i++) 
+      src[i] = translate_src( t, &inst->SrcReg[i] );
 
-/** Reference into a constant buffer */
-static struct tgsi_full_declaration
-make_constant_decl(GLuint first, GLuint last)
-{
-   struct tgsi_full_declaration decl;
-   decl = tgsi_default_full_declaration();
-   decl.Declaration.File = TGSI_FILE_CONSTANT;
-   decl.DeclarationRange.First = first;
-   decl.DeclarationRange.Last = last;
-   return decl;
-}
+   switch( inst->Opcode ) {
+   case OPCODE_SWZ:
+      emit_swz( t, dst[0], &inst->SrcReg[0] );
+      return;
 
+   case OPCODE_BGNLOOP:
+   case OPCODE_CAL:
+   case OPCODE_ELSE:
+   case OPCODE_ENDLOOP:
+   case OPCODE_IF:
+      assert(num_dst == 0);
+      ureg_label_insn( ureg,
+                       translate_opcode( inst->Opcode ),
+                       src, num_src,
+                       get_label( t, inst->BranchTarget ));
+      return;
 
+   case OPCODE_TEX:
+   case OPCODE_TXB:
+   case OPCODE_TXD:
+   case OPCODE_TXL:
+   case OPCODE_TXP:
+      src[num_src++] = t->samplers[inst->TexSrcUnit];
+      ureg_tex_insn( ureg,
+                     translate_opcode( inst->Opcode ),
+                     dst, num_dst, 
+                     translate_texture_target( inst->TexSrcTarget,
+                                               inst->TexShadow ),
+                     src, num_src );
+      return;
 
-/**
- * Find the temporaries which are used in the given program.
- */
-static void
-find_temporaries(const struct gl_program *program,
-                 GLboolean tempsUsed[MAX_PROGRAM_TEMPS])
-{
-   GLuint i, j;
+   case OPCODE_SCS:
+      dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_XY );
+      ureg_insn( ureg, 
+                 translate_opcode( inst->Opcode ), 
+                 dst, num_dst, 
+                 src, num_src );
+      break;
 
-   for (i = 0; i < MAX_PROGRAM_TEMPS; i++)
-      tempsUsed[i] = GL_FALSE;
+   case OPCODE_XPD:
+      dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_XYZ );
+      ureg_insn( ureg, 
+                 translate_opcode( inst->Opcode ), 
+                 dst, num_dst, 
+                 src, num_src );
+      break;
 
-   for (i = 0; i < program->NumInstructions; i++) {
-      const struct prog_instruction *inst = program->Instructions + i;
-      const GLuint n = _mesa_num_inst_src_regs( inst->Opcode );
-      for (j = 0; j < n; j++) {
-         if (inst->SrcReg[j].File == PROGRAM_TEMPORARY)
-            tempsUsed[inst->SrcReg[j].Index] = GL_TRUE;
-         if (inst->DstReg.File == PROGRAM_TEMPORARY)
-            tempsUsed[inst->DstReg.Index] = GL_TRUE;
-      }
+   default:
+      ureg_insn( ureg, 
+                 translate_opcode( inst->Opcode ), 
+                 dst, num_dst, 
+                 src, num_src );
+      break;
    }
 }
 
 
 /**
- * Find an unused temporary in the tempsUsed array.
+ * Emit the TGSI instructions for inverting the WPOS y coordinate.
  */
-static int
-find_free_temporary(GLboolean tempsUsed[MAX_PROGRAM_TEMPS])
-{
-   int i;
-   for (i = 0; i < MAX_PROGRAM_TEMPS; i++) {
-      if (!tempsUsed[i]) {
-         tempsUsed[i] = GL_TRUE;
-         return i;
-      }
-   }
-   return -1;
-}
-
-
-/** helper for building simple TGSI instruction, one src register */
 static void
-build_tgsi_instruction1(struct tgsi_full_instruction *inst,
-                        int opcode,
-                        int dstFile, int dstIndex, int writemask,
-                        int srcFile1, int srcIndex1)
+emit_inverted_wpos( struct st_translate *t,
+                    const struct gl_program *program )
 {
-   *inst = tgsi_default_full_instruction();
-
-   inst->Instruction.Opcode = opcode;
-
-   inst->Instruction.NumDstRegs = 1;
-   inst->FullDstRegisters[0].DstRegister.File = dstFile;
-   inst->FullDstRegisters[0].DstRegister.Index = dstIndex;
-   inst->FullDstRegisters[0].DstRegister.WriteMask = writemask;
+   struct ureg_program *ureg = t->ureg;
 
-   inst->Instruction.NumSrcRegs = 1;
-   inst->FullSrcRegisters[0].SrcRegister.File = srcFile1;
-   inst->FullSrcRegisters[0].SrcRegister.Index = srcIndex1;
-}
-
-
-/** helper for building simple TGSI instruction, two src registers */
-static void
-build_tgsi_instruction2(struct tgsi_full_instruction *inst,
-                        int opcode,
-                        int dstFile, int dstIndex, int writemask,
-                        int srcFile1, int srcIndex1,
-                        int srcFile2, int srcIndex2)
-{
-   *inst = tgsi_default_full_instruction();
-
-   inst->Instruction.Opcode = opcode;
+   /* Fragment program uses fragment position input.
+    * Need to replace instances of INPUT[WPOS] with temp T
+    * where T = INPUT[WPOS] by y is inverted.
+    */
+   static const gl_state_index winSizeState[STATE_LENGTH]
+      = { STATE_INTERNAL, STATE_FB_SIZE, 0, 0, 0 };
+   
+   /* XXX: note we are modifying the incoming shader here!  Need to
+    * do this before emitting the constant decls below, or this
+    * will be missed:
+    */
+   unsigned winHeightConst = _mesa_add_state_reference(program->Parameters,
+                                                       winSizeState);
 
-   inst->Instruction.NumDstRegs = 1;
-   inst->FullDstRegisters[0].DstRegister.File = dstFile;
-   inst->FullDstRegisters[0].DstRegister.Index = dstIndex;
-   inst->FullDstRegisters[0].DstRegister.WriteMask = writemask;
-
-   inst->Instruction.NumSrcRegs = 2;
-   inst->FullSrcRegisters[0].SrcRegister.File = srcFile1;
-   inst->FullSrcRegisters[0].SrcRegister.Index = srcIndex1;
-   inst->FullSrcRegisters[1].SrcRegister.File = srcFile2;
-   inst->FullSrcRegisters[1].SrcRegister.Index = srcIndex2;
-}
+   struct ureg_src winsize = ureg_DECL_constant( ureg, winHeightConst );
+   struct ureg_dst wpos_temp = ureg_DECL_temporary( ureg );
+   struct ureg_src wpos_input = t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]];
 
+   /* MOV wpos_temp, input[wpos]
+    */
+   ureg_MOV( ureg, wpos_temp, wpos_input );
 
+   /* SUB wpos_temp.y, winsize_const, wpos_input
+    */
+   ureg_SUB( ureg,
+             ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ),
+             winsize,
+             wpos_input);
 
-/**
- * Emit the TGSI instructions for inverting the WPOS y coordinate.
- */
-static int
-emit_inverted_wpos(struct tgsi_token *tokens,
-                   int wpos_temp,
-                   int winsize_const,
-                   int wpos_input,
-                   struct tgsi_header *header, int maxTokens)
-{
-   struct tgsi_full_instruction fullinst;
-   int ti = 0;
-
-   /* MOV wpos_temp.xzw, input[wpos]; */
-   build_tgsi_instruction1(&fullinst,
-                           TGSI_OPCODE_MOV,
-                           TGSI_FILE_TEMPORARY, wpos_temp, WRITEMASK_XZW,
-                           TGSI_FILE_INPUT, 0);
-
-   ti += tgsi_build_full_instruction(&fullinst,
-                                     &tokens[ti],
-                                     header,
-                                     maxTokens - ti);
-
-   /* SUB wpos_temp.y, const[winsize_const] - input[wpos_input]; */
-   build_tgsi_instruction2(&fullinst,
-                           TGSI_OPCODE_SUB,
-                           TGSI_FILE_TEMPORARY, wpos_temp, WRITEMASK_Y,
-                           TGSI_FILE_CONSTANT, winsize_const,
-                           TGSI_FILE_INPUT, wpos_input);
-
-   ti += tgsi_build_full_instruction(&fullinst,
-                                     &tokens[ti],
-                                     header,
-                                     maxTokens - ti);
-
-   return ti;
+   /* Use wpos_temp as position input from here on:
+    */
+   t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]] = ureg_src(wpos_temp);
 }
 
 
-
-
 /**
  * Translate Mesa program to TGSI format.
  * \param program  the program to translate
@@ -864,20 +676,19 @@ emit_inverted_wpos(struct tgsi_token *tokens,
  * \param inputMapping  maps Mesa fragment program inputs to TGSI generic
  *                      input indexes
  * \param inputSemanticName  the TGSI_SEMANTIC flag for each input
- * \param inputSemanticIndex  the semantic index (ex: which texcoord) for each input
+ * \param inputSemanticIndex  the semantic index (ex: which texcoord) for
+ *                            each input
  * \param interpMode  the TGSI_INTERPOLATE_LINEAR/PERSP mode for each input
-
  * \param numOutputs  number of output registers used
  * \param outputMapping  maps Mesa fragment program outputs to TGSI
  *                       generic outputs
  * \param outputSemanticName  the TGSI_SEMANTIC flag for each output
- * \param outputSemanticIndex  the semantic index (ex: which texcoord) for each output
- * \param tokens  array to store translated tokens in
- * \param maxTokens  size of the tokens array
+ * \param outputSemanticIndex  the semantic index (ex: which texcoord) for
+ *                             each output
  *
- * \return number of tokens placed in 'tokens' buffer, or zero if error
+ * \return  array of translated tokens, caller's responsibility to free
  */
-GLuint
+const struct tgsi_token *
 st_translate_mesa_program(
    GLcontext *ctx,
    uint procType,
@@ -892,252 +703,124 @@ st_translate_mesa_program(
    const GLuint outputMapping[],
    const ubyte outputSemanticName[],
    const ubyte outputSemanticIndex[],
-   const GLbitfield outputFlags[],
-   struct tgsi_token *tokens,
-   GLuint maxTokens )
+   const GLbitfield outputFlags[] )
 {
-   GLuint i;
-   GLuint ti;  /* token index */
-   struct tgsi_header *header;
-   struct tgsi_processor *processor;
-   GLuint preamble_size = 0;
-   GLuint immediates[1000];
-   GLuint numImmediates = 0;
-   GLboolean insideSubroutine = GL_FALSE;
-   GLboolean indirectAccess = GL_FALSE;
-   GLboolean tempsUsed[MAX_PROGRAM_TEMPS + 1];
-   GLint wposTemp = -1, winHeightConst = -1;
-
-   assert(procType == TGSI_PROCESSOR_FRAGMENT ||
-          procType == TGSI_PROCESSOR_VERTEX);
-
-   find_temporaries(program, tempsUsed);
-
-   if (procType == TGSI_PROCESSOR_FRAGMENT) {
-      if (program->InputsRead & FRAG_BIT_WPOS) {
-         /* Fragment program uses fragment position input.
-          * Need to replace instances of INPUT[WPOS] with temp T
-          * where T = INPUT[WPOS] by y is inverted.
-          */
-         static const gl_state_index winSizeState[STATE_LENGTH]
-            = { STATE_INTERNAL, STATE_FB_SIZE, 0, 0, 0 };
-         winHeightConst = _mesa_add_state_reference(program->Parameters,
-                                                    winSizeState);
-         wposTemp = find_free_temporary(tempsUsed);
-      }
-   }
-
+   struct st_translate translate, *t;
+   struct ureg_program *ureg;
+   const struct tgsi_token *tokens = NULL;
+   unsigned i;
 
-   *(struct tgsi_version *) &tokens[0] = tgsi_build_version();
+   t = &translate;
+   memset(t, 0, sizeof *t);
 
-   header = (struct tgsi_header *) &tokens[1];
-   *header = tgsi_build_header();
+   t->procType = procType;
+   t->inputMapping = inputMapping;
+   t->outputMapping = outputMapping;
+   t->ureg = ureg_create( procType );
+   if (t->ureg == NULL)
+      return NULL;
 
-   processor = (struct tgsi_processor *) &tokens[2];
-   *processor = tgsi_build_processor( procType, header );
+   ureg = t->ureg;
 
-   ti = 3;
+   /*_mesa_print_program(program);*/
 
    /*
     * Declare input attributes.
     */
    if (procType == TGSI_PROCESSOR_FRAGMENT) {
       for (i = 0; i < numInputs; i++) {
-         struct tgsi_full_declaration fulldecl;
-         fulldecl = make_input_decl(i,
-                                    GL_TRUE, interpMode[i],
-                                    TGSI_WRITEMASK_XYZW,
-                                    GL_TRUE, inputSemanticName[i],
-                                    inputSemanticIndex[i],
-                                    inputFlags[i]);
-         ti += tgsi_build_full_declaration(&fulldecl,
-                                           &tokens[ti],
-                                           header,
-                                           maxTokens - ti );
+         t->inputs[i] = ureg_DECL_fs_input(ureg,
+                                           inputSemanticName[i],
+                                           inputSemanticIndex[i],
+                                           interpMode[i]);
       }
-   }
-   else {
-      /* vertex prog */
-      /* XXX: this could probaby be merged with the clause above.
-       * the only difference is the semantic tags.
-       */
-      for (i = 0; i < numInputs; i++) {
-         struct tgsi_full_declaration fulldecl;
-         fulldecl = make_input_decl(i,
-                                    GL_FALSE, 0,
-                                    TGSI_WRITEMASK_XYZW,
-                                    GL_FALSE, 0, 0,
-                                    inputFlags[i]);
-         ti += tgsi_build_full_declaration(&fulldecl,
-                                           &tokens[ti],
-                                           header,
-                                           maxTokens - ti );
+
+      if (program->InputsRead & FRAG_BIT_WPOS) {
+         /* Must do this after setting up t->inputs, and before
+          * emitting constant references, below:
+          */
+         emit_inverted_wpos( t, program );
       }
-   }
 
-   /*
-    * Declare output attributes.
-    */
-   if (procType == TGSI_PROCESSOR_FRAGMENT) {
+      /*
+       * Declare output attributes.
+       */
       for (i = 0; i < numOutputs; i++) {
-         struct tgsi_full_declaration fulldecl;
          switch (outputSemanticName[i]) {
          case TGSI_SEMANTIC_POSITION:
-            fulldecl = make_output_decl(i,
-                                        TGSI_SEMANTIC_POSITION, /* Z / Depth */
-                                        outputSemanticIndex[i],
-                                        TGSI_WRITEMASK_Z,
-                                        outputFlags[i]);
+            t->outputs[i] = ureg_DECL_output( ureg,
+                                              TGSI_SEMANTIC_POSITION, /* Z / Depth */
+                                              outputSemanticIndex[i] );
+
+            t->outputs[i] = ureg_writemask( t->outputs[i],
+                                            TGSI_WRITEMASK_Z );
             break;
          case TGSI_SEMANTIC_COLOR:
-            fulldecl = make_output_decl(i,
-                                        TGSI_SEMANTIC_COLOR,
-                                        outputSemanticIndex[i],
-                                        TGSI_WRITEMASK_XYZW,
-                                        outputFlags[i]);
+            t->outputs[i] = ureg_DECL_output( ureg,
+                                              TGSI_SEMANTIC_COLOR,
+                                              outputSemanticIndex[i] );
             break;
          default:
             assert(0);
             return 0;
          }
-         ti += tgsi_build_full_declaration(&fulldecl,
-                                           &tokens[ti],
-                                           header,
-                                           maxTokens - ti );
       }
    }
    else {
-      /* vertex prog */
-      for (i = 0; i < numOutputs; i++) {
-         struct tgsi_full_declaration fulldecl;
-         fulldecl = make_output_decl(i,
-                                     outputSemanticName[i],
-                                     outputSemanticIndex[i],
-                                     TGSI_WRITEMASK_XYZW,
-                                     outputFlags[i]);
-         ti += tgsi_build_full_declaration(&fulldecl,
-                                           &tokens[ti],
-                                           header,
-                                           maxTokens - ti );
+      for (i = 0; i < numInputs; i++) {
+         t->inputs[i] = ureg_DECL_vs_input(ureg, i);
       }
-   }
 
-   /* temporary decls */
-   {
-      GLboolean inside_range = GL_FALSE;
-      GLuint start_range = 0;
-
-      tempsUsed[MAX_PROGRAM_TEMPS] = GL_FALSE;
-      for (i = 0; i < MAX_PROGRAM_TEMPS + 1; i++) {
-         if (tempsUsed[i] && !inside_range) {
-            inside_range = GL_TRUE;
-            start_range = i;
-         }
-         else if (!tempsUsed[i] && inside_range) {
-            struct tgsi_full_declaration fulldecl;
-
-            inside_range = GL_FALSE;
-            fulldecl = make_temp_decl( start_range, i - 1 );
-            ti += tgsi_build_full_declaration(
-               &fulldecl,
-               &tokens[ti],
-               header,
-               maxTokens - ti );
-         }
+      for (i = 0; i < numOutputs; i++) {
+         t->outputs[i] = ureg_DECL_output( ureg,
+                                           outputSemanticName[i],
+                                           outputSemanticIndex[i] );
       }
    }
 
    /* Declare address register.
-   */
+    */
    if (program->NumAddressRegs > 0) {
-      struct tgsi_full_declaration fulldecl;
-
       assert( program->NumAddressRegs == 1 );
-
-      fulldecl = make_addr_decl( 0, 0 );
-      ti += tgsi_build_full_declaration(
-         &fulldecl,
-         &tokens[ti],
-         header,
-         maxTokens - ti );
-
-      indirectAccess = GL_TRUE;
+      t->address[0] = ureg_DECL_address( ureg );
    }
 
-   /* immediates/literals */
-   memset(immediates, ~0, sizeof(immediates));
 
-   /* Emit immediates only when there is no address register in use.
-    * FIXME: Be smarter and recognize param arrays -- indirect addressing is
-    *        only valid within the referenced array.
+   /* Emit constants and immediates.  Mesa uses a single index space
+    * for these, so we put all the translated regs in t->constants.
     */
-   if (program->Parameters && !indirectAccess) {
-      for (i = 0; i < program->Parameters->NumParameters; i++) {
-         if (program->Parameters->Parameters[i].Type == PROGRAM_CONSTANT) {
-            struct tgsi_full_immediate fullimm;
-
-            fullimm = make_immediate( program->Parameters->ParameterValues[i], 4 );
-            ti += tgsi_build_full_immediate(
-               &fullimm,
-               &tokens[ti],
-               header,
-               maxTokens - ti );
-            immediates[i] = numImmediates;
-            numImmediates++;
-         }
-      }
-   }
-
-   /* constant buffer refs */
    if (program->Parameters) {
-      GLint start = -1, end = -1;
-
+      
+      t->constants = CALLOC( program->Parameters->NumParameters,
+                             sizeof t->constants[0] );
+      if (t->constants == NULL)
+         goto out;
+      
       for (i = 0; i < program->Parameters->NumParameters; i++) {
-         GLboolean emit = (i == program->Parameters->NumParameters - 1);
-         GLboolean matches;
-
          switch (program->Parameters->Parameters[i].Type) {
          case PROGRAM_ENV_PARAM:
          case PROGRAM_STATE_VAR:
          case PROGRAM_NAMED_PARAM:
          case PROGRAM_UNIFORM:
-            matches = GL_TRUE;
+            t->constants[i] = ureg_DECL_constant( ureg, i );
             break;
+
+            /* Emit immediates only when there is no address register
+             * in use.  FIXME: Be smarter and recognize param arrays:
+             * indirect addressing is only valid within the referenced
+             * array.
+             */
          case PROGRAM_CONSTANT:
-            matches = indirectAccess;
+            if (program->NumAddressRegs > 0) 
+               t->constants[i] = ureg_DECL_constant( ureg, i );
+            else
+               t->constants[i] = 
+                  ureg_DECL_immediate( ureg,
+                                       program->Parameters->ParameterValues[i],
+                                       4 );
             break;
          default:
-            matches = GL_FALSE;
-         }
-
-         if (matches) {
-            if (start == -1) {
-               /* begin a sequence */
-               start = i;
-               end = i;
-            }
-            else {
-               /* continue sequence */
-               end = i;
-            }
-         }
-         else {
-            if (start != -1) {
-               /* end of sequence */
-               emit = GL_TRUE;
-            }
-         }
-
-         if (emit && start >= 0) {
-            struct tgsi_full_declaration fulldecl;
-
-            fulldecl = make_constant_decl( start, end );
-            ti += tgsi_build_full_declaration(
-               &fulldecl,
-               &tokens[ti],
-               header,
-               maxTokens - ti );
-            start = end = -1;
+            break;
          }
       }
    }
@@ -1145,58 +828,44 @@ st_translate_mesa_program(
    /* texture samplers */
    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
       if (program->SamplersUsed & (1 << i)) {
-         struct tgsi_full_declaration fulldecl;
-
-         fulldecl = make_sampler_decl( i );
-         ti += tgsi_build_full_declaration(
-            &fulldecl,
-            &tokens[ti],
-            header,
-            maxTokens - ti );
+         t->samplers[i] = ureg_DECL_sampler( ureg, i );
       }
    }
 
-   /* invert WPOS fragment input */
-   if (wposTemp >= 0) {
-      ti += emit_inverted_wpos(&tokens[ti], wposTemp, winHeightConst,
-                               inputMapping[FRAG_ATTRIB_WPOS],
-                               header, maxTokens - ti);
-      preamble_size = 2; /* two instructions added */
+   /* Emit each instruction in turn:
+    */
+   for (i = 0; i < program->NumInstructions; i++) {
+      set_insn_start( t, ureg_get_instruction_number( ureg ));
+      compile_instruction( t, &program->Instructions[i] );
    }
 
-   for (i = 0; i < program->NumInstructions; i++) {
-      struct tgsi_full_instruction fullinst;
-
-      compile_instruction(
-         &program->Instructions[i],
-         &fullinst,
-         inputMapping,
-         outputMapping,
-         immediates,
-         indirectAccess,
-         preamble_size,
-         procType,
-         &insideSubroutine,
-         wposTemp);
-
-      ti += tgsi_build_full_instruction(
-         &fullinst,
-         &tokens[ti],
-         header,
-         maxTokens - ti );
+   /* Fix up all emitted labels:
+    */
+   for (i = 0; i < t->labels_count; i++) {
+      ureg_fixup_label( ureg,
+                        t->labels[i].token,
+                        t->insn[t->labels[i].branch_target] );
+   }
+
+   tokens = ureg_get_tokens( ureg, NULL );
+   ureg_destroy( ureg );
+
+out:
+   FREE(t->insn);
+   FREE(t->labels);
+   FREE(t->constants);
+
+   if (t->error) {
+      debug_printf("%s: translate error flag set\n", __FUNCTION__);
+      FREE((void *)tokens);
+      tokens = NULL;
    }
 
-#if DEBUG
-   if(!tgsi_sanity_check(tokens)) {
-      debug_printf("Due to sanity check failure(s) above the following shader program is invalid:\n");
-      debug_printf("\nOriginal program:\n%s", program->String);
-      debug_printf("\nMesa program:\n");
+   if (!tokens) {
+      debug_printf("%s: failed to translate Mesa program:\n", __FUNCTION__);
       _mesa_print_program(program);
-      debug_printf("\nTGSI program:\n");
-      tgsi_dump(tokens, 0);
       assert(0);
    }
-#endif
 
-   return ti;
+   return tokens;
 }
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.h b/src/mesa/state_tracker/st_mesa_to_tgsi.h
index b465b3bddc..679d0ddd41 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.h
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.h
@@ -39,7 +39,7 @@ extern "C" {
 struct tgsi_token;
 struct gl_program;
 
-GLuint
+const struct tgsi_token *
 st_translate_mesa_program(
    GLcontext *ctx,
    uint procType,
@@ -54,9 +54,7 @@ st_translate_mesa_program(
    const GLuint outputMapping[],
    const ubyte outputSemanticName[],
    const ubyte outputSemanticIndex[],
-   const GLbitfield outputFlags[],
-   struct tgsi_token *tokens,
-   GLuint maxTokens );
+   const GLbitfield outputFlags[] );
 
 
 #if defined __cplusplus
diff --git a/src/mesa/state_tracker/st_program.c b/src/mesa/state_tracker/st_program.c
index d2da20ae42..5f9d2a6dad 100644
--- a/src/mesa/state_tracker/st_program.c
+++ b/src/mesa/state_tracker/st_program.c
@@ -49,9 +49,6 @@
 #include "cso_cache/cso_context.h"
 
 
-#define ST_MAX_SHADER_TOKENS (8 * 1024)
-
-
 #define TGSI_DEBUG 0
 
 
@@ -70,12 +67,9 @@ st_translate_vertex_program(struct st_context *st,
                             const ubyte *outputSemanticIndex)
 {
    struct pipe_context *pipe = st->pipe;
-   struct tgsi_token *tokens;
    GLuint defaultOutputMapping[VERT_RESULT_MAX];
-   struct pipe_shader_state vs;
    GLuint attr, i;
    GLuint num_generic = 0;
-   GLuint num_tokens;
 
    ubyte vs_input_semantic_name[PIPE_MAX_SHADER_INPUTS];
    ubyte vs_input_semantic_index[PIPE_MAX_SHADER_INPUTS];
@@ -88,14 +82,7 @@ st_translate_vertex_program(struct st_context *st,
    GLbitfield input_flags[MAX_PROGRAM_INPUTS];
    GLbitfield output_flags[MAX_PROGRAM_OUTPUTS];
 
-   tokens =  (struct tgsi_token *)MALLOC(ST_MAX_SHADER_TOKENS * sizeof *tokens);
-   if(!tokens) {
-      /* FIXME: propagate error to the caller */
-      assert(0);
-      return;
-   }
-
-   memset(&vs, 0, sizeof(vs));
+//   memset(&vs, 0, sizeof(vs));
    memset(input_flags, 0, sizeof(input_flags));
    memset(output_flags, 0, sizeof(output_flags));
 
@@ -338,43 +325,32 @@ st_translate_vertex_program(struct st_context *st,
       stvp->driver_shader = NULL;
    }
 
-   /* XXX: fix static allocation of tokens:
-    */
-   num_tokens = st_translate_mesa_program(st->ctx,
-                                          TGSI_PROCESSOR_VERTEX,
-                                          &stvp->Base.Base,
-                                          /* inputs */
-                                          vs_num_inputs,
-                                          stvp->input_to_index,
-                                          vs_input_semantic_name,
-                                          vs_input_semantic_index,
-                                          NULL,
-                                          input_flags,
-                                          /* outputs */
-                                          vs_num_outputs,
-                                          outputMapping,
-                                          vs_output_semantic_name,
-                                          vs_output_semantic_index,
-                                          output_flags,
-                                          /* tokenized result */
-                                          tokens, ST_MAX_SHADER_TOKENS);
-
-   assert(num_tokens < ST_MAX_SHADER_TOKENS);
-
-   vs.tokens = (struct tgsi_token *)
-      _mesa_realloc(tokens,
-                    ST_MAX_SHADER_TOKENS * sizeof *tokens,
-                    num_tokens * sizeof *tokens);
+   stvp->state.tokens = 
+      st_translate_mesa_program(st->ctx,
+                                TGSI_PROCESSOR_VERTEX,
+                                &stvp->Base.Base,
+                                /* inputs */
+                                vs_num_inputs,
+                                stvp->input_to_index,
+                                vs_input_semantic_name,
+                                vs_input_semantic_index,
+                                NULL,
+                                input_flags,
+                                /* outputs */
+                                vs_num_outputs,
+                                outputMapping,
+                                vs_output_semantic_name,
+                                vs_output_semantic_index,
+                                output_flags );
 
    stvp->num_inputs = vs_num_inputs;
-   stvp->state = vs; /* struct copy */
-   stvp->driver_shader = pipe->create_vs_state(pipe, &vs);
+   stvp->driver_shader = pipe->create_vs_state(pipe, &stvp->state);
 
    if (0)
       _mesa_print_program(&stvp->Base.Base);
 
    if (TGSI_DEBUG)
-      tgsi_dump( vs.tokens, 0 );
+      tgsi_dump( stvp->state.tokens, 0 );
 }
 
 
@@ -383,7 +359,6 @@ st_translate_vertex_program(struct st_context *st,
  * Translate a Mesa fragment shader into a TGSI shader.
  * \param inputMapping  to map fragment program input registers to TGSI
  *                      input slots
- * \param tokensOut  destination for TGSI tokens
  * \return  pointer to cached pipe_shader object.
  */
 void
@@ -392,16 +367,13 @@ st_translate_fragment_program(struct st_context *st,
                               const GLuint inputMapping[])
 {
    struct pipe_context *pipe = st->pipe;
-   struct tgsi_token *tokens;
    GLuint outputMapping[FRAG_RESULT_MAX];
    GLuint defaultInputMapping[FRAG_ATTRIB_MAX];
-   struct pipe_shader_state fs;
    GLuint interpMode[16];  /* XXX size? */
    GLuint attr;
    const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
    GLuint vslot = 0;
    GLuint num_generic = 0;
-   GLuint num_tokens;
 
    uint fs_num_inputs = 0;
 
@@ -412,14 +384,7 @@ st_translate_fragment_program(struct st_context *st,
    GLbitfield input_flags[MAX_PROGRAM_INPUTS];
    GLbitfield output_flags[MAX_PROGRAM_OUTPUTS];
 
-   tokens =  (struct tgsi_token *)MALLOC(ST_MAX_SHADER_TOKENS * sizeof *tokens);
-   if(!tokens) {
-      /* FIXME: propagate error to the caller */
-      assert(0);
-      return;
-   }
-
-   memset(&fs, 0, sizeof(fs));
+//   memset(&fs, 0, sizeof(fs));
    memset(input_flags, 0, sizeof(input_flags));
    memset(output_flags, 0, sizeof(output_flags));
 
@@ -541,42 +506,31 @@ st_translate_fragment_program(struct st_context *st,
    if (!inputMapping)
       inputMapping = defaultInputMapping;
 
-   /* XXX: fix static allocation of tokens:
-    */
-   num_tokens = st_translate_mesa_program(st->ctx,
-                                          TGSI_PROCESSOR_FRAGMENT,
-                                          &stfp->Base.Base,
-                                          /* inputs */
-                                          fs_num_inputs,
-                                          inputMapping,
-                                          stfp->input_semantic_name,
-                                          stfp->input_semantic_index,
-                                          interpMode,
-                                          input_flags,
-                                          /* outputs */
-                                          fs_num_outputs,
-                                          outputMapping,
-                                          fs_output_semantic_name,
-                                          fs_output_semantic_index,
-                                          output_flags,
-                                          /* tokenized result */
-                                          tokens, ST_MAX_SHADER_TOKENS);
-
-   assert(num_tokens < ST_MAX_SHADER_TOKENS);
-
-   fs.tokens = (struct tgsi_token *)
-      _mesa_realloc(tokens,
-                    ST_MAX_SHADER_TOKENS * sizeof *tokens,
-                    num_tokens * sizeof *tokens);
-
-   stfp->state = fs; /* struct copy */
-   stfp->driver_shader = pipe->create_fs_state(pipe, &fs);
+   stfp->state.tokens = 
+      st_translate_mesa_program(st->ctx,
+                                TGSI_PROCESSOR_FRAGMENT,
+                                &stfp->Base.Base,
+                                /* inputs */
+                                fs_num_inputs,
+                                inputMapping,
+                                stfp->input_semantic_name,
+                                stfp->input_semantic_index,
+                                interpMode,
+                                input_flags,
+                                /* outputs */
+                                fs_num_outputs,
+                                outputMapping,
+                                fs_output_semantic_name,
+                                fs_output_semantic_index,
+                                output_flags );
+
+   stfp->driver_shader = pipe->create_fs_state(pipe, &stfp->state);
 
    if (0)
       _mesa_print_program(&stfp->Base.Base);
 
    if (TGSI_DEBUG)
-      tgsi_dump( fs.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
+      tgsi_dump( stfp->state.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
 }
 
 
diff --git a/src/mesa/swrast/s_depth.c b/src/mesa/swrast/s_depth.c
index 26e23f02d5..1a428fb1a2 100644
--- a/src/mesa/swrast/s_depth.c
+++ b/src/mesa/swrast/s_depth.c
@@ -497,6 +497,33 @@ depth_test_span32( GLcontext *ctx, GLuint n,
    return passed;
 }
 
+/* Apply ARB_depth_clamp to span of fragments. */
+void
+_swrast_depth_clamp_span( GLcontext *ctx, SWspan *span )
+{
+   struct gl_framebuffer *fb = ctx->DrawBuffer;
+   struct gl_renderbuffer *rb = fb->_DepthBuffer;
+   const GLuint count = span->end;
+   GLuint *zValues = span->array->z;
+   GLuint near, far;
+   int i;
+
+   if (rb->DataType == GL_UNSIGNED_SHORT) {
+      near = FLOAT_TO_UINT(ctx->Viewport.Near);
+      far = FLOAT_TO_UINT(ctx->Viewport.Far);
+   } else {
+      assert(rb->DataType == GL_UNSIGNED_INT);
+      CLAMPED_FLOAT_TO_USHORT(near, ctx->Viewport.Near);
+      CLAMPED_FLOAT_TO_USHORT(far, ctx->Viewport.Far);
+   }
+   for (i = 0; i < count; i++) {
+      if (zValues[i] < near)
+	 zValues[i] = near;
+      if (zValues[i] > far)
+	 zValues[i] = far;
+   }
+}
+
 
 
 /*
diff --git a/src/mesa/swrast/s_depth.h b/src/mesa/swrast/s_depth.h
index 3688625683..7eae366742 100644
--- a/src/mesa/swrast/s_depth.h
+++ b/src/mesa/swrast/s_depth.h
@@ -33,6 +33,8 @@
 extern GLuint
 _swrast_depth_test_span( GLcontext *ctx, SWspan *span);
 
+extern void
+_swrast_depth_clamp_span( GLcontext *ctx, SWspan *span );
 
 extern GLboolean
 _swrast_depth_bounds_test( GLcontext *ctx, SWspan *span );
diff --git a/src/mesa/swrast/s_imaging.c b/src/mesa/swrast/s_imaging.c
deleted file mode 100644
index 3578b713f6..0000000000
--- a/src/mesa/swrast/s_imaging.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
- *
- * 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 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
- * BRIAN PAUL 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.
- */
-
-/* KW:  Moved these here to remove knowledge of swrast from core mesa.
- * Should probably pull the entire software implementation of these
- * extensions into either swrast or a sister module.  
- */
-
-#include "main/glheader.h"
-#include "main/colortab.h"
-#include "main/convolve.h"
-#include "s_context.h"
-#include "s_span.h"
-
-
-void
-_swrast_CopyColorTable( GLcontext *ctx, 
-			GLenum target, GLenum internalformat,
-			GLint x, GLint y, GLsizei width)
-{
-   GLchan data[MAX_WIDTH][4];
-   struct gl_buffer_object *bufferSave;
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   if (width > MAX_WIDTH)
-      width = MAX_WIDTH;
-
-   swrast_render_start(ctx);
-
-   /* read the data from framebuffer */
-   _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                           width, x, y, CHAN_TYPE, data );
-
-   swrast_render_finish(ctx);
-
-   /* save PBO binding */
-   bufferSave = ctx->Unpack.BufferObj;
-   ctx->Unpack.BufferObj = ctx->Shared->NullBufferObj;
-
-   _mesa_ColorTable(target, internalformat, width, GL_RGBA, CHAN_TYPE, data);
-
-   /* restore PBO binding */
-   ctx->Unpack.BufferObj = bufferSave;
-}
-
-
-void
-_swrast_CopyColorSubTable( GLcontext *ctx,GLenum target, GLsizei start,
-			   GLint x, GLint y, GLsizei width)
-{
-   GLchan data[MAX_WIDTH][4];
-   struct gl_buffer_object *bufferSave;
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   if (width > MAX_WIDTH)
-      width = MAX_WIDTH;
-
-   swrast_render_start(ctx);
-
-   /* read the data from framebuffer */
-   _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                           width, x, y, CHAN_TYPE, data );
-
-   swrast_render_finish(ctx);
-
-   /* save PBO binding */
-   bufferSave = ctx->Unpack.BufferObj;
-   ctx->Unpack.BufferObj = ctx->Shared->NullBufferObj;
-
-   _mesa_ColorSubTable(target, start, width, GL_RGBA, CHAN_TYPE, data);
-
-   /* restore PBO binding */
-   ctx->Unpack.BufferObj = bufferSave;
-}
-
-
-void
-_swrast_CopyConvolutionFilter1D(GLcontext *ctx, GLenum target, 
-				GLenum internalFormat, 
-				GLint x, GLint y, GLsizei width)
-{
-   GLchan rgba[MAX_CONVOLUTION_WIDTH][4];
-   struct gl_buffer_object *bufferSave;
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   swrast_render_start(ctx);
-
-   /* read the data from framebuffer */
-   _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                           width, x, y, CHAN_TYPE, rgba );
-   
-   swrast_render_finish(ctx);
-
-   /* save PBO binding */
-   bufferSave = ctx->Unpack.BufferObj;
-   ctx->Unpack.BufferObj = ctx->Shared->NullBufferObj;
-
-   /* store as convolution filter */
-   _mesa_ConvolutionFilter1D(target, internalFormat, width,
-                             GL_RGBA, CHAN_TYPE, rgba);
-
-   /* restore PBO binding */
-   ctx->Unpack.BufferObj = bufferSave;
-}
-
-
-void
-_swrast_CopyConvolutionFilter2D(GLcontext *ctx, GLenum target, 
-				GLenum internalFormat, 
-				GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   struct gl_pixelstore_attrib packSave;
-   GLchan rgba[MAX_CONVOLUTION_HEIGHT][MAX_CONVOLUTION_WIDTH][4];
-   GLint i;
-   struct gl_buffer_object *bufferSave;
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      /* no readbuffer - OK */
-      return;
-   }
-
-   swrast_render_start(ctx);
-   
-   /* read pixels from framebuffer */
-   for (i = 0; i < height; i++) {
-      _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
-                              width, x, y + i, CHAN_TYPE, rgba[i] );
-   }
-
-   swrast_render_finish(ctx);
-
-   /*
-    * HACK: save & restore context state so we can store this as a
-    * convolution filter via the GL api.  Doesn't call any callbacks
-    * hanging off ctx->Unpack statechanges.
-    */
-
-   packSave = ctx->Unpack;  /* save pixel packing params */
-
-   ctx->Unpack.Alignment = 1;
-   ctx->Unpack.RowLength = MAX_CONVOLUTION_WIDTH;
-   ctx->Unpack.SkipPixels = 0;
-   ctx->Unpack.SkipRows = 0;
-   ctx->Unpack.ImageHeight = 0;
-   ctx->Unpack.SkipImages = 0;
-   ctx->Unpack.SwapBytes = GL_FALSE;
-   ctx->Unpack.LsbFirst = GL_FALSE;
-   ctx->Unpack.BufferObj = ctx->Shared->NullBufferObj;
-   ctx->NewState |= _NEW_PACKUNPACK;
-
-   /* save PBO binding */
-   bufferSave = ctx->Unpack.BufferObj;
-   ctx->Unpack.BufferObj = ctx->Shared->NullBufferObj;
-
-   _mesa_ConvolutionFilter2D(target, internalFormat, width, height,
-                             GL_RGBA, CHAN_TYPE, rgba);
-
-   /* restore PBO binding */
-   ctx->Unpack.BufferObj = bufferSave;
-
-   ctx->Unpack = packSave;  /* restore pixel packing params */
-   ctx->NewState |= _NEW_PACKUNPACK; 
-}
diff --git a/src/mesa/swrast/s_span.c b/src/mesa/swrast/s_span.c
index 0e2793b474..a45eac438e 100644
--- a/src/mesa/swrast/s_span.c
+++ b/src/mesa/swrast/s_span.c
@@ -880,6 +880,9 @@ _swrast_write_index_span( GLcontext *ctx, SWspan *span)
       stipple_polygon_span(ctx, span);
    }
 
+   if (ctx->Transform.DepthClamp)
+      _swrast_depth_clamp_span(ctx, span);
+
    /* Stencil and Z testing */
    if (ctx->Stencil._Enabled || ctx->Depth.Test) {
       if (!(span->arrayMask & SPAN_Z))
diff --git a/src/mesa/swrast/s_texstore.c b/src/mesa/swrast/s_texstore.c
deleted file mode 100644
index f9ff9ad6a4..0000000000
--- a/src/mesa/swrast/s_texstore.c
+++ /dev/null
@@ -1,601 +0,0 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.2
- *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
- *
- * 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 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
- * BRIAN PAUL 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:
- *   Brian Paul
- */
-
-
-/*
- * The functions in this file are mostly related to software texture fallbacks.
- * This includes texture image transfer/packing and texel fetching.
- * Hardware drivers will likely override most of this.
- */
-
-
-
-#include "main/glheader.h"
-#include "main/imports.h"
-#include "main/colormac.h"
-#include "main/context.h"
-#include "main/convolve.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/mipmap.h"
-#include "main/texformat.h"
-#include "main/teximage.h"
-#include "main/texstore.h"
-
-#include "s_context.h"
-#include "s_depth.h"
-#include "s_span.h"
-
-
-/**
- * Read an RGBA image from the frame buffer.
- * This is used by glCopyTex[Sub]Image[12]D().
- * \param x  window source x
- * \param y  window source y
- * \param width  image width
- * \param height  image height
- * \param type  datatype for returned GL_RGBA image
- * \return pointer to image
- */
-static GLvoid *
-read_color_image( GLcontext *ctx, GLint x, GLint y, GLenum type,
-                  GLsizei width, GLsizei height )
-{
-   struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;
-   const GLint pixelSize = _mesa_bytes_per_pixel(GL_RGBA, type);
-   const GLint stride = width * pixelSize;
-   GLint row;
-   GLubyte *image, *dst;
-
-   image = (GLubyte *) _mesa_malloc(width * height * pixelSize);
-   if (!image)
-      return NULL;
-
-   swrast_render_start(ctx);
-
-   dst = image;
-   for (row = 0; row < height; row++) {
-      _swrast_read_rgba_span(ctx, rb, width, x, y + row, type, dst);
-      dst += stride;
-   }
-
-   swrast_render_finish(ctx);
-
-   return image;
-}
-
-
-/**
- * As above, but read data from depth buffer.  Returned as GLuints.
- * \sa read_color_image
- */
-static GLuint *
-read_depth_image( GLcontext *ctx, GLint x, GLint y,
-                  GLsizei width, GLsizei height )
-{
-   struct gl_renderbuffer *rb = ctx->ReadBuffer->_DepthBuffer;
-   GLuint *image, *dst;
-   GLint i;
-
-   image = (GLuint *) _mesa_malloc(width * height * sizeof(GLuint));
-   if (!image)
-      return NULL;
-
-   swrast_render_start(ctx);
-
-   dst = image;
-   for (i = 0; i < height; i++) {
-      _swrast_read_depth_span_uint(ctx, rb, width, x, y + i, dst);
-      dst += width;
-   }
-
-   swrast_render_finish(ctx);
-
-   return image;
-}
-
-
-/**
- * As above, but read data from depth+stencil buffers.
- */
-static GLuint *
-read_depth_stencil_image(GLcontext *ctx, GLint x, GLint y,
-                         GLsizei width, GLsizei height)
-{
-   struct gl_renderbuffer *depthRb = ctx->ReadBuffer->_DepthBuffer;
-   struct gl_renderbuffer *stencilRb = ctx->ReadBuffer->_StencilBuffer;
-   GLuint *image, *dst;
-   GLint i;
-
-   ASSERT(depthRb);
-   ASSERT(stencilRb);
-
-   image = (GLuint *) _mesa_malloc(width * height * sizeof(GLuint));
-   if (!image)
-      return NULL;
-
-   swrast_render_start(ctx);
-
-   /* read from depth buffer */
-   dst = image;
-   if (depthRb->DataType == GL_UNSIGNED_INT) {
-      for (i = 0; i < height; i++) {
-         _swrast_get_row(ctx, depthRb, width, x, y + i, dst, sizeof(GLuint));
-         dst += width;
-      }
-   }
-   else {
-      GLushort z16[MAX_WIDTH];
-      ASSERT(depthRb->DataType == GL_UNSIGNED_SHORT);
-      for (i = 0; i < height; i++) {
-         GLint j;
-         _swrast_get_row(ctx, depthRb, width, x, y + i, z16, sizeof(GLushort));
-         /* convert GLushorts to GLuints */
-         for (j = 0; j < width; j++) {
-            dst[j] = z16[j];
-         }
-         dst += width;
-      }
-   }
-
-   /* put depth values into bits 0xffffff00 */
-   if (ctx->ReadBuffer->Visual.depthBits == 24) {
-      GLint j;
-      for (j = 0; j < width * height; j++) {
-         image[j] <<= 8;
-      }
-   }
-   else if (ctx->ReadBuffer->Visual.depthBits == 16) {
-      GLint j;
-      for (j = 0; j < width * height; j++) {
-         image[j] = (image[j] << 16) | (image[j] & 0xff00);
-      }      
-   }
-   else {
-      /* this handles arbitrary depthBits >= 12 */
-      const GLint rShift = ctx->ReadBuffer->Visual.depthBits;
-      const GLint lShift = 32 - rShift;
-      GLint j;
-      for (j = 0; j < width * height; j++) {
-         GLuint z = (image[j] << lShift);
-         image[j] = z | (z >> rShift);
-      }
-   }
-
-   /* read stencil values and interleave into image array */
-   dst = image;
-   for (i = 0; i < height; i++) {
-      GLstencil stencil[MAX_WIDTH];
-      GLint j;
-      ASSERT(8 * sizeof(GLstencil) == stencilRb->StencilBits);
-      _swrast_get_row(ctx, stencilRb, width, x, y + i,
-                      stencil, sizeof(GLstencil));
-      for (j = 0; j < width; j++) {
-         dst[j] = (dst[j] & 0xffffff00) | (stencil[j] & 0xff);
-      }
-      dst += width;
-   }
-
-   swrast_render_finish(ctx);
-
-   return image;
-}
-
-
-static GLboolean
-is_depth_format(GLenum format)
-{
-   switch (format) {
-      case GL_DEPTH_COMPONENT:
-      case GL_DEPTH_COMPONENT16:
-      case GL_DEPTH_COMPONENT24:
-      case GL_DEPTH_COMPONENT32:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-static GLboolean
-is_depth_stencil_format(GLenum format)
-{
-   switch (format) {
-      case GL_DEPTH_STENCIL_EXT:
-      case GL_DEPTH24_STENCIL8_EXT:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/*
- * Fallback for Driver.CopyTexImage1D().
- */
-void
-_swrast_copy_teximage1d( GLcontext *ctx, GLenum target, GLint level,
-                         GLenum internalFormat,
-                         GLint x, GLint y, GLsizei width, GLint border )
-{
-   struct gl_texture_unit *texUnit;
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   ASSERT(texObj);
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-   ASSERT(texImage);
-
-   ASSERT(ctx->Driver.TexImage1D);
-
-   if (is_depth_format(internalFormat)) {
-      /* read depth image from framebuffer */
-      GLuint *image = read_depth_image(ctx, x, y, width, 1);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
-         return;
-      }
-      /* call glTexImage1D to redefine the texture */
-      ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
-                             width, border,
-                             GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, image,
-                             &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else if (is_depth_stencil_format(internalFormat)) {
-      /* read depth/stencil image from framebuffer */
-      GLuint *image = read_depth_stencil_image(ctx, x, y, width, 1);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
-         return;
-      }
-      /* call glTexImage1D to redefine the texture */
-      ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
-                             width, border,
-                             GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
-                             image, &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else {
-      /* read RGBA image from framebuffer */
-      const GLenum format = GL_RGBA;
-      const GLenum type = ctx->ReadBuffer->_ColorReadBuffer->DataType;
-      GLvoid *image = read_color_image(ctx, x, y, type, width, 1);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
-         return;
-      }
-      /* call glTexImage1D to redefine the texture */
-      ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
-                             width, border, format, type, image,
-                             &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-}
-
-
-/**
- * Fallback for Driver.CopyTexImage2D().
- *
- * We implement CopyTexImage by reading the image from the framebuffer
- * then passing it to the ctx->Driver.TexImage2D() function.
- *
- * Device drivers should try to implement direct framebuffer->texture copies.
- */
-void
-_swrast_copy_teximage2d( GLcontext *ctx, GLenum target, GLint level,
-                         GLenum internalFormat,
-                         GLint x, GLint y, GLsizei width, GLsizei height,
-                         GLint border )
-{
-   struct gl_texture_unit *texUnit;
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   ASSERT(texObj);
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-   ASSERT(texImage);
-
-   ASSERT(ctx->Driver.TexImage2D);
-
-   if (is_depth_format(internalFormat)) {
-      /* read depth image from framebuffer */
-      GLuint *image = read_depth_image(ctx, x, y, width, height);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
-         return;
-      }
-      /* call glTexImage2D to redefine the texture */
-      ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
-                             width, height, border,
-                             GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, image,
-                             &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else if (is_depth_stencil_format(internalFormat)) {
-      GLuint *image = read_depth_stencil_image(ctx, x, y, width, height);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
-         return;
-      }
-      /* call glTexImage2D to redefine the texture */
-      ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
-                             width, height, border,
-                             GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
-                             image, &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else {
-      /* read RGBA image from framebuffer */
-      const GLenum format = GL_RGBA;
-      const GLenum type = ctx->ReadBuffer->_ColorReadBuffer->DataType;
-      GLvoid *image = read_color_image(ctx, x, y, type, width, height);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
-         return;
-      }
-      /* call glTexImage2D to redefine the texture */
-      ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
-                             width, height, border, format, type, image,
-                             &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-}
-
-
-/*
- * Fallback for Driver.CopyTexSubImage1D().
- */
-void
-_swrast_copy_texsubimage1d( GLcontext *ctx, GLenum target, GLint level,
-                            GLint xoffset, GLint x, GLint y, GLsizei width )
-{
-   struct gl_texture_unit *texUnit;
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   ASSERT(texObj);
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-   ASSERT(texImage);
-
-   ASSERT(ctx->Driver.TexImage1D);
-
-   if (texImage->_BaseFormat == GL_DEPTH_COMPONENT) {
-      /* read depth image from framebuffer */
-      GLuint *image = read_depth_image(ctx, x, y, width, 1);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage1D");
-         return;
-      }
-
-      /* call glTexSubImage1D to redefine the texture */
-      ctx->Driver.TexSubImage1D(ctx, target, level, xoffset, width,
-                                GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, image,
-                                &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else if (texImage->_BaseFormat == GL_DEPTH_STENCIL_EXT) {
-      /* read depth/stencil image from framebuffer */
-      GLuint *image = read_depth_stencil_image(ctx, x, y, width, 1);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage1D");
-         return;
-      }
-      /* call glTexImage1D to redefine the texture */
-      ctx->Driver.TexSubImage1D(ctx, target, level, xoffset, width,
-                                GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
-                                image, &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else {
-      /* read RGBA image from framebuffer */
-      const GLenum format = GL_RGBA;
-      const GLenum type = ctx->ReadBuffer->_ColorReadBuffer->DataType;
-      GLvoid *image = read_color_image(ctx, x, y, type, width, 1);
-      if (!image) {
-         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage1D" );
-         return;
-      }
-      /* now call glTexSubImage1D to do the real work */
-      ctx->Driver.TexSubImage1D(ctx, target, level, xoffset, width,
-                                format, type, image,
-                                &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-}
-
-
-/**
- * Fallback for Driver.CopyTexSubImage2D().
- *
- * Read the image from the framebuffer then hand it
- * off to ctx->Driver.TexSubImage2D().
- */
-void
-_swrast_copy_texsubimage2d( GLcontext *ctx,
-                            GLenum target, GLint level,
-                            GLint xoffset, GLint yoffset,
-                            GLint x, GLint y, GLsizei width, GLsizei height )
-{
-   struct gl_texture_unit *texUnit;
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   ASSERT(texObj);
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-   ASSERT(texImage);
-
-   ASSERT(ctx->Driver.TexImage2D);
-
-   if (texImage->_BaseFormat == GL_DEPTH_COMPONENT) {
-      /* read depth image from framebuffer */
-      GLuint *image = read_depth_image(ctx, x, y, width, height);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage2D");
-         return;
-      }
-      /* call glTexImage2D to redefine the texture */
-      ctx->Driver.TexSubImage2D(ctx, target, level,
-                                xoffset, yoffset, width, height,
-                                GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, image,
-                                &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else if (texImage->_BaseFormat == GL_DEPTH_STENCIL_EXT) {
-      /* read depth/stencil image from framebuffer */
-      GLuint *image = read_depth_stencil_image(ctx, x, y, width, height);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage2D");
-         return;
-      }
-      /* call glTexImage2D to redefine the texture */
-      ctx->Driver.TexSubImage2D(ctx, target, level,
-                                xoffset, yoffset, width, height,
-                                GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
-                                image, &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else {
-      /* read RGBA image from framebuffer */
-      const GLenum format = GL_RGBA;
-      const GLenum type = ctx->ReadBuffer->_ColorReadBuffer->DataType;
-      GLvoid *image = read_color_image(ctx, x, y, type, width, height);
-      if (!image) {
-         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage2D" );
-         return;
-      }
-      /* now call glTexSubImage2D to do the real work */
-      ctx->Driver.TexSubImage2D(ctx, target, level,
-                                xoffset, yoffset, width, height,
-                                format, type, image,
-                                &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-}
-
-
-/*
- * Fallback for Driver.CopyTexSubImage3D().
- */
-void
-_swrast_copy_texsubimage3d( GLcontext *ctx,
-                            GLenum target, GLint level,
-                            GLint xoffset, GLint yoffset, GLint zoffset,
-                            GLint x, GLint y, GLsizei width, GLsizei height )
-{
-   struct gl_texture_unit *texUnit;
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   ASSERT(texObj);
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-   ASSERT(texImage);
-
-   ASSERT(ctx->Driver.TexImage3D);
-
-   if (texImage->_BaseFormat == GL_DEPTH_COMPONENT) {
-      /* read depth image from framebuffer */
-      GLuint *image = read_depth_image(ctx, x, y, width, height);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage3D");
-         return;
-      }
-      /* call glTexImage3D to redefine the texture */
-      ctx->Driver.TexSubImage3D(ctx, target, level,
-                                xoffset, yoffset, zoffset, width, height, 1,
-                                GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, image,
-                                &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else if (texImage->_BaseFormat == GL_DEPTH_STENCIL_EXT) {
-      /* read depth/stencil image from framebuffer */
-      GLuint *image = read_depth_stencil_image(ctx, x, y, width, height);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage3D");
-         return;
-      }
-      /* call glTexImage3D to redefine the texture */
-      ctx->Driver.TexSubImage3D(ctx, target, level,
-                                xoffset, yoffset, zoffset, width, height, 1,
-                                GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
-                                image, &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-   else {
-      /* read RGBA image from framebuffer */
-      const GLenum format = GL_RGBA;
-      const GLenum type = ctx->ReadBuffer->_ColorReadBuffer->DataType;
-      GLvoid *image = read_color_image(ctx, x, y, type, width, height);
-      if (!image) {
-         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage3D" );
-         return;
-      }
-      /* now call glTexSubImage3D to do the real work */
-      ctx->Driver.TexSubImage3D(ctx, target, level,
-                                xoffset, yoffset, zoffset, width, height, 1,
-                                format, type, image,
-                                &ctx->DefaultPacking, texObj, texImage);
-      _mesa_free(image);
-   }
-
-   /* GL_SGIS_generate_mipmap */
-   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-}
diff --git a/src/mesa/swrast/swrast.h b/src/mesa/swrast/swrast.h
index c319ca62f9..c183b315b6 100644
--- a/src/mesa/swrast/swrast.h
+++ b/src/mesa/swrast/swrast.h
@@ -207,60 +207,6 @@ extern void
 _swrast_print_vertex( GLcontext *ctx, const SWvertex *v );
 
 
-/*
- * Imaging fallbacks (a better solution should be found, perhaps
- * moving all the imaging fallback code to a new module) 
- */
-extern void
-_swrast_CopyConvolutionFilter2D(GLcontext *ctx, GLenum target, 
-				GLenum internalFormat, 
-				GLint x, GLint y, GLsizei width, 
-				GLsizei height);
-extern void
-_swrast_CopyConvolutionFilter1D(GLcontext *ctx, GLenum target, 
-				GLenum internalFormat, 
-				GLint x, GLint y, GLsizei width);
-extern void
-_swrast_CopyColorSubTable( GLcontext *ctx,GLenum target, GLsizei start,
-			   GLint x, GLint y, GLsizei width);
-extern void
-_swrast_CopyColorTable( GLcontext *ctx, 
-			GLenum target, GLenum internalformat,
-			GLint x, GLint y, GLsizei width);
-
-
-/*
- * Texture fallbacks.  Could also live in a new module
- * with the rest of the texture store fallbacks?
- */
-extern void
-_swrast_copy_teximage1d(GLcontext *ctx, GLenum target, GLint level,
-                        GLenum internalFormat,
-                        GLint x, GLint y, GLsizei width, GLint border);
-
-extern void
-_swrast_copy_teximage2d(GLcontext *ctx, GLenum target, GLint level,
-                        GLenum internalFormat,
-                        GLint x, GLint y, GLsizei width, GLsizei height,
-                        GLint border);
-
-
-extern void
-_swrast_copy_texsubimage1d(GLcontext *ctx, GLenum target, GLint level,
-                           GLint xoffset, GLint x, GLint y, GLsizei width);
-
-extern void
-_swrast_copy_texsubimage2d(GLcontext *ctx,
-                           GLenum target, GLint level,
-                           GLint xoffset, GLint yoffset,
-                           GLint x, GLint y, GLsizei width, GLsizei height);
-
-extern void
-_swrast_copy_texsubimage3d(GLcontext *ctx,
-                           GLenum target, GLint level,
-                           GLint xoffset, GLint yoffset, GLint zoffset,
-                           GLint x, GLint y, GLsizei width, GLsizei height);
-
 
 extern void
 _swrast_eject_texture_images(GLcontext *ctx);
diff --git a/src/mesa/tnl/t_context.h b/src/mesa/tnl/t_context.h
index c19eb3df3c..6137c2d2fe 100644
--- a/src/mesa/tnl/t_context.h
+++ b/src/mesa/tnl/t_context.h
@@ -548,4 +548,8 @@ typedef struct
 #define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1      /* 0xa + 1 */
 
 
+extern void
+tnl_clip_prepare(GLcontext *ctx);
+
+
 #endif
diff --git a/src/mesa/tnl/t_draw.c b/src/mesa/tnl/t_draw.c
index c64c2c2077..04fa106300 100644
--- a/src/mesa/tnl/t_draw.c
+++ b/src/mesa/tnl/t_draw.c
@@ -316,22 +316,27 @@ static void bind_indices( GLcontext *ctx,
 
    ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);
 
-   if (ib->type == GL_UNSIGNED_INT) {
+   if (ib->type == GL_UNSIGNED_INT && VB->Primitive[0].basevertex == 0) {
       VB->Elts = (GLuint *) ptr;
    }
    else {
       GLuint *elts = (GLuint *)get_space(ctx, ib->count * sizeof(GLuint));
       VB->Elts = elts;
 
-      if (ib->type == GL_UNSIGNED_SHORT) {
+      if (ib->type == GL_UNSIGNED_INT) {
+	 const GLuint *in = (GLuint *)ptr;
+	 for (i = 0; i < ib->count; i++)
+	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
+      }
+      else if (ib->type == GL_UNSIGNED_SHORT) {
 	 const GLushort *in = (GLushort *)ptr;
 	 for (i = 0; i < ib->count; i++) 
-	    *elts++ = (GLuint)(*in++);
+	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
       }
       else {
 	 const GLubyte *in = (GLubyte *)ptr;
 	 for (i = 0; i < ib->count; i++) 
-	    *elts++ = (GLuint)(*in++);
+	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
       }
    }
 }
@@ -390,10 +395,14 @@ void _tnl_draw_prims( GLcontext *ctx,
    TNLcontext *tnl = TNL_CONTEXT(ctx);
    const GLuint TEST_SPLIT = 0;
    const GLint max = TEST_SPLIT ? 8 : tnl->vb.Size - MAX_CLIPPED_VERTICES;
+   GLuint max_basevertex = prim->basevertex;
+   GLuint i;
+
+   for (i = 1; i < nr_prims; i++)
+      max_basevertex = MAX2(max_basevertex, prim[i].basevertex);
 
    if (0)
    {
-      GLuint i;
       _mesa_printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
       for (i = 0; i < nr_prims; i++)
 	 _mesa_printf("prim %d: %s start %d count %d\n", i, 
@@ -410,7 +419,7 @@ void _tnl_draw_prims( GLcontext *ctx,
 			_tnl_vbo_draw_prims );
       return;
    }
-   else if (max_index > max) {
+   else if (max_index + max_basevertex > max) {
       /* The software TNL pipeline has a fixed amount of storage for
        * vertices and it is necessary to split incoming drawing commands
        * if they exceed that limit.
@@ -424,7 +433,7 @@ void _tnl_draw_prims( GLcontext *ctx,
        * recursively call back into this function.
        */
       vbo_split_prims( ctx, arrays, prim, nr_prims, ib, 
-		       0, max_index,
+		       0, max_index + prim->basevertex,
 		       _tnl_vbo_draw_prims,
 		       &limits );
    }
@@ -435,17 +444,34 @@ void _tnl_draw_prims( GLcontext *ctx,
       struct gl_buffer_object *bo[VERT_ATTRIB_MAX + 1];
       GLuint nr_bo = 0;
 
-      /* Binding inputs may imply mapping some vertex buffer objects.
-       * They will need to be unmapped below.
-       */
-      bind_inputs(ctx, arrays, max_index+1, bo, &nr_bo);
-      bind_indices(ctx, ib, bo, &nr_bo);
-      bind_prims(ctx, prim, nr_prims );
+      for (i = 0; i < nr_prims;) {
+	 GLuint this_nr_prims;
+
+	 /* Our SW TNL pipeline doesn't handle basevertex yet, so bind_indices
+	  * will rebase the elements to the basevertex, and we'll only
+	  * emit strings of prims with the same basevertex in one draw call.
+	  */
+	 for (this_nr_prims = 1; i + this_nr_prims < nr_prims;
+	      this_nr_prims++) {
+	    if (prim[i].basevertex != prim[i + this_nr_prims].basevertex)
+	       break;
+	 }
+
+	 /* Binding inputs may imply mapping some vertex buffer objects.
+	  * They will need to be unmapped below.
+	  */
+	 bind_prims(ctx, &prim[i], this_nr_prims);
+	 bind_inputs(ctx, arrays, max_index + prim[i].basevertex + 1,
+		     bo, &nr_bo);
+	 bind_indices(ctx, ib, bo, &nr_bo);
 
-      TNL_CONTEXT(ctx)->Driver.RunPipeline(ctx);
+	 TNL_CONTEXT(ctx)->Driver.RunPipeline(ctx);
 
-      unmap_vbos(ctx, bo, nr_bo);
-      free_space(ctx);
+	 unmap_vbos(ctx, bo, nr_bo);
+	 free_space(ctx);
+
+	 i += this_nr_prims;
+      }
    }
 }
 
diff --git a/src/mesa/tnl/t_rasterpos.c b/src/mesa/tnl/t_rasterpos.c
index f1fdddf0f5..99b6787455 100644
--- a/src/mesa/tnl/t_rasterpos.c
+++ b/src/mesa/tnl/t_rasterpos.c
@@ -46,11 +46,10 @@
  * \return zero if outside view volume, or one if inside.
  */
 static GLuint
-viewclip_point( const GLfloat v[] )
+viewclip_point_xy( const GLfloat v[] )
 {
    if (   v[0] > v[3] || v[0] < -v[3]
-       || v[1] > v[3] || v[1] < -v[3]
-       || v[2] > v[3] || v[2] < -v[3] ) {
+       || v[1] > v[3] || v[1] < -v[3] ) {
       return 0;
    }
    else {
@@ -408,18 +407,18 @@ _tnl_RasterPos(GLcontext *ctx, const GLfloat vObj[4])
       /* apply projection matrix:  clip = Proj * eye */
       TRANSFORM_POINT( clip, ctx->ProjectionMatrixStack.Top->m, eye );
 
-      /* clip to view volume */
-      if (ctx->Transform.RasterPositionUnclipped) {
-         /* GL_IBM_rasterpos_clip: only clip against Z */
+      /* clip to view volume. */
+      if (!ctx->Transform.DepthClamp) {
          if (viewclip_point_z(clip) == 0) {
             ctx->Current.RasterPosValid = GL_FALSE;
             return;
          }
       }
-      else if (viewclip_point(clip) == 0) {
-         /* Normal OpenGL behaviour */
-         ctx->Current.RasterPosValid = GL_FALSE;
-         return;
+      if (!ctx->Transform.RasterPositionUnclipped) {
+         if (viewclip_point_xy(clip) == 0) {
+            ctx->Current.RasterPosValid = GL_FALSE;
+            return;
+         }
       }
 
       /* clip to user clipping planes */
@@ -443,6 +442,12 @@ _tnl_RasterPos(GLcontext *ctx, const GLfloat vObj[4])
                                   / ctx->DrawBuffer->_DepthMaxF;
       ctx->Current.RasterPos[3] = clip[3];
 
+      if (ctx->Transform.DepthClamp) {
+	 ctx->Current.RasterPos[3] = CLAMP(ctx->Current.RasterPos[3],
+					   ctx->Viewport.Near,
+					   ctx->Viewport.Far);
+      }
+
       /* compute raster distance */
       if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
          ctx->Current.RasterDistance = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
diff --git a/src/mesa/tnl/t_vb_program.c b/src/mesa/tnl/t_vb_program.c
index dc954bcba1..c10a27614f 100644
--- a/src/mesa/tnl/t_vb_program.c
+++ b/src/mesa/tnl/t_vb_program.c
@@ -131,13 +131,16 @@ do_ndc_cliptest(GLcontext *ctx, struct vp_stage_data *store)
    store->ormask = 0;
    store->andmask = CLIP_FRUSTUM_BITS;
 
+   tnl_clip_prepare(ctx);
+
    if (tnl->NeedNdcCoords) {
       VB->NdcPtr =
          _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
                                             &store->ndcCoords,
                                             store->clipmask,
                                             &store->ormask,
-                                            &store->andmask );
+                                            &store->andmask,
+					    !ctx->Transform.DepthClamp );
    }
    else {
       VB->NdcPtr = NULL;
@@ -145,7 +148,8 @@ do_ndc_cliptest(GLcontext *ctx, struct vp_stage_data *store)
                                             NULL,
                                             store->clipmask,
                                             &store->ormask,
-                                            &store->andmask );
+                                            &store->andmask,
+					    !ctx->Transform.DepthClamp );
    }
 
    if (store->andmask) {
diff --git a/src/mesa/tnl/t_vb_vertex.c b/src/mesa/tnl/t_vb_vertex.c
index 30aa7c4086..4734754ea4 100644
--- a/src/mesa/tnl/t_vb_vertex.c
+++ b/src/mesa/tnl/t_vb_vertex.c
@@ -118,6 +118,22 @@ static void (*(usercliptab[5]))( GLcontext *,
 };
 
 
+void
+tnl_clip_prepare(GLcontext *ctx)
+{
+   /* Neither the x86 nor sparc asm cliptest functions have been updated
+    * for ARB_depth_clamp, so force the C paths.
+    */
+   if (ctx->Transform.DepthClamp) {
+      static GLboolean c_funcs_installed = GL_FALSE;
+      if (!c_funcs_installed) {
+         init_c_cliptest();
+         c_funcs_installed = GL_TRUE;
+      }
+   }
+}
+
+
 
 static GLboolean run_vertex_stage( GLcontext *ctx,
 				   struct tnl_pipeline_stage *stage )
@@ -129,6 +145,8 @@ static GLboolean run_vertex_stage( GLcontext *ctx,
    if (ctx->VertexProgram._Current) 
       return GL_TRUE;
 
+   tnl_clip_prepare(ctx);
+
    if (ctx->_NeedEyeCoords) {
       /* Separate modelview transformation:
        * Use combined ModelProject to avoid some depth artifacts
@@ -173,7 +191,8 @@ static GLboolean run_vertex_stage( GLcontext *ctx,
 					    &store->proj,
 					    store->clipmask,
 					    &store->ormask,
-					    &store->andmask );
+					    &store->andmask,
+					    !ctx->Transform.DepthClamp );
    }
    else {
       VB->NdcPtr = NULL;
@@ -181,7 +200,8 @@ static GLboolean run_vertex_stage( GLcontext *ctx,
 					    NULL,
 					    store->clipmask,
 					    &store->ormask,
-					    &store->andmask );
+					    &store->andmask,
+					    !ctx->Transform.DepthClamp );
    }
 
    if (store->andmask)
diff --git a/src/mesa/vbo/vbo.h b/src/mesa/vbo/vbo.h
index 5986e93576..b24ecfd7cd 100644
--- a/src/mesa/vbo/vbo.h
+++ b/src/mesa/vbo/vbo.h
@@ -44,6 +44,7 @@ struct _mesa_prim {
 
    GLuint start;
    GLuint count;
+   GLint basevertex;
 };
 
 /* Would like to call this a "vbo_index_buffer", but this would be
diff --git a/src/mesa/vbo/vbo_exec_array.c b/src/mesa/vbo/vbo_exec_array.c
index 12911f5750..b9550d6106 100644
--- a/src/mesa/vbo/vbo_exec_array.c
+++ b/src/mesa/vbo/vbo_exec_array.c
@@ -181,7 +181,7 @@ unmap_array_buffer(GLcontext *ctx, struct gl_client_array *array)
  */
 static void
 check_draw_elements_data(GLcontext *ctx, GLsizei count, GLenum elemType,
-                         const void *elements)
+                         const void *elements, GLint basevertex)
 {
    struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
    const void *elemMap;
@@ -518,6 +518,7 @@ vbo_exec_DrawArrays(GLenum mode, GLint start, GLsizei count)
    prim[0].start = start;
    prim[0].count = count;
    prim[0].indexed = 0;
+   prim[0].basevertex = 0;
 
    vbo->draw_prims( ctx, exec->array.inputs, prim, 1, NULL,
                     GL_TRUE, start, start + count - 1 );
@@ -592,7 +593,8 @@ vbo_validated_drawrangeelements(GLcontext *ctx, GLenum mode,
 				GLboolean index_bounds_valid,
 				GLuint start, GLuint end,
 				GLsizei count, GLenum type,
-				const GLvoid *indices)
+				const GLvoid *indices,
+				GLint basevertex)
 {
    struct vbo_context *vbo = vbo_context(ctx);
    struct vbo_exec_context *exec = &vbo->exec;
@@ -626,6 +628,7 @@ vbo_validated_drawrangeelements(GLcontext *ctx, GLenum mode,
    prim[0].start = 0;
    prim[0].count = count;
    prim[0].indexed = 1;
+   prim[0].basevertex = basevertex;
 
    /* Need to give special consideration to rendering a range of
     * indices starting somewhere above zero.  Typically the
@@ -663,23 +666,25 @@ vbo_validated_drawrangeelements(GLcontext *ctx, GLenum mode,
 }
 
 static void GLAPIENTRY
-vbo_exec_DrawRangeElements(GLenum mode,
-			   GLuint start, GLuint end,
-			   GLsizei count, GLenum type, const GLvoid *indices)
+vbo_exec_DrawRangeElementsBaseVertex(GLenum mode,
+				     GLuint start, GLuint end,
+				     GLsizei count, GLenum type,
+				     const GLvoid *indices,
+				     GLint basevertex)
 {
    GET_CURRENT_CONTEXT(ctx);
 
    if (!_mesa_validate_DrawRangeElements( ctx, mode, start, end, count,
-                                          type, indices ))
+                                          type, indices, basevertex ))
       return;
 
    if (end >= ctx->Array.ArrayObj->_MaxElement) {
       /* the max element is out of bounds of one or more enabled arrays */
-      _mesa_warning(ctx, "glDraw[Range]Elements(start %u, end %u, count %d, "
-                    "type 0x%x, indices=%p)\n"
+      _mesa_warning(ctx, "glDraw[Range]Elements{,BaseVertex}(start %u, end %u, "
+		    "count %d, type 0x%x, indices=%p, base=%d)\n"
                     "\tindex=%u is out of bounds (max=%u)  "
                     "Element Buffer %u (size %d)",
-                    start, end, count, type, indices, end,
+                    start, end, count, type, indices, end, basevertex,
                     ctx->Array.ArrayObj->_MaxElement - 1,
                     ctx->Array.ElementArrayBufferObj->Name,
                     ctx->Array.ElementArrayBufferObj->Size);
@@ -692,10 +697,12 @@ vbo_exec_DrawRangeElements(GLenum mode,
       return;
    }
    else if (0) {
-      _mesa_printf("glDraw[Range]Elements"
-                   "(start %u, end %u, type 0x%x, count %d) ElemBuf %u\n",
+      _mesa_printf("glDraw[Range]Elements{,BaseVertex}"
+                   "(start %u, end %u, type 0x%x, count %d) ElemBuf %u, "
+		   "base %d\n",
                    start, end, type, count,
-                   ctx->Array.ElementArrayBufferObj->Name);
+                   ctx->Array.ElementArrayBufferObj->Name,
+		   basevertex);
    }
 
 #if 0
@@ -705,7 +712,17 @@ vbo_exec_DrawRangeElements(GLenum mode,
 #endif
 
    vbo_validated_drawrangeelements(ctx, mode, GL_TRUE, start, end,
-				   count, type, indices);
+				   count, type, indices, basevertex);
+}
+
+static void GLAPIENTRY
+vbo_exec_DrawRangeElements(GLenum mode,
+				     GLuint start, GLuint end,
+				     GLsizei count, GLenum type,
+				     const GLvoid *indices)
+{
+   vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,
+					indices, 0);
 }
 
 
@@ -715,18 +732,33 @@ vbo_exec_DrawElements(GLenum mode, GLsizei count, GLenum type,
 {
    GET_CURRENT_CONTEXT(ctx);
 
-   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
+      return;
+
+   vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
+				   count, type, indices, 0);
+}
+
+static void GLAPIENTRY
+vbo_exec_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+				const GLvoid *indices, GLint basevertex)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices,
+				     basevertex ))
       return;
 
    vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
-				   count, type, indices);
+				   count, type, indices, basevertex);
 }
 
 /* Inner support for both _mesa_DrawElements and _mesa_DrawRangeElements */
 static void
 vbo_validated_multidrawelements(GLcontext *ctx, GLenum mode,
 				const GLsizei *count, GLenum type,
-				const GLvoid **indices, GLsizei primcount)
+				const GLvoid **indices, GLsizei primcount,
+				const GLint *basevertex)
 {
    struct vbo_context *vbo = vbo_context(ctx);
    struct vbo_exec_context *exec = &vbo->exec;
@@ -820,6 +852,10 @@ vbo_validated_multidrawelements(GLcontext *ctx, GLenum mode,
 	 prim[i].start = ((uintptr_t)indices[i] - min_index_ptr) / index_type_size;
 	 prim[i].count = count[i];
 	 prim[i].indexed = 1;
+	 if (basevertex != NULL)
+	    prim[i].basevertex = basevertex[i];
+	 else
+	    prim[i].basevertex = 0;
       }
 
       vbo->draw_prims(ctx, exec->array.inputs, prim, primcount, &ib,
@@ -840,6 +876,10 @@ vbo_validated_multidrawelements(GLcontext *ctx, GLenum mode,
 	 prim[0].start = 0;
 	 prim[0].count = count[i];
 	 prim[0].indexed = 1;
+	 if (basevertex != NULL)
+	    prim[0].basevertex = basevertex[i];
+	 else
+	    prim[0].basevertex = 0;
       }
 
       vbo->draw_prims(ctx, exec->array.inputs, prim, 1, &ib,
@@ -860,13 +900,36 @@ vbo_exec_MultiDrawElements(GLenum mode,
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    for (i = 0; i < primcount; i++) {
-      if (!_mesa_validate_DrawElements( ctx, mode, count[i], type, indices[i] ))
+      if (!_mesa_validate_DrawElements(ctx, mode, count[i], type, indices[i],
+				       0))
 	 return;
    }
 
-   vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount);
+   vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,
+				   NULL);
 }
 
+static void GLAPIENTRY
+vbo_exec_MultiDrawElementsBaseVertex(GLenum mode,
+				     const GLsizei *count, GLenum type,
+				     const GLvoid **indices,
+				     GLsizei primcount,
+				     const GLsizei *basevertex)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint i;
+
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   for (i = 0; i < primcount; i++) {
+      if (!_mesa_validate_DrawElements(ctx, mode, count[i], type, indices[i],
+				       basevertex[i]))
+	 return;
+   }
+
+   vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,
+				   basevertex);
+}
 
 
 /***********************************************************************
@@ -881,11 +944,17 @@ vbo_exec_array_init( struct vbo_exec_context *exec )
    exec->vtxfmt.DrawElements = vbo_exec_DrawElements;
    exec->vtxfmt.DrawRangeElements = vbo_exec_DrawRangeElements;
    exec->vtxfmt.MultiDrawElementsEXT = vbo_exec_MultiDrawElements;
+   exec->vtxfmt.DrawElementsBaseVertex = vbo_exec_DrawElementsBaseVertex;
+   exec->vtxfmt.DrawRangeElementsBaseVertex = vbo_exec_DrawRangeElementsBaseVertex;
+   exec->vtxfmt.MultiDrawElementsBaseVertex = vbo_exec_MultiDrawElementsBaseVertex;
 #else
    exec->vtxfmt.DrawArrays = _mesa_noop_DrawArrays;
    exec->vtxfmt.DrawElements = _mesa_noop_DrawElements;
    exec->vtxfmt.DrawRangeElements = _mesa_noop_DrawRangeElements;
    exec->vtxfmt.MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
+   exec->vtxfmt.DrawElementsBaseVertex = _mesa_noop_DrawElementsBaseVertex;
+   exec->vtxfmt.DrawRangeElementsBaseVertex = _mesa_noop_DrawRangeElementsBaseVertex;
+   exec->vtxfmt.MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
 #endif
 }
 
@@ -913,6 +982,13 @@ _mesa_DrawElements(GLenum mode, GLsizei count, GLenum type,
    vbo_exec_DrawElements(mode, count, type, indices);
 }
 
+void GLAPIENTRY
+_mesa_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+			     const GLvoid *indices, GLint basevertex)
+{
+   vbo_exec_DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+}
+
 
 /* This API entrypoint is not ordinarily used */
 void GLAPIENTRY
@@ -922,6 +998,15 @@ _mesa_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
    vbo_exec_DrawRangeElements(mode, start, end, count, type, indices);
 }
 
+void GLAPIENTRY
+_mesa_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
+				  GLsizei count, GLenum type,
+				  const GLvoid *indices, GLint basevertex)
+{
+   vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,
+					indices, basevertex);
+}
+
 /* GL_EXT_multi_draw_arrays */
 void GLAPIENTRY
 _mesa_MultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type,
@@ -929,3 +1014,13 @@ _mesa_MultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type,
 {
    vbo_exec_MultiDrawElements(mode, count, type, indices, primcount);
 }
+
+void GLAPIENTRY
+_mesa_MultiDrawElementsBaseVertex(GLenum mode,
+				  const GLsizei *count, GLenum type,
+				  const GLvoid **indices, GLsizei primcount,
+				  const GLint *basevertex)
+{
+   vbo_exec_MultiDrawElementsBaseVertex(mode, count, type, indices,
+					primcount, basevertex);
+}
diff --git a/src/mesa/vbo/vbo_rebase.c b/src/mesa/vbo/vbo_rebase.c
index 3bf7ef580f..799a25fc1c 100644
--- a/src/mesa/vbo/vbo_rebase.c
+++ b/src/mesa/vbo/vbo_rebase.c
@@ -126,7 +126,20 @@ void vbo_rebase_prims( GLcontext *ctx,
    if (0)
       _mesa_printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
 
-   if (ib) {
+
+   if (ib && ctx->Extensions.ARB_draw_elements_base_vertex) {
+      /* If we can just tell the hardware or the TNL to interpret our
+       * indices with a different base, do so.
+       */
+      tmp_prims = (struct _mesa_prim *)_mesa_malloc(sizeof(*prim) * nr_prims);
+
+      for (i = 0; i < nr_prims; i++) {
+	 tmp_prims[i] = prim[i];
+	 tmp_prims[i].basevertex -= min_index;
+      }
+
+      prim = tmp_prims;
+   } else if (ib) {
       /* Unfortunately need to adjust each index individually.
        */
       GLboolean map_ib = ib->obj->Name && !ib->obj->Pointer;
diff --git a/src/mesa/vbo/vbo_save_api.c b/src/mesa/vbo/vbo_save_api.c
index 1771510d84..41cd21d04b 100644
--- a/src/mesa/vbo/vbo_save_api.c
+++ b/src/mesa/vbo/vbo_save_api.c
@@ -826,6 +826,33 @@ static void GLAPIENTRY _save_DrawRangeElements(GLenum mode,
    _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );
 }
 
+static void GLAPIENTRY _save_DrawElementsBaseVertex(GLenum mode,
+						    GLsizei count,
+						    GLenum type,
+						    const GLvoid *indices,
+						    GLint basevertex)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   (void) mode; (void) count; (void) type; (void) indices; (void)basevertex;
+
+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawElements" );
+}
+
+static void GLAPIENTRY _save_DrawRangeElementsBaseVertex(GLenum mode,
+							 GLuint start,
+							 GLuint end,
+							 GLsizei count,
+							 GLenum type,
+							 const GLvoid *indices,
+							 GLint basevertex)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   (void) mode; (void) start; (void) end; (void) count; (void) type;
+   (void) indices; (void)basevertex;
+
+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );
+}
+
 static void GLAPIENTRY _save_DrawArrays(GLenum mode, GLint start, GLsizei count)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -907,7 +934,7 @@ static void GLAPIENTRY _save_OBE_DrawElements(GLenum mode, GLsizei count, GLenum
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
 
-   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
       return;
 
    _ae_map_vbos( ctx );
@@ -948,7 +975,7 @@ static void GLAPIENTRY _save_OBE_DrawRangeElements(GLenum mode,
    GET_CURRENT_CONTEXT(ctx);
    if (_mesa_validate_DrawRangeElements( ctx, mode,
 					 start, end,
-					 count, type, indices ))
+					 count, type, indices, 0 ))
       _save_OBE_DrawElements( mode, count, type, indices );
 }
 
@@ -1039,9 +1066,11 @@ static void _save_vtxfmt_init( GLcontext *ctx )
    vfmt->DrawArrays = _save_DrawArrays;
    vfmt->DrawElements = _save_DrawElements;
    vfmt->DrawRangeElements = _save_DrawRangeElements;
+   vfmt->DrawElementsBaseVertex = _save_DrawElementsBaseVertex;
+   vfmt->DrawRangeElementsBaseVertex = _save_DrawRangeElementsBaseVertex;
    /* Loops back into vfmt->DrawElements */
    vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
-
+   vfmt->MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
 }
 
 
@@ -1233,6 +1262,7 @@ void vbo_save_api_init( struct vbo_save_context *save )
    ctx->ListState.ListVtxfmt.DrawRangeElements = _save_OBE_DrawRangeElements;
    /* loops back into _save_OBE_DrawElements */
    ctx->ListState.ListVtxfmt.MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
+   ctx->ListState.ListVtxfmt.MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
    _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
 }
 
diff --git a/src/mesa/vbo/vbo_split.c b/src/mesa/vbo/vbo_split.c
index 58e879628d..c445acca7d 100644
--- a/src/mesa/vbo/vbo_split.c
+++ b/src/mesa/vbo/vbo_split.c
@@ -50,6 +50,7 @@
 #include "main/glheader.h"
 #include "main/imports.h"
 #include "main/mtypes.h"
+#include "main/macros.h"
 
 #include "vbo_split.h"
 #include "vbo.h"
@@ -107,7 +108,12 @@ void vbo_split_prims( GLcontext *ctx,
 		      vbo_draw_func draw,
 		      const struct split_limits *limits )
 {
-  
+   GLuint max_basevertex = prim->basevertex;
+   GLuint i;
+
+   for (i = 1; i < nr_prims; i++)
+      max_basevertex = MAX2(max_basevertex, prim[i].basevertex);
+
    if (ib) {
       if (limits->max_indices == 0) {
 	 /* Could traverse the indices, re-emitting vertices in turn.
diff --git a/src/mesa/vbo/vbo_split_copy.c b/src/mesa/vbo/vbo_split_copy.c
index 8ec180d550..c45190b9dd 100644
--- a/src/mesa/vbo/vbo_split_copy.c
+++ b/src/mesa/vbo/vbo_split_copy.c
@@ -589,28 +589,40 @@ void vbo_split_copy( GLcontext *ctx,
 		     const struct split_limits *limits )
 {
    struct copy_context copy;
-   GLuint i;
+   GLuint i, this_nr_prims;
+
+   for (i = 0; i < nr_prims;) {
+      /* Our SW TNL pipeline doesn't handle basevertex yet, so bind_indices
+       * will rebase the elements to the basevertex, and we'll only
+       * emit strings of prims with the same basevertex in one draw call.
+       */
+      for (this_nr_prims = 1; i + this_nr_prims < nr_prims;
+	   this_nr_prims++) {
+	 if (prim[i].basevertex != prim[i + this_nr_prims].basevertex)
+	    break;
+      }
 
-   memset(&copy, 0, sizeof(copy));
+      memset(&copy, 0, sizeof(copy));
 
-   /* Require indexed primitives:
-    */
-   assert(ib);
-   
-   copy.ctx = ctx;
-   copy.array = arrays;
-   copy.prim = prim;
-   copy.nr_prims = nr_prims;
-   copy.ib = ib;
-   copy.draw = draw;
-   copy.limits = limits;
+      /* Require indexed primitives:
+       */
+      assert(ib);
 
-   /* Clear the vertex cache:
-    */
-   for (i = 0; i < ELT_TABLE_SIZE; i++)
-      copy.vert_cache[i].in = ~0;
+      copy.ctx = ctx;
+      copy.array = arrays;
+      copy.prim = &prim[i];
+      copy.nr_prims = this_nr_prims;
+      copy.ib = ib;
+      copy.draw = draw;
+      copy.limits = limits;
 
-   replay_init(&copy);
-   replay_elts(&copy);
-   replay_finish(&copy);
+      /* Clear the vertex cache:
+       */
+      for (i = 0; i < ELT_TABLE_SIZE; i++)
+	 copy.vert_cache[i].in = ~0;
+
+      replay_init(&copy);
+      replay_elts(&copy);
+      replay_finish(&copy);
+   }
 }
diff --git a/src/mesa/x86-64/glapi_x86-64.S b/src/mesa/x86-64/glapi_x86-64.S
index db917f3982..72d0532906 100644
--- a/src/mesa/x86-64/glapi_x86-64.S
+++ b/src/mesa/x86-64/glapi_x86-64.S
@@ -21601,21 +21601,25 @@ GL_PREFIX(WaitSync):
 	.size	GL_PREFIX(WaitSync), .-GL_PREFIX(WaitSync)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(PolygonOffsetEXT)
-	.type	GL_PREFIX(PolygonOffsetEXT), @function
-GL_PREFIX(PolygonOffsetEXT):
+	.globl	GL_PREFIX(DrawElementsBaseVertex)
+	.type	GL_PREFIX(DrawElementsBaseVertex), @function
+GL_PREFIX(DrawElementsBaseVertex):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
 	movq	4592(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
-	subq	$24, %rsp
-	movq	%xmm0, (%rsp)
-	movq	%xmm1, 8(%rsp)
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
 	call	_x86_64_get_dispatch@PLT
-	movq	8(%rsp), %xmm1
-	movq	(%rsp), %xmm0
-	addq	$24, %rsp
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
 	movq	4592(%rax), %r11
 	jmp	*%r11
 #else
@@ -21625,23 +21629,26 @@ GL_PREFIX(PolygonOffsetEXT):
 	movq	4592(%rax), %r11
 	jmp	*%r11
 1:
-	subq	$24, %rsp
-	movq	%xmm0, (%rsp)
-	movq	%xmm1, 8(%rsp)
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
 	call	_glapi_get_dispatch
-	movq	8(%rsp), %xmm1
-	movq	(%rsp), %xmm0
-	addq	$24, %rsp
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
 	movq	4592(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(PolygonOffsetEXT), .-GL_PREFIX(PolygonOffsetEXT)
+	.size	GL_PREFIX(DrawElementsBaseVertex), .-GL_PREFIX(DrawElementsBaseVertex)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_575)
-	.type	GL_PREFIX(_dispatch_stub_575), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_575))
-GL_PREFIX(_dispatch_stub_575):
+	.globl	GL_PREFIX(DrawRangeElementsBaseVertex)
+	.type	GL_PREFIX(DrawRangeElementsBaseVertex), @function
+GL_PREFIX(DrawRangeElementsBaseVertex):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
 	movq	4600(%rax), %r11
@@ -21649,9 +21656,17 @@ GL_PREFIX(_dispatch_stub_575):
 #elif defined(PTHREADS)
 	pushq	%rdi
 	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
+	pushq	%r9
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
+	popq	%r9
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
 	popq	%rsi
 	popq	%rdi
 	movq	4600(%rax), %r11
@@ -21665,21 +21680,28 @@ GL_PREFIX(_dispatch_stub_575):
 1:
 	pushq	%rdi
 	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
+	pushq	%r9
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
+	popq	%r9
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
 	popq	%rsi
 	popq	%rdi
 	movq	4600(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_575), .-GL_PREFIX(_dispatch_stub_575)
+	.size	GL_PREFIX(DrawRangeElementsBaseVertex), .-GL_PREFIX(DrawRangeElementsBaseVertex)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_576)
-	.type	GL_PREFIX(_dispatch_stub_576), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_576))
-GL_PREFIX(_dispatch_stub_576):
+	.globl	GL_PREFIX(MultiDrawElementsBaseVertex)
+	.type	GL_PREFIX(MultiDrawElementsBaseVertex), @function
+GL_PREFIX(MultiDrawElementsBaseVertex):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
 	movq	4608(%rax), %r11
@@ -21687,9 +21709,17 @@ GL_PREFIX(_dispatch_stub_576):
 #elif defined(PTHREADS)
 	pushq	%rdi
 	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
+	pushq	%r9
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
+	popq	%r9
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
 	popq	%rsi
 	popq	%rdi
 	movq	4608(%rax), %r11
@@ -21703,32 +21733,39 @@ GL_PREFIX(_dispatch_stub_576):
 1:
 	pushq	%rdi
 	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
+	pushq	%r9
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
+	popq	%r9
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
 	popq	%rsi
 	popq	%rdi
 	movq	4608(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_576), .-GL_PREFIX(_dispatch_stub_576)
+	.size	GL_PREFIX(MultiDrawElementsBaseVertex), .-GL_PREFIX(MultiDrawElementsBaseVertex)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_577)
-	.type	GL_PREFIX(_dispatch_stub_577), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_577))
-GL_PREFIX(_dispatch_stub_577):
+	.globl	GL_PREFIX(PolygonOffsetEXT)
+	.type	GL_PREFIX(PolygonOffsetEXT), @function
+GL_PREFIX(PolygonOffsetEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
 	movq	4616(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
-	movq	%rdi, (%rsp)
-	movq	%xmm0, 8(%rsp)
+	movq	%xmm0, (%rsp)
+	movq	%xmm1, 8(%rsp)
 	call	_x86_64_get_dispatch@PLT
-	movq	8(%rsp), %xmm0
-	movq	(%rsp), %rdi
+	movq	8(%rsp), %xmm1
+	movq	(%rsp), %xmm0
 	addq	$24, %rsp
 	movq	4616(%rax), %r11
 	jmp	*%r11
@@ -21740,16 +21777,16 @@ GL_PREFIX(_dispatch_stub_577):
 	jmp	*%r11
 1:
 	subq	$24, %rsp
-	movq	%rdi, (%rsp)
-	movq	%xmm0, 8(%rsp)
+	movq	%xmm0, (%rsp)
+	movq	%xmm1, 8(%rsp)
 	call	_glapi_get_dispatch
-	movq	8(%rsp), %xmm0
-	movq	(%rsp), %rdi
+	movq	8(%rsp), %xmm1
+	movq	(%rsp), %xmm0
 	addq	$24, %rsp
 	movq	4616(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_577), .-GL_PREFIX(_dispatch_stub_577)
+	.size	GL_PREFIX(PolygonOffsetEXT), .-GL_PREFIX(PolygonOffsetEXT)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(_dispatch_stub_578)
@@ -21837,13 +21874,13 @@ GL_PREFIX(_dispatch_stub_580):
 	movq	4640(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
-	pushq	%rdi
-	pushq	%rsi
-	pushq	%rbp
+	subq	$24, %rsp
+	movq	%rdi, (%rsp)
+	movq	%xmm0, 8(%rsp)
 	call	_x86_64_get_dispatch@PLT
-	popq	%rbp
-	popq	%rsi
-	popq	%rdi
+	movq	8(%rsp), %xmm0
+	movq	(%rsp), %rdi
+	addq	$24, %rsp
 	movq	4640(%rax), %r11
 	jmp	*%r11
 #else
@@ -21853,13 +21890,13 @@ GL_PREFIX(_dispatch_stub_580):
 	movq	4640(%rax), %r11
 	jmp	*%r11
 1:
-	pushq	%rdi
-	pushq	%rsi
-	pushq	%rbp
+	subq	$24, %rsp
+	movq	%rdi, (%rsp)
+	movq	%xmm0, 8(%rsp)
 	call	_glapi_get_dispatch
-	popq	%rbp
-	popq	%rsi
-	popq	%rdi
+	movq	8(%rsp), %xmm0
+	movq	(%rsp), %rdi
+	addq	$24, %rsp
 	movq	4640(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
@@ -21914,7 +21951,11 @@ GL_PREFIX(_dispatch_stub_582):
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
+	pushq	%rsi
+	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
+	popq	%rbp
+	popq	%rsi
 	popq	%rdi
 	movq	4656(%rax), %r11
 	jmp	*%r11
@@ -21926,7 +21967,11 @@ GL_PREFIX(_dispatch_stub_582):
 	jmp	*%r11
 1:
 	pushq	%rdi
+	pushq	%rsi
+	pushq	%rbp
 	call	_glapi_get_dispatch
+	popq	%rbp
+	popq	%rsi
 	popq	%rdi
 	movq	4656(%rax), %r11
 	jmp	*%r11
@@ -21934,12 +21979,118 @@ GL_PREFIX(_dispatch_stub_582):
 	.size	GL_PREFIX(_dispatch_stub_582), .-GL_PREFIX(_dispatch_stub_582)
 
 	.p2align	4,,15
+	.globl	GL_PREFIX(_dispatch_stub_583)
+	.type	GL_PREFIX(_dispatch_stub_583), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_583))
+GL_PREFIX(_dispatch_stub_583):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	4664(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rbp
+	call	_x86_64_get_dispatch@PLT
+	popq	%rbp
+	popq	%rsi
+	popq	%rdi
+	movq	4664(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	4664(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rbp
+	call	_glapi_get_dispatch
+	popq	%rbp
+	popq	%rsi
+	popq	%rdi
+	movq	4664(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(_dispatch_stub_583), .-GL_PREFIX(_dispatch_stub_583)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(_dispatch_stub_584)
+	.type	GL_PREFIX(_dispatch_stub_584), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_584))
+GL_PREFIX(_dispatch_stub_584):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	4672(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rbp
+	call	_x86_64_get_dispatch@PLT
+	popq	%rbp
+	popq	%rsi
+	popq	%rdi
+	movq	4672(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	4672(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rbp
+	call	_glapi_get_dispatch
+	popq	%rbp
+	popq	%rsi
+	popq	%rdi
+	movq	4672(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(_dispatch_stub_584), .-GL_PREFIX(_dispatch_stub_584)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(_dispatch_stub_585)
+	.type	GL_PREFIX(_dispatch_stub_585), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_585))
+GL_PREFIX(_dispatch_stub_585):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	4680(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	call	_x86_64_get_dispatch@PLT
+	popq	%rdi
+	movq	4680(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	4680(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	call	_glapi_get_dispatch
+	popq	%rdi
+	movq	4680(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(_dispatch_stub_585), .-GL_PREFIX(_dispatch_stub_585)
+
+	.p2align	4,,15
 	.globl	GL_PREFIX(ColorPointerEXT)
 	.type	GL_PREFIX(ColorPointerEXT), @function
 GL_PREFIX(ColorPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4664(%rax), %r11
+	movq	4688(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21953,13 +22104,13 @@ GL_PREFIX(ColorPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4664(%rax), %r11
+	movq	4688(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4664(%rax), %r11
+	movq	4688(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21973,7 +22124,7 @@ GL_PREFIX(ColorPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4664(%rax), %r11
+	movq	4688(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ColorPointerEXT), .-GL_PREFIX(ColorPointerEXT)
@@ -21984,7 +22135,7 @@ GL_PREFIX(ColorPointerEXT):
 GL_PREFIX(EdgeFlagPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4672(%rax), %r11
+	movq	4696(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21994,13 +22145,13 @@ GL_PREFIX(EdgeFlagPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4672(%rax), %r11
+	movq	4696(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4672(%rax), %r11
+	movq	4696(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22010,7 +22161,7 @@ GL_PREFIX(EdgeFlagPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4672(%rax), %r11
+	movq	4696(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EdgeFlagPointerEXT), .-GL_PREFIX(EdgeFlagPointerEXT)
@@ -22021,7 +22172,7 @@ GL_PREFIX(EdgeFlagPointerEXT):
 GL_PREFIX(IndexPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4680(%rax), %r11
+	movq	4704(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22035,13 +22186,13 @@ GL_PREFIX(IndexPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4680(%rax), %r11
+	movq	4704(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4680(%rax), %r11
+	movq	4704(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22055,7 +22206,7 @@ GL_PREFIX(IndexPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4680(%rax), %r11
+	movq	4704(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IndexPointerEXT), .-GL_PREFIX(IndexPointerEXT)
@@ -22066,7 +22217,7 @@ GL_PREFIX(IndexPointerEXT):
 GL_PREFIX(NormalPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4688(%rax), %r11
+	movq	4712(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22080,13 +22231,13 @@ GL_PREFIX(NormalPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4688(%rax), %r11
+	movq	4712(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4688(%rax), %r11
+	movq	4712(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22100,7 +22251,7 @@ GL_PREFIX(NormalPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4688(%rax), %r11
+	movq	4712(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(NormalPointerEXT), .-GL_PREFIX(NormalPointerEXT)
@@ -22111,7 +22262,7 @@ GL_PREFIX(NormalPointerEXT):
 GL_PREFIX(TexCoordPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4696(%rax), %r11
+	movq	4720(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22125,13 +22276,13 @@ GL_PREFIX(TexCoordPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4696(%rax), %r11
+	movq	4720(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4696(%rax), %r11
+	movq	4720(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22145,7 +22296,7 @@ GL_PREFIX(TexCoordPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4696(%rax), %r11
+	movq	4720(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(TexCoordPointerEXT), .-GL_PREFIX(TexCoordPointerEXT)
@@ -22156,7 +22307,7 @@ GL_PREFIX(TexCoordPointerEXT):
 GL_PREFIX(VertexPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4704(%rax), %r11
+	movq	4728(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22170,13 +22321,13 @@ GL_PREFIX(VertexPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4704(%rax), %r11
+	movq	4728(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4704(%rax), %r11
+	movq	4728(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22190,7 +22341,7 @@ GL_PREFIX(VertexPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4704(%rax), %r11
+	movq	4728(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexPointerEXT), .-GL_PREFIX(VertexPointerEXT)
@@ -22201,7 +22352,7 @@ GL_PREFIX(VertexPointerEXT):
 GL_PREFIX(PointParameterfEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4712(%rax), %r11
+	movq	4736(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -22211,13 +22362,13 @@ GL_PREFIX(PointParameterfEXT):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4712(%rax), %r11
+	movq	4736(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4712(%rax), %r11
+	movq	4736(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -22227,7 +22378,7 @@ GL_PREFIX(PointParameterfEXT):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4712(%rax), %r11
+	movq	4736(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PointParameterfEXT), .-GL_PREFIX(PointParameterfEXT)
@@ -22238,7 +22389,7 @@ GL_PREFIX(PointParameterfEXT):
 GL_PREFIX(PointParameterfvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4720(%rax), %r11
+	movq	4744(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22248,13 +22399,13 @@ GL_PREFIX(PointParameterfvEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4720(%rax), %r11
+	movq	4744(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4720(%rax), %r11
+	movq	4744(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22264,7 +22415,7 @@ GL_PREFIX(PointParameterfvEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4720(%rax), %r11
+	movq	4744(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PointParameterfvEXT), .-GL_PREFIX(PointParameterfvEXT)
@@ -22275,7 +22426,7 @@ GL_PREFIX(PointParameterfvEXT):
 GL_PREFIX(LockArraysEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4728(%rax), %r11
+	movq	4752(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22285,13 +22436,13 @@ GL_PREFIX(LockArraysEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4728(%rax), %r11
+	movq	4752(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4728(%rax), %r11
+	movq	4752(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22301,7 +22452,7 @@ GL_PREFIX(LockArraysEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4728(%rax), %r11
+	movq	4752(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(LockArraysEXT), .-GL_PREFIX(LockArraysEXT)
@@ -22312,37 +22463,37 @@ GL_PREFIX(LockArraysEXT):
 GL_PREFIX(UnlockArraysEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4736(%rax), %r11
+	movq	4760(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	4736(%rax), %r11
+	movq	4760(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4736(%rax), %r11
+	movq	4760(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	4736(%rax), %r11
+	movq	4760(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(UnlockArraysEXT), .-GL_PREFIX(UnlockArraysEXT)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_593)
-	.type	GL_PREFIX(_dispatch_stub_593), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_593))
-GL_PREFIX(_dispatch_stub_593):
+	.globl	GL_PREFIX(_dispatch_stub_596)
+	.type	GL_PREFIX(_dispatch_stub_596), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_596))
+GL_PREFIX(_dispatch_stub_596):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4744(%rax), %r11
+	movq	4768(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22352,13 +22503,13 @@ GL_PREFIX(_dispatch_stub_593):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4744(%rax), %r11
+	movq	4768(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4744(%rax), %r11
+	movq	4768(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22368,19 +22519,19 @@ GL_PREFIX(_dispatch_stub_593):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4744(%rax), %r11
+	movq	4768(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_593), .-GL_PREFIX(_dispatch_stub_593)
+	.size	GL_PREFIX(_dispatch_stub_596), .-GL_PREFIX(_dispatch_stub_596)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_594)
-	.type	GL_PREFIX(_dispatch_stub_594), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_594))
-GL_PREFIX(_dispatch_stub_594):
+	.globl	GL_PREFIX(_dispatch_stub_597)
+	.type	GL_PREFIX(_dispatch_stub_597), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_597))
+GL_PREFIX(_dispatch_stub_597):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4752(%rax), %r11
+	movq	4776(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22390,13 +22541,13 @@ GL_PREFIX(_dispatch_stub_594):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4752(%rax), %r11
+	movq	4776(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4752(%rax), %r11
+	movq	4776(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22406,10 +22557,10 @@ GL_PREFIX(_dispatch_stub_594):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4752(%rax), %r11
+	movq	4776(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_594), .-GL_PREFIX(_dispatch_stub_594)
+	.size	GL_PREFIX(_dispatch_stub_597), .-GL_PREFIX(_dispatch_stub_597)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(SecondaryColor3bEXT)
@@ -22417,7 +22568,7 @@ GL_PREFIX(_dispatch_stub_594):
 GL_PREFIX(SecondaryColor3bEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4760(%rax), %r11
+	movq	4784(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22427,13 +22578,13 @@ GL_PREFIX(SecondaryColor3bEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4760(%rax), %r11
+	movq	4784(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4760(%rax), %r11
+	movq	4784(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22443,7 +22594,7 @@ GL_PREFIX(SecondaryColor3bEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4760(%rax), %r11
+	movq	4784(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3bEXT), .-GL_PREFIX(SecondaryColor3bEXT)
@@ -22454,25 +22605,25 @@ GL_PREFIX(SecondaryColor3bEXT):
 GL_PREFIX(SecondaryColor3bvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4768(%rax), %r11
+	movq	4792(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4768(%rax), %r11
+	movq	4792(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4768(%rax), %r11
+	movq	4792(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4768(%rax), %r11
+	movq	4792(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3bvEXT), .-GL_PREFIX(SecondaryColor3bvEXT)
@@ -22483,7 +22634,7 @@ GL_PREFIX(SecondaryColor3bvEXT):
 GL_PREFIX(SecondaryColor3dEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4776(%rax), %r11
+	movq	4800(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -22495,13 +22646,13 @@ GL_PREFIX(SecondaryColor3dEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4776(%rax), %r11
+	movq	4800(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4776(%rax), %r11
+	movq	4800(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -22513,7 +22664,7 @@ GL_PREFIX(SecondaryColor3dEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4776(%rax), %r11
+	movq	4800(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3dEXT), .-GL_PREFIX(SecondaryColor3dEXT)
@@ -22524,25 +22675,25 @@ GL_PREFIX(SecondaryColor3dEXT):
 GL_PREFIX(SecondaryColor3dvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4784(%rax), %r11
+	movq	4808(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4784(%rax), %r11
+	movq	4808(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4784(%rax), %r11
+	movq	4808(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4784(%rax), %r11
+	movq	4808(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3dvEXT), .-GL_PREFIX(SecondaryColor3dvEXT)
@@ -22553,7 +22704,7 @@ GL_PREFIX(SecondaryColor3dvEXT):
 GL_PREFIX(SecondaryColor3fEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4792(%rax), %r11
+	movq	4816(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -22565,13 +22716,13 @@ GL_PREFIX(SecondaryColor3fEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4792(%rax), %r11
+	movq	4816(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4792(%rax), %r11
+	movq	4816(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -22583,7 +22734,7 @@ GL_PREFIX(SecondaryColor3fEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4792(%rax), %r11
+	movq	4816(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3fEXT), .-GL_PREFIX(SecondaryColor3fEXT)
@@ -22594,25 +22745,25 @@ GL_PREFIX(SecondaryColor3fEXT):
 GL_PREFIX(SecondaryColor3fvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4800(%rax), %r11
+	movq	4824(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4800(%rax), %r11
+	movq	4824(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4800(%rax), %r11
+	movq	4824(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4800(%rax), %r11
+	movq	4824(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3fvEXT), .-GL_PREFIX(SecondaryColor3fvEXT)
@@ -22623,7 +22774,7 @@ GL_PREFIX(SecondaryColor3fvEXT):
 GL_PREFIX(SecondaryColor3iEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4808(%rax), %r11
+	movq	4832(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22633,13 +22784,13 @@ GL_PREFIX(SecondaryColor3iEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4808(%rax), %r11
+	movq	4832(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4808(%rax), %r11
+	movq	4832(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22649,7 +22800,7 @@ GL_PREFIX(SecondaryColor3iEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4808(%rax), %r11
+	movq	4832(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3iEXT), .-GL_PREFIX(SecondaryColor3iEXT)
@@ -22660,25 +22811,25 @@ GL_PREFIX(SecondaryColor3iEXT):
 GL_PREFIX(SecondaryColor3ivEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4816(%rax), %r11
+	movq	4840(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4816(%rax), %r11
+	movq	4840(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4816(%rax), %r11
+	movq	4840(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4816(%rax), %r11
+	movq	4840(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3ivEXT), .-GL_PREFIX(SecondaryColor3ivEXT)
@@ -22689,7 +22840,7 @@ GL_PREFIX(SecondaryColor3ivEXT):
 GL_PREFIX(SecondaryColor3sEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4824(%rax), %r11
+	movq	4848(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22699,13 +22850,13 @@ GL_PREFIX(SecondaryColor3sEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4824(%rax), %r11
+	movq	4848(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4824(%rax), %r11
+	movq	4848(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22715,7 +22866,7 @@ GL_PREFIX(SecondaryColor3sEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4824(%rax), %r11
+	movq	4848(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3sEXT), .-GL_PREFIX(SecondaryColor3sEXT)
@@ -22726,25 +22877,25 @@ GL_PREFIX(SecondaryColor3sEXT):
 GL_PREFIX(SecondaryColor3svEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4832(%rax), %r11
+	movq	4856(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4832(%rax), %r11
+	movq	4856(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4832(%rax), %r11
+	movq	4856(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4832(%rax), %r11
+	movq	4856(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3svEXT), .-GL_PREFIX(SecondaryColor3svEXT)
@@ -22755,7 +22906,7 @@ GL_PREFIX(SecondaryColor3svEXT):
 GL_PREFIX(SecondaryColor3ubEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4840(%rax), %r11
+	movq	4864(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22765,13 +22916,13 @@ GL_PREFIX(SecondaryColor3ubEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4840(%rax), %r11
+	movq	4864(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4840(%rax), %r11
+	movq	4864(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22781,7 +22932,7 @@ GL_PREFIX(SecondaryColor3ubEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4840(%rax), %r11
+	movq	4864(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3ubEXT), .-GL_PREFIX(SecondaryColor3ubEXT)
@@ -22792,25 +22943,25 @@ GL_PREFIX(SecondaryColor3ubEXT):
 GL_PREFIX(SecondaryColor3ubvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4848(%rax), %r11
+	movq	4872(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4848(%rax), %r11
+	movq	4872(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4848(%rax), %r11
+	movq	4872(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4848(%rax), %r11
+	movq	4872(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3ubvEXT), .-GL_PREFIX(SecondaryColor3ubvEXT)
@@ -22821,7 +22972,7 @@ GL_PREFIX(SecondaryColor3ubvEXT):
 GL_PREFIX(SecondaryColor3uiEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4856(%rax), %r11
+	movq	4880(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22831,13 +22982,13 @@ GL_PREFIX(SecondaryColor3uiEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4856(%rax), %r11
+	movq	4880(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4856(%rax), %r11
+	movq	4880(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22847,7 +22998,7 @@ GL_PREFIX(SecondaryColor3uiEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4856(%rax), %r11
+	movq	4880(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3uiEXT), .-GL_PREFIX(SecondaryColor3uiEXT)
@@ -22858,25 +23009,25 @@ GL_PREFIX(SecondaryColor3uiEXT):
 GL_PREFIX(SecondaryColor3uivEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4864(%rax), %r11
+	movq	4888(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4864(%rax), %r11
+	movq	4888(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4864(%rax), %r11
+	movq	4888(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4864(%rax), %r11
+	movq	4888(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3uivEXT), .-GL_PREFIX(SecondaryColor3uivEXT)
@@ -22887,7 +23038,7 @@ GL_PREFIX(SecondaryColor3uivEXT):
 GL_PREFIX(SecondaryColor3usEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4872(%rax), %r11
+	movq	4896(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22897,13 +23048,13 @@ GL_PREFIX(SecondaryColor3usEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4872(%rax), %r11
+	movq	4896(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4872(%rax), %r11
+	movq	4896(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22913,7 +23064,7 @@ GL_PREFIX(SecondaryColor3usEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4872(%rax), %r11
+	movq	4896(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3usEXT), .-GL_PREFIX(SecondaryColor3usEXT)
@@ -22924,25 +23075,25 @@ GL_PREFIX(SecondaryColor3usEXT):
 GL_PREFIX(SecondaryColor3usvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4880(%rax), %r11
+	movq	4904(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4880(%rax), %r11
+	movq	4904(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4880(%rax), %r11
+	movq	4904(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4880(%rax), %r11
+	movq	4904(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3usvEXT), .-GL_PREFIX(SecondaryColor3usvEXT)
@@ -22953,7 +23104,7 @@ GL_PREFIX(SecondaryColor3usvEXT):
 GL_PREFIX(SecondaryColorPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4888(%rax), %r11
+	movq	4912(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22967,13 +23118,13 @@ GL_PREFIX(SecondaryColorPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4888(%rax), %r11
+	movq	4912(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4888(%rax), %r11
+	movq	4912(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22987,7 +23138,7 @@ GL_PREFIX(SecondaryColorPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4888(%rax), %r11
+	movq	4912(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColorPointerEXT), .-GL_PREFIX(SecondaryColorPointerEXT)
@@ -22998,7 +23149,7 @@ GL_PREFIX(SecondaryColorPointerEXT):
 GL_PREFIX(MultiDrawArraysEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4896(%rax), %r11
+	movq	4920(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23012,13 +23163,13 @@ GL_PREFIX(MultiDrawArraysEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4896(%rax), %r11
+	movq	4920(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4896(%rax), %r11
+	movq	4920(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23032,7 +23183,7 @@ GL_PREFIX(MultiDrawArraysEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4896(%rax), %r11
+	movq	4920(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(MultiDrawArraysEXT), .-GL_PREFIX(MultiDrawArraysEXT)
@@ -23043,7 +23194,7 @@ GL_PREFIX(MultiDrawArraysEXT):
 GL_PREFIX(MultiDrawElementsEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4904(%rax), %r11
+	movq	4928(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23057,13 +23208,13 @@ GL_PREFIX(MultiDrawElementsEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4904(%rax), %r11
+	movq	4928(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4904(%rax), %r11
+	movq	4928(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23077,7 +23228,7 @@ GL_PREFIX(MultiDrawElementsEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4904(%rax), %r11
+	movq	4928(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(MultiDrawElementsEXT), .-GL_PREFIX(MultiDrawElementsEXT)
@@ -23088,7 +23239,7 @@ GL_PREFIX(MultiDrawElementsEXT):
 GL_PREFIX(FogCoordPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4912(%rax), %r11
+	movq	4936(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23098,13 +23249,13 @@ GL_PREFIX(FogCoordPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4912(%rax), %r11
+	movq	4936(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4912(%rax), %r11
+	movq	4936(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23114,7 +23265,7 @@ GL_PREFIX(FogCoordPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4912(%rax), %r11
+	movq	4936(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoordPointerEXT), .-GL_PREFIX(FogCoordPointerEXT)
@@ -23125,7 +23276,7 @@ GL_PREFIX(FogCoordPointerEXT):
 GL_PREFIX(FogCoorddEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4920(%rax), %r11
+	movq	4944(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$8, %rsp
@@ -23133,13 +23284,13 @@ GL_PREFIX(FogCoorddEXT):
 	call	_x86_64_get_dispatch@PLT
 	movq	(%rsp), %xmm0
 	addq	$8, %rsp
-	movq	4920(%rax), %r11
+	movq	4944(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4920(%rax), %r11
+	movq	4944(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$8, %rsp
@@ -23147,7 +23298,7 @@ GL_PREFIX(FogCoorddEXT):
 	call	_glapi_get_dispatch
 	movq	(%rsp), %xmm0
 	addq	$8, %rsp
-	movq	4920(%rax), %r11
+	movq	4944(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoorddEXT), .-GL_PREFIX(FogCoorddEXT)
@@ -23158,25 +23309,25 @@ GL_PREFIX(FogCoorddEXT):
 GL_PREFIX(FogCoorddvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4928(%rax), %r11
+	movq	4952(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4928(%rax), %r11
+	movq	4952(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4928(%rax), %r11
+	movq	4952(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4928(%rax), %r11
+	movq	4952(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoorddvEXT), .-GL_PREFIX(FogCoorddvEXT)
@@ -23187,7 +23338,7 @@ GL_PREFIX(FogCoorddvEXT):
 GL_PREFIX(FogCoordfEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4936(%rax), %r11
+	movq	4960(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$8, %rsp
@@ -23195,13 +23346,13 @@ GL_PREFIX(FogCoordfEXT):
 	call	_x86_64_get_dispatch@PLT
 	movq	(%rsp), %xmm0
 	addq	$8, %rsp
-	movq	4936(%rax), %r11
+	movq	4960(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4936(%rax), %r11
+	movq	4960(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$8, %rsp
@@ -23209,7 +23360,7 @@ GL_PREFIX(FogCoordfEXT):
 	call	_glapi_get_dispatch
 	movq	(%rsp), %xmm0
 	addq	$8, %rsp
-	movq	4936(%rax), %r11
+	movq	4960(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoordfEXT), .-GL_PREFIX(FogCoordfEXT)
@@ -23220,58 +23371,58 @@ GL_PREFIX(FogCoordfEXT):
 GL_PREFIX(FogCoordfvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4944(%rax), %r11
+	movq	4968(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4944(%rax), %r11
+	movq	4968(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4944(%rax), %r11
+	movq	4968(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4944(%rax), %r11
+	movq	4968(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoordfvEXT), .-GL_PREFIX(FogCoordfvEXT)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_619)
-	.type	GL_PREFIX(_dispatch_stub_619), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_619))
-GL_PREFIX(_dispatch_stub_619):
+	.globl	GL_PREFIX(_dispatch_stub_622)
+	.type	GL_PREFIX(_dispatch_stub_622), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_622))
+GL_PREFIX(_dispatch_stub_622):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4952(%rax), %r11
+	movq	4976(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4952(%rax), %r11
+	movq	4976(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4952(%rax), %r11
+	movq	4976(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4952(%rax), %r11
+	movq	4976(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_619), .-GL_PREFIX(_dispatch_stub_619)
+	.size	GL_PREFIX(_dispatch_stub_622), .-GL_PREFIX(_dispatch_stub_622)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(BlendFuncSeparateEXT)
@@ -23279,7 +23430,7 @@ GL_PREFIX(_dispatch_stub_619):
 GL_PREFIX(BlendFuncSeparateEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4960(%rax), %r11
+	movq	4984(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23293,13 +23444,13 @@ GL_PREFIX(BlendFuncSeparateEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4960(%rax), %r11
+	movq	4984(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4960(%rax), %r11
+	movq	4984(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23313,7 +23464,7 @@ GL_PREFIX(BlendFuncSeparateEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4960(%rax), %r11
+	movq	4984(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BlendFuncSeparateEXT), .-GL_PREFIX(BlendFuncSeparateEXT)
@@ -23324,25 +23475,25 @@ GL_PREFIX(BlendFuncSeparateEXT):
 GL_PREFIX(FlushVertexArrayRangeNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4968(%rax), %r11
+	movq	4992(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	4968(%rax), %r11
+	movq	4992(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4968(%rax), %r11
+	movq	4992(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	4968(%rax), %r11
+	movq	4992(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FlushVertexArrayRangeNV), .-GL_PREFIX(FlushVertexArrayRangeNV)
@@ -23353,7 +23504,7 @@ GL_PREFIX(FlushVertexArrayRangeNV):
 GL_PREFIX(VertexArrayRangeNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4976(%rax), %r11
+	movq	5000(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23363,13 +23514,13 @@ GL_PREFIX(VertexArrayRangeNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4976(%rax), %r11
+	movq	5000(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4976(%rax), %r11
+	movq	5000(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23379,7 +23530,7 @@ GL_PREFIX(VertexArrayRangeNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4976(%rax), %r11
+	movq	5000(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexArrayRangeNV), .-GL_PREFIX(VertexArrayRangeNV)
@@ -23390,7 +23541,7 @@ GL_PREFIX(VertexArrayRangeNV):
 GL_PREFIX(CombinerInputNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4984(%rax), %r11
+	movq	5008(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23408,13 +23559,13 @@ GL_PREFIX(CombinerInputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4984(%rax), %r11
+	movq	5008(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4984(%rax), %r11
+	movq	5008(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23432,7 +23583,7 @@ GL_PREFIX(CombinerInputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4984(%rax), %r11
+	movq	5008(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerInputNV), .-GL_PREFIX(CombinerInputNV)
@@ -23443,7 +23594,7 @@ GL_PREFIX(CombinerInputNV):
 GL_PREFIX(CombinerOutputNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4992(%rax), %r11
+	movq	5016(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23461,13 +23612,13 @@ GL_PREFIX(CombinerOutputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4992(%rax), %r11
+	movq	5016(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4992(%rax), %r11
+	movq	5016(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23485,7 +23636,7 @@ GL_PREFIX(CombinerOutputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4992(%rax), %r11
+	movq	5016(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerOutputNV), .-GL_PREFIX(CombinerOutputNV)
@@ -23496,7 +23647,7 @@ GL_PREFIX(CombinerOutputNV):
 GL_PREFIX(CombinerParameterfNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5000(%rax), %r11
+	movq	5024(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -23506,13 +23657,13 @@ GL_PREFIX(CombinerParameterfNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5000(%rax), %r11
+	movq	5024(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5000(%rax), %r11
+	movq	5024(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -23522,7 +23673,7 @@ GL_PREFIX(CombinerParameterfNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5000(%rax), %r11
+	movq	5024(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerParameterfNV), .-GL_PREFIX(CombinerParameterfNV)
@@ -23533,7 +23684,7 @@ GL_PREFIX(CombinerParameterfNV):
 GL_PREFIX(CombinerParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5008(%rax), %r11
+	movq	5032(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23543,13 +23694,13 @@ GL_PREFIX(CombinerParameterfvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5008(%rax), %r11
+	movq	5032(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5008(%rax), %r11
+	movq	5032(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23559,7 +23710,7 @@ GL_PREFIX(CombinerParameterfvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5008(%rax), %r11
+	movq	5032(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerParameterfvNV), .-GL_PREFIX(CombinerParameterfvNV)
@@ -23570,7 +23721,7 @@ GL_PREFIX(CombinerParameterfvNV):
 GL_PREFIX(CombinerParameteriNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5016(%rax), %r11
+	movq	5040(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23580,13 +23731,13 @@ GL_PREFIX(CombinerParameteriNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5016(%rax), %r11
+	movq	5040(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5016(%rax), %r11
+	movq	5040(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23596,7 +23747,7 @@ GL_PREFIX(CombinerParameteriNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5016(%rax), %r11
+	movq	5040(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerParameteriNV), .-GL_PREFIX(CombinerParameteriNV)
@@ -23607,7 +23758,7 @@ GL_PREFIX(CombinerParameteriNV):
 GL_PREFIX(CombinerParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5024(%rax), %r11
+	movq	5048(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23617,13 +23768,13 @@ GL_PREFIX(CombinerParameterivNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5024(%rax), %r11
+	movq	5048(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5024(%rax), %r11
+	movq	5048(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23633,7 +23784,7 @@ GL_PREFIX(CombinerParameterivNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5024(%rax), %r11
+	movq	5048(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerParameterivNV), .-GL_PREFIX(CombinerParameterivNV)
@@ -23644,7 +23795,7 @@ GL_PREFIX(CombinerParameterivNV):
 GL_PREFIX(FinalCombinerInputNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5032(%rax), %r11
+	movq	5056(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23658,13 +23809,13 @@ GL_PREFIX(FinalCombinerInputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5032(%rax), %r11
+	movq	5056(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5032(%rax), %r11
+	movq	5056(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23678,7 +23829,7 @@ GL_PREFIX(FinalCombinerInputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5032(%rax), %r11
+	movq	5056(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FinalCombinerInputNV), .-GL_PREFIX(FinalCombinerInputNV)
@@ -23689,7 +23840,7 @@ GL_PREFIX(FinalCombinerInputNV):
 GL_PREFIX(GetCombinerInputParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5040(%rax), %r11
+	movq	5064(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23703,13 +23854,13 @@ GL_PREFIX(GetCombinerInputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5040(%rax), %r11
+	movq	5064(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5040(%rax), %r11
+	movq	5064(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23723,7 +23874,7 @@ GL_PREFIX(GetCombinerInputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5040(%rax), %r11
+	movq	5064(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetCombinerInputParameterfvNV), .-GL_PREFIX(GetCombinerInputParameterfvNV)
@@ -23734,7 +23885,7 @@ GL_PREFIX(GetCombinerInputParameterfvNV):
 GL_PREFIX(GetCombinerInputParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5048(%rax), %r11
+	movq	5072(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23748,13 +23899,13 @@ GL_PREFIX(GetCombinerInputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5048(%rax), %r11
+	movq	5072(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5048(%rax), %r11
+	movq	5072(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23768,7 +23919,7 @@ GL_PREFIX(GetCombinerInputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5048(%rax), %r11
+	movq	5072(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetCombinerInputParameterivNV), .-GL_PREFIX(GetCombinerInputParameterivNV)
@@ -23779,7 +23930,7 @@ GL_PREFIX(GetCombinerInputParameterivNV):
 GL_PREFIX(GetCombinerOutputParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5056(%rax), %r11
+	movq	5080(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23793,13 +23944,13 @@ GL_PREFIX(GetCombinerOutputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5056(%rax), %r11
+	movq	5080(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5056(%rax), %r11
+	movq	5080(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23813,7 +23964,7 @@ GL_PREFIX(GetCombinerOutputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5056(%rax), %r11
+	movq	5080(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetCombinerOutputParameterfvNV), .-GL_PREFIX(GetCombinerOutputParameterfvNV)
@@ -23824,7 +23975,7 @@ GL_PREFIX(GetCombinerOutputParameterfvNV):
 GL_PREFIX(GetCombinerOutputParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5064(%rax), %r11
+	movq	5088(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23838,13 +23989,13 @@ GL_PREFIX(GetCombinerOutputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5064(%rax), %r11
+	movq	5088(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5064(%rax), %r11
+	movq	5088(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23858,7 +24009,7 @@ GL_PREFIX(GetCombinerOutputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5064(%rax), %r11
+	movq	5088(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetCombinerOutputParameterivNV), .-GL_PREFIX(GetCombinerOutputParameterivNV)
@@ -23869,7 +24020,7 @@ GL_PREFIX(GetCombinerOutputParameterivNV):
 GL_PREFIX(GetFinalCombinerInputParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5072(%rax), %r11
+	movq	5096(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23879,13 +24030,13 @@ GL_PREFIX(GetFinalCombinerInputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5072(%rax), %r11
+	movq	5096(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5072(%rax), %r11
+	movq	5096(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23895,7 +24046,7 @@ GL_PREFIX(GetFinalCombinerInputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5072(%rax), %r11
+	movq	5096(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetFinalCombinerInputParameterfvNV), .-GL_PREFIX(GetFinalCombinerInputParameterfvNV)
@@ -23906,7 +24057,7 @@ GL_PREFIX(GetFinalCombinerInputParameterfvNV):
 GL_PREFIX(GetFinalCombinerInputParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5080(%rax), %r11
+	movq	5104(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23916,13 +24067,13 @@ GL_PREFIX(GetFinalCombinerInputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5080(%rax), %r11
+	movq	5104(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5080(%rax), %r11
+	movq	5104(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23932,7 +24083,7 @@ GL_PREFIX(GetFinalCombinerInputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5080(%rax), %r11
+	movq	5104(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetFinalCombinerInputParameterivNV), .-GL_PREFIX(GetFinalCombinerInputParameterivNV)
@@ -23943,25 +24094,25 @@ GL_PREFIX(GetFinalCombinerInputParameterivNV):
 GL_PREFIX(ResizeBuffersMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5088(%rax), %r11
+	movq	5112(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	5088(%rax), %r11
+	movq	5112(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5088(%rax), %r11
+	movq	5112(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	5088(%rax), %r11
+	movq	5112(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ResizeBuffersMESA), .-GL_PREFIX(ResizeBuffersMESA)
@@ -23972,7 +24123,7 @@ GL_PREFIX(ResizeBuffersMESA):
 GL_PREFIX(WindowPos2dMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5096(%rax), %r11
+	movq	5120(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -23982,13 +24133,13 @@ GL_PREFIX(WindowPos2dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5096(%rax), %r11
+	movq	5120(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5096(%rax), %r11
+	movq	5120(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -23998,7 +24149,7 @@ GL_PREFIX(WindowPos2dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5096(%rax), %r11
+	movq	5120(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2dMESA), .-GL_PREFIX(WindowPos2dMESA)
@@ -24009,25 +24160,25 @@ GL_PREFIX(WindowPos2dMESA):
 GL_PREFIX(WindowPos2dvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5104(%rax), %r11
+	movq	5128(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5104(%rax), %r11
+	movq	5128(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5104(%rax), %r11
+	movq	5128(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5104(%rax), %r11
+	movq	5128(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2dvMESA), .-GL_PREFIX(WindowPos2dvMESA)
@@ -24038,7 +24189,7 @@ GL_PREFIX(WindowPos2dvMESA):
 GL_PREFIX(WindowPos2fMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5112(%rax), %r11
+	movq	5136(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -24048,13 +24199,13 @@ GL_PREFIX(WindowPos2fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5112(%rax), %r11
+	movq	5136(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5112(%rax), %r11
+	movq	5136(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -24064,7 +24215,7 @@ GL_PREFIX(WindowPos2fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5112(%rax), %r11
+	movq	5136(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2fMESA), .-GL_PREFIX(WindowPos2fMESA)
@@ -24075,25 +24226,25 @@ GL_PREFIX(WindowPos2fMESA):
 GL_PREFIX(WindowPos2fvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5120(%rax), %r11
+	movq	5144(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5120(%rax), %r11
+	movq	5144(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5120(%rax), %r11
+	movq	5144(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5120(%rax), %r11
+	movq	5144(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2fvMESA), .-GL_PREFIX(WindowPos2fvMESA)
@@ -24104,7 +24255,7 @@ GL_PREFIX(WindowPos2fvMESA):
 GL_PREFIX(WindowPos2iMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5128(%rax), %r11
+	movq	5152(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24114,13 +24265,13 @@ GL_PREFIX(WindowPos2iMESA):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5128(%rax), %r11
+	movq	5152(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5128(%rax), %r11
+	movq	5152(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24130,7 +24281,7 @@ GL_PREFIX(WindowPos2iMESA):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5128(%rax), %r11
+	movq	5152(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2iMESA), .-GL_PREFIX(WindowPos2iMESA)
@@ -24141,25 +24292,25 @@ GL_PREFIX(WindowPos2iMESA):
 GL_PREFIX(WindowPos2ivMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5136(%rax), %r11
+	movq	5160(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5136(%rax), %r11
+	movq	5160(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5136(%rax), %r11
+	movq	5160(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5136(%rax), %r11
+	movq	5160(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2ivMESA), .-GL_PREFIX(WindowPos2ivMESA)
@@ -24170,7 +24321,7 @@ GL_PREFIX(WindowPos2ivMESA):
 GL_PREFIX(WindowPos2sMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5144(%rax), %r11
+	movq	5168(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24180,13 +24331,13 @@ GL_PREFIX(WindowPos2sMESA):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5144(%rax), %r11
+	movq	5168(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5144(%rax), %r11
+	movq	5168(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24196,7 +24347,7 @@ GL_PREFIX(WindowPos2sMESA):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5144(%rax), %r11
+	movq	5168(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2sMESA), .-GL_PREFIX(WindowPos2sMESA)
@@ -24207,25 +24358,25 @@ GL_PREFIX(WindowPos2sMESA):
 GL_PREFIX(WindowPos2svMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5152(%rax), %r11
+	movq	5176(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5152(%rax), %r11
+	movq	5176(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5152(%rax), %r11
+	movq	5176(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5152(%rax), %r11
+	movq	5176(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2svMESA), .-GL_PREFIX(WindowPos2svMESA)
@@ -24236,7 +24387,7 @@ GL_PREFIX(WindowPos2svMESA):
 GL_PREFIX(WindowPos3dMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5160(%rax), %r11
+	movq	5184(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -24248,13 +24399,13 @@ GL_PREFIX(WindowPos3dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5160(%rax), %r11
+	movq	5184(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5160(%rax), %r11
+	movq	5184(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -24266,7 +24417,7 @@ GL_PREFIX(WindowPos3dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5160(%rax), %r11
+	movq	5184(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3dMESA), .-GL_PREFIX(WindowPos3dMESA)
@@ -24277,25 +24428,25 @@ GL_PREFIX(WindowPos3dMESA):
 GL_PREFIX(WindowPos3dvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5168(%rax), %r11
+	movq	5192(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5168(%rax), %r11
+	movq	5192(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5168(%rax), %r11
+	movq	5192(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5168(%rax), %r11
+	movq	5192(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3dvMESA), .-GL_PREFIX(WindowPos3dvMESA)
@@ -24306,7 +24457,7 @@ GL_PREFIX(WindowPos3dvMESA):
 GL_PREFIX(WindowPos3fMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5176(%rax), %r11
+	movq	5200(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -24318,13 +24469,13 @@ GL_PREFIX(WindowPos3fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5176(%rax), %r11
+	movq	5200(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5176(%rax), %r11
+	movq	5200(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -24336,7 +24487,7 @@ GL_PREFIX(WindowPos3fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5176(%rax), %r11
+	movq	5200(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3fMESA), .-GL_PREFIX(WindowPos3fMESA)
@@ -24347,25 +24498,25 @@ GL_PREFIX(WindowPos3fMESA):
 GL_PREFIX(WindowPos3fvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5184(%rax), %r11
+	movq	5208(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5184(%rax), %r11
+	movq	5208(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5184(%rax), %r11
+	movq	5208(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5184(%rax), %r11
+	movq	5208(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3fvMESA), .-GL_PREFIX(WindowPos3fvMESA)
@@ -24376,7 +24527,7 @@ GL_PREFIX(WindowPos3fvMESA):
 GL_PREFIX(WindowPos3iMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5192(%rax), %r11
+	movq	5216(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24386,13 +24537,13 @@ GL_PREFIX(WindowPos3iMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5192(%rax), %r11
+	movq	5216(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5192(%rax), %r11
+	movq	5216(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24402,7 +24553,7 @@ GL_PREFIX(WindowPos3iMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5192(%rax), %r11
+	movq	5216(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3iMESA), .-GL_PREFIX(WindowPos3iMESA)
@@ -24413,25 +24564,25 @@ GL_PREFIX(WindowPos3iMESA):
 GL_PREFIX(WindowPos3ivMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5200(%rax), %r11
+	movq	5224(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5200(%rax), %r11
+	movq	5224(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5200(%rax), %r11
+	movq	5224(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5200(%rax), %r11
+	movq	5224(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3ivMESA), .-GL_PREFIX(WindowPos3ivMESA)
@@ -24442,7 +24593,7 @@ GL_PREFIX(WindowPos3ivMESA):
 GL_PREFIX(WindowPos3sMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5208(%rax), %r11
+	movq	5232(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24452,13 +24603,13 @@ GL_PREFIX(WindowPos3sMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5208(%rax), %r11
+	movq	5232(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5208(%rax), %r11
+	movq	5232(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24468,7 +24619,7 @@ GL_PREFIX(WindowPos3sMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5208(%rax), %r11
+	movq	5232(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3sMESA), .-GL_PREFIX(WindowPos3sMESA)
@@ -24479,25 +24630,25 @@ GL_PREFIX(WindowPos3sMESA):
 GL_PREFIX(WindowPos3svMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5216(%rax), %r11
+	movq	5240(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5216(%rax), %r11
+	movq	5240(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5216(%rax), %r11
+	movq	5240(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5216(%rax), %r11
+	movq	5240(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3svMESA), .-GL_PREFIX(WindowPos3svMESA)
@@ -24508,7 +24659,7 @@ GL_PREFIX(WindowPos3svMESA):
 GL_PREFIX(WindowPos4dMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5224(%rax), %r11
+	movq	5248(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -24522,13 +24673,13 @@ GL_PREFIX(WindowPos4dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$40, %rsp
-	movq	5224(%rax), %r11
+	movq	5248(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5224(%rax), %r11
+	movq	5248(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -24542,7 +24693,7 @@ GL_PREFIX(WindowPos4dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$40, %rsp
-	movq	5224(%rax), %r11
+	movq	5248(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4dMESA), .-GL_PREFIX(WindowPos4dMESA)
@@ -24553,25 +24704,25 @@ GL_PREFIX(WindowPos4dMESA):
 GL_PREFIX(WindowPos4dvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5232(%rax), %r11
+	movq	5256(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5232(%rax), %r11
+	movq	5256(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5232(%rax), %r11
+	movq	5256(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5232(%rax), %r11
+	movq	5256(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4dvMESA), .-GL_PREFIX(WindowPos4dvMESA)
@@ -24582,7 +24733,7 @@ GL_PREFIX(WindowPos4dvMESA):
 GL_PREFIX(WindowPos4fMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5240(%rax), %r11
+	movq	5264(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -24596,13 +24747,13 @@ GL_PREFIX(WindowPos4fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$40, %rsp
-	movq	5240(%rax), %r11
+	movq	5264(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5240(%rax), %r11
+	movq	5264(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -24616,7 +24767,7 @@ GL_PREFIX(WindowPos4fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$40, %rsp
-	movq	5240(%rax), %r11
+	movq	5264(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4fMESA), .-GL_PREFIX(WindowPos4fMESA)
@@ -24627,25 +24778,25 @@ GL_PREFIX(WindowPos4fMESA):
 GL_PREFIX(WindowPos4fvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5248(%rax), %r11
+	movq	5272(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5248(%rax), %r11
+	movq	5272(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5248(%rax), %r11
+	movq	5272(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5248(%rax), %r11
+	movq	5272(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4fvMESA), .-GL_PREFIX(WindowPos4fvMESA)
@@ -24656,7 +24807,7 @@ GL_PREFIX(WindowPos4fvMESA):
 GL_PREFIX(WindowPos4iMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5256(%rax), %r11
+	movq	5280(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24670,13 +24821,13 @@ GL_PREFIX(WindowPos4iMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5256(%rax), %r11
+	movq	5280(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5256(%rax), %r11
+	movq	5280(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24690,7 +24841,7 @@ GL_PREFIX(WindowPos4iMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5256(%rax), %r11
+	movq	5280(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4iMESA), .-GL_PREFIX(WindowPos4iMESA)
@@ -24701,25 +24852,25 @@ GL_PREFIX(WindowPos4iMESA):
 GL_PREFIX(WindowPos4ivMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5264(%rax), %r11
+	movq	5288(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5264(%rax), %r11
+	movq	5288(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5264(%rax), %r11
+	movq	5288(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5264(%rax), %r11
+	movq	5288(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4ivMESA), .-GL_PREFIX(WindowPos4ivMESA)
@@ -24730,7 +24881,7 @@ GL_PREFIX(WindowPos4ivMESA):
 GL_PREFIX(WindowPos4sMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5272(%rax), %r11
+	movq	5296(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24744,13 +24895,13 @@ GL_PREFIX(WindowPos4sMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5272(%rax), %r11
+	movq	5296(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5272(%rax), %r11
+	movq	5296(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24764,7 +24915,7 @@ GL_PREFIX(WindowPos4sMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5272(%rax), %r11
+	movq	5296(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4sMESA), .-GL_PREFIX(WindowPos4sMESA)
@@ -24775,37 +24926,37 @@ GL_PREFIX(WindowPos4sMESA):
 GL_PREFIX(WindowPos4svMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5280(%rax), %r11
+	movq	5304(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5280(%rax), %r11
+	movq	5304(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5280(%rax), %r11
+	movq	5304(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5280(%rax), %r11
+	movq	5304(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4svMESA), .-GL_PREFIX(WindowPos4svMESA)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_661)
-	.type	GL_PREFIX(_dispatch_stub_661), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_661))
-GL_PREFIX(_dispatch_stub_661):
+	.globl	GL_PREFIX(_dispatch_stub_664)
+	.type	GL_PREFIX(_dispatch_stub_664), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_664))
+GL_PREFIX(_dispatch_stub_664):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5288(%rax), %r11
+	movq	5312(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24819,13 +24970,13 @@ GL_PREFIX(_dispatch_stub_661):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5288(%rax), %r11
+	movq	5312(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5288(%rax), %r11
+	movq	5312(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24839,19 +24990,19 @@ GL_PREFIX(_dispatch_stub_661):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5288(%rax), %r11
+	movq	5312(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_661), .-GL_PREFIX(_dispatch_stub_661)
+	.size	GL_PREFIX(_dispatch_stub_664), .-GL_PREFIX(_dispatch_stub_664)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_662)
-	.type	GL_PREFIX(_dispatch_stub_662), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_662))
-GL_PREFIX(_dispatch_stub_662):
+	.globl	GL_PREFIX(_dispatch_stub_665)
+	.type	GL_PREFIX(_dispatch_stub_665), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_665))
+GL_PREFIX(_dispatch_stub_665):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5296(%rax), %r11
+	movq	5320(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24869,13 +25020,13 @@ GL_PREFIX(_dispatch_stub_662):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5296(%rax), %r11
+	movq	5320(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5296(%rax), %r11
+	movq	5320(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24893,19 +25044,19 @@ GL_PREFIX(_dispatch_stub_662):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5296(%rax), %r11
+	movq	5320(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_662), .-GL_PREFIX(_dispatch_stub_662)
+	.size	GL_PREFIX(_dispatch_stub_665), .-GL_PREFIX(_dispatch_stub_665)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_663)
-	.type	GL_PREFIX(_dispatch_stub_663), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_663))
-GL_PREFIX(_dispatch_stub_663):
+	.globl	GL_PREFIX(_dispatch_stub_666)
+	.type	GL_PREFIX(_dispatch_stub_666), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_666))
+GL_PREFIX(_dispatch_stub_666):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5304(%rax), %r11
+	movq	5328(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24915,13 +25066,13 @@ GL_PREFIX(_dispatch_stub_663):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5304(%rax), %r11
+	movq	5328(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5304(%rax), %r11
+	movq	5328(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24931,49 +25082,49 @@ GL_PREFIX(_dispatch_stub_663):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5304(%rax), %r11
+	movq	5328(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_663), .-GL_PREFIX(_dispatch_stub_663)
+	.size	GL_PREFIX(_dispatch_stub_666), .-GL_PREFIX(_dispatch_stub_666)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_664)
-	.type	GL_PREFIX(_dispatch_stub_664), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_664))
-GL_PREFIX(_dispatch_stub_664):
+	.globl	GL_PREFIX(_dispatch_stub_667)
+	.type	GL_PREFIX(_dispatch_stub_667), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_667))
+GL_PREFIX(_dispatch_stub_667):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5312(%rax), %r11
+	movq	5336(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5312(%rax), %r11
+	movq	5336(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5312(%rax), %r11
+	movq	5336(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5312(%rax), %r11
+	movq	5336(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_664), .-GL_PREFIX(_dispatch_stub_664)
+	.size	GL_PREFIX(_dispatch_stub_667), .-GL_PREFIX(_dispatch_stub_667)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_665)
-	.type	GL_PREFIX(_dispatch_stub_665), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_665))
-GL_PREFIX(_dispatch_stub_665):
+	.globl	GL_PREFIX(_dispatch_stub_668)
+	.type	GL_PREFIX(_dispatch_stub_668), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_668))
+GL_PREFIX(_dispatch_stub_668):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5320(%rax), %r11
+	movq	5344(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24983,13 +25134,13 @@ GL_PREFIX(_dispatch_stub_665):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5320(%rax), %r11
+	movq	5344(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5320(%rax), %r11
+	movq	5344(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24999,19 +25150,19 @@ GL_PREFIX(_dispatch_stub_665):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5320(%rax), %r11
+	movq	5344(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_665), .-GL_PREFIX(_dispatch_stub_665)
+	.size	GL_PREFIX(_dispatch_stub_668), .-GL_PREFIX(_dispatch_stub_668)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_666)
-	.type	GL_PREFIX(_dispatch_stub_666), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_666))
-GL_PREFIX(_dispatch_stub_666):
+	.globl	GL_PREFIX(_dispatch_stub_669)
+	.type	GL_PREFIX(_dispatch_stub_669), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_669))
+GL_PREFIX(_dispatch_stub_669):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5328(%rax), %r11
+	movq	5352(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25021,13 +25172,13 @@ GL_PREFIX(_dispatch_stub_666):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5328(%rax), %r11
+	movq	5352(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5328(%rax), %r11
+	movq	5352(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25037,49 +25188,49 @@ GL_PREFIX(_dispatch_stub_666):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5328(%rax), %r11
+	movq	5352(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_666), .-GL_PREFIX(_dispatch_stub_666)
+	.size	GL_PREFIX(_dispatch_stub_669), .-GL_PREFIX(_dispatch_stub_669)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_667)
-	.type	GL_PREFIX(_dispatch_stub_667), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_667))
-GL_PREFIX(_dispatch_stub_667):
+	.globl	GL_PREFIX(_dispatch_stub_670)
+	.type	GL_PREFIX(_dispatch_stub_670), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_670))
+GL_PREFIX(_dispatch_stub_670):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5336(%rax), %r11
+	movq	5360(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5336(%rax), %r11
+	movq	5360(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5336(%rax), %r11
+	movq	5360(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5336(%rax), %r11
+	movq	5360(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_667), .-GL_PREFIX(_dispatch_stub_667)
+	.size	GL_PREFIX(_dispatch_stub_670), .-GL_PREFIX(_dispatch_stub_670)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_668)
-	.type	GL_PREFIX(_dispatch_stub_668), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_668))
-GL_PREFIX(_dispatch_stub_668):
+	.globl	GL_PREFIX(_dispatch_stub_671)
+	.type	GL_PREFIX(_dispatch_stub_671), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_671))
+GL_PREFIX(_dispatch_stub_671):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5344(%rax), %r11
+	movq	5368(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25089,13 +25240,13 @@ GL_PREFIX(_dispatch_stub_668):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5344(%rax), %r11
+	movq	5368(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5344(%rax), %r11
+	movq	5368(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25105,40 +25256,40 @@ GL_PREFIX(_dispatch_stub_668):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5344(%rax), %r11
+	movq	5368(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_668), .-GL_PREFIX(_dispatch_stub_668)
+	.size	GL_PREFIX(_dispatch_stub_671), .-GL_PREFIX(_dispatch_stub_671)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_669)
-	.type	GL_PREFIX(_dispatch_stub_669), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_669))
-GL_PREFIX(_dispatch_stub_669):
+	.globl	GL_PREFIX(_dispatch_stub_672)
+	.type	GL_PREFIX(_dispatch_stub_672), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_672))
+GL_PREFIX(_dispatch_stub_672):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5352(%rax), %r11
+	movq	5376(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5352(%rax), %r11
+	movq	5376(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5352(%rax), %r11
+	movq	5376(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5352(%rax), %r11
+	movq	5376(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_669), .-GL_PREFIX(_dispatch_stub_669)
+	.size	GL_PREFIX(_dispatch_stub_672), .-GL_PREFIX(_dispatch_stub_672)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(AreProgramsResidentNV)
@@ -25146,7 +25297,7 @@ GL_PREFIX(_dispatch_stub_669):
 GL_PREFIX(AreProgramsResidentNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5360(%rax), %r11
+	movq	5384(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25156,13 +25307,13 @@ GL_PREFIX(AreProgramsResidentNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5360(%rax), %r11
+	movq	5384(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5360(%rax), %r11
+	movq	5384(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25172,7 +25323,7 @@ GL_PREFIX(AreProgramsResidentNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5360(%rax), %r11
+	movq	5384(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(AreProgramsResidentNV), .-GL_PREFIX(AreProgramsResidentNV)
@@ -25183,7 +25334,7 @@ GL_PREFIX(AreProgramsResidentNV):
 GL_PREFIX(BindProgramNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5368(%rax), %r11
+	movq	5392(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25193,13 +25344,13 @@ GL_PREFIX(BindProgramNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5368(%rax), %r11
+	movq	5392(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5368(%rax), %r11
+	movq	5392(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25209,7 +25360,7 @@ GL_PREFIX(BindProgramNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5368(%rax), %r11
+	movq	5392(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindProgramNV), .-GL_PREFIX(BindProgramNV)
@@ -25220,7 +25371,7 @@ GL_PREFIX(BindProgramNV):
 GL_PREFIX(DeleteProgramsNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5376(%rax), %r11
+	movq	5400(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25230,13 +25381,13 @@ GL_PREFIX(DeleteProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5376(%rax), %r11
+	movq	5400(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5376(%rax), %r11
+	movq	5400(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25246,7 +25397,7 @@ GL_PREFIX(DeleteProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5376(%rax), %r11
+	movq	5400(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteProgramsNV), .-GL_PREFIX(DeleteProgramsNV)
@@ -25257,7 +25408,7 @@ GL_PREFIX(DeleteProgramsNV):
 GL_PREFIX(ExecuteProgramNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5384(%rax), %r11
+	movq	5408(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25267,13 +25418,13 @@ GL_PREFIX(ExecuteProgramNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5384(%rax), %r11
+	movq	5408(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5384(%rax), %r11
+	movq	5408(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25283,7 +25434,7 @@ GL_PREFIX(ExecuteProgramNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5384(%rax), %r11
+	movq	5408(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ExecuteProgramNV), .-GL_PREFIX(ExecuteProgramNV)
@@ -25294,7 +25445,7 @@ GL_PREFIX(ExecuteProgramNV):
 GL_PREFIX(GenProgramsNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5392(%rax), %r11
+	movq	5416(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25304,13 +25455,13 @@ GL_PREFIX(GenProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5392(%rax), %r11
+	movq	5416(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5392(%rax), %r11
+	movq	5416(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25320,7 +25471,7 @@ GL_PREFIX(GenProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5392(%rax), %r11
+	movq	5416(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenProgramsNV), .-GL_PREFIX(GenProgramsNV)
@@ -25331,7 +25482,7 @@ GL_PREFIX(GenProgramsNV):
 GL_PREFIX(GetProgramParameterdvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5400(%rax), %r11
+	movq	5424(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25345,13 +25496,13 @@ GL_PREFIX(GetProgramParameterdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5400(%rax), %r11
+	movq	5424(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5400(%rax), %r11
+	movq	5424(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25365,7 +25516,7 @@ GL_PREFIX(GetProgramParameterdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5400(%rax), %r11
+	movq	5424(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramParameterdvNV), .-GL_PREFIX(GetProgramParameterdvNV)
@@ -25376,7 +25527,7 @@ GL_PREFIX(GetProgramParameterdvNV):
 GL_PREFIX(GetProgramParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5408(%rax), %r11
+	movq	5432(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25390,13 +25541,13 @@ GL_PREFIX(GetProgramParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5408(%rax), %r11
+	movq	5432(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5408(%rax), %r11
+	movq	5432(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25410,7 +25561,7 @@ GL_PREFIX(GetProgramParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5408(%rax), %r11
+	movq	5432(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramParameterfvNV), .-GL_PREFIX(GetProgramParameterfvNV)
@@ -25421,7 +25572,7 @@ GL_PREFIX(GetProgramParameterfvNV):
 GL_PREFIX(GetProgramStringNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5416(%rax), %r11
+	movq	5440(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25431,13 +25582,13 @@ GL_PREFIX(GetProgramStringNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5416(%rax), %r11
+	movq	5440(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5416(%rax), %r11
+	movq	5440(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25447,7 +25598,7 @@ GL_PREFIX(GetProgramStringNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5416(%rax), %r11
+	movq	5440(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramStringNV), .-GL_PREFIX(GetProgramStringNV)
@@ -25458,7 +25609,7 @@ GL_PREFIX(GetProgramStringNV):
 GL_PREFIX(GetProgramivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5424(%rax), %r11
+	movq	5448(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25468,13 +25619,13 @@ GL_PREFIX(GetProgramivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5424(%rax), %r11
+	movq	5448(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5424(%rax), %r11
+	movq	5448(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25484,7 +25635,7 @@ GL_PREFIX(GetProgramivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5424(%rax), %r11
+	movq	5448(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramivNV), .-GL_PREFIX(GetProgramivNV)
@@ -25495,7 +25646,7 @@ GL_PREFIX(GetProgramivNV):
 GL_PREFIX(GetTrackMatrixivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5432(%rax), %r11
+	movq	5456(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25509,13 +25660,13 @@ GL_PREFIX(GetTrackMatrixivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5432(%rax), %r11
+	movq	5456(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5432(%rax), %r11
+	movq	5456(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25529,7 +25680,7 @@ GL_PREFIX(GetTrackMatrixivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5432(%rax), %r11
+	movq	5456(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetTrackMatrixivNV), .-GL_PREFIX(GetTrackMatrixivNV)
@@ -25540,7 +25691,7 @@ GL_PREFIX(GetTrackMatrixivNV):
 GL_PREFIX(GetVertexAttribPointervNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5440(%rax), %r11
+	movq	5464(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25550,13 +25701,13 @@ GL_PREFIX(GetVertexAttribPointervNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5440(%rax), %r11
+	movq	5464(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5440(%rax), %r11
+	movq	5464(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25566,7 +25717,7 @@ GL_PREFIX(GetVertexAttribPointervNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5440(%rax), %r11
+	movq	5464(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribPointervNV), .-GL_PREFIX(GetVertexAttribPointervNV)
@@ -25577,7 +25728,7 @@ GL_PREFIX(GetVertexAttribPointervNV):
 GL_PREFIX(GetVertexAttribdvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5448(%rax), %r11
+	movq	5472(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25587,13 +25738,13 @@ GL_PREFIX(GetVertexAttribdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5448(%rax), %r11
+	movq	5472(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5448(%rax), %r11
+	movq	5472(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25603,7 +25754,7 @@ GL_PREFIX(GetVertexAttribdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5448(%rax), %r11
+	movq	5472(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribdvNV), .-GL_PREFIX(GetVertexAttribdvNV)
@@ -25614,7 +25765,7 @@ GL_PREFIX(GetVertexAttribdvNV):
 GL_PREFIX(GetVertexAttribfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5456(%rax), %r11
+	movq	5480(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25624,13 +25775,13 @@ GL_PREFIX(GetVertexAttribfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5456(%rax), %r11
+	movq	5480(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5456(%rax), %r11
+	movq	5480(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25640,7 +25791,7 @@ GL_PREFIX(GetVertexAttribfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5456(%rax), %r11
+	movq	5480(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribfvNV), .-GL_PREFIX(GetVertexAttribfvNV)
@@ -25651,7 +25802,7 @@ GL_PREFIX(GetVertexAttribfvNV):
 GL_PREFIX(GetVertexAttribivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5464(%rax), %r11
+	movq	5488(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25661,13 +25812,13 @@ GL_PREFIX(GetVertexAttribivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5464(%rax), %r11
+	movq	5488(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5464(%rax), %r11
+	movq	5488(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25677,7 +25828,7 @@ GL_PREFIX(GetVertexAttribivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5464(%rax), %r11
+	movq	5488(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribivNV), .-GL_PREFIX(GetVertexAttribivNV)
@@ -25688,25 +25839,25 @@ GL_PREFIX(GetVertexAttribivNV):
 GL_PREFIX(IsProgramNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5472(%rax), %r11
+	movq	5496(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5472(%rax), %r11
+	movq	5496(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5472(%rax), %r11
+	movq	5496(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5472(%rax), %r11
+	movq	5496(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsProgramNV), .-GL_PREFIX(IsProgramNV)
@@ -25717,7 +25868,7 @@ GL_PREFIX(IsProgramNV):
 GL_PREFIX(LoadProgramNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5480(%rax), %r11
+	movq	5504(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25731,13 +25882,13 @@ GL_PREFIX(LoadProgramNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5480(%rax), %r11
+	movq	5504(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5480(%rax), %r11
+	movq	5504(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25751,7 +25902,7 @@ GL_PREFIX(LoadProgramNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5480(%rax), %r11
+	movq	5504(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(LoadProgramNV), .-GL_PREFIX(LoadProgramNV)
@@ -25762,7 +25913,7 @@ GL_PREFIX(LoadProgramNV):
 GL_PREFIX(ProgramParameters4dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5488(%rax), %r11
+	movq	5512(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25776,13 +25927,13 @@ GL_PREFIX(ProgramParameters4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5488(%rax), %r11
+	movq	5512(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5488(%rax), %r11
+	movq	5512(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25796,7 +25947,7 @@ GL_PREFIX(ProgramParameters4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5488(%rax), %r11
+	movq	5512(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramParameters4dvNV), .-GL_PREFIX(ProgramParameters4dvNV)
@@ -25807,7 +25958,7 @@ GL_PREFIX(ProgramParameters4dvNV):
 GL_PREFIX(ProgramParameters4fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5496(%rax), %r11
+	movq	5520(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25821,13 +25972,13 @@ GL_PREFIX(ProgramParameters4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5496(%rax), %r11
+	movq	5520(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5496(%rax), %r11
+	movq	5520(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25841,7 +25992,7 @@ GL_PREFIX(ProgramParameters4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5496(%rax), %r11
+	movq	5520(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramParameters4fvNV), .-GL_PREFIX(ProgramParameters4fvNV)
@@ -25852,7 +26003,7 @@ GL_PREFIX(ProgramParameters4fvNV):
 GL_PREFIX(RequestResidentProgramsNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5504(%rax), %r11
+	movq	5528(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25862,13 +26013,13 @@ GL_PREFIX(RequestResidentProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5504(%rax), %r11
+	movq	5528(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5504(%rax), %r11
+	movq	5528(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25878,7 +26029,7 @@ GL_PREFIX(RequestResidentProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5504(%rax), %r11
+	movq	5528(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(RequestResidentProgramsNV), .-GL_PREFIX(RequestResidentProgramsNV)
@@ -25889,7 +26040,7 @@ GL_PREFIX(RequestResidentProgramsNV):
 GL_PREFIX(TrackMatrixNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5512(%rax), %r11
+	movq	5536(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25903,13 +26054,13 @@ GL_PREFIX(TrackMatrixNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5512(%rax), %r11
+	movq	5536(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5512(%rax), %r11
+	movq	5536(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25923,7 +26074,7 @@ GL_PREFIX(TrackMatrixNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5512(%rax), %r11
+	movq	5536(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(TrackMatrixNV), .-GL_PREFIX(TrackMatrixNV)
@@ -25934,7 +26085,7 @@ GL_PREFIX(TrackMatrixNV):
 GL_PREFIX(VertexAttrib1dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5520(%rax), %r11
+	movq	5544(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -25944,13 +26095,13 @@ GL_PREFIX(VertexAttrib1dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5520(%rax), %r11
+	movq	5544(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5520(%rax), %r11
+	movq	5544(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -25960,7 +26111,7 @@ GL_PREFIX(VertexAttrib1dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5520(%rax), %r11
+	movq	5544(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1dNV), .-GL_PREFIX(VertexAttrib1dNV)
@@ -25971,7 +26122,7 @@ GL_PREFIX(VertexAttrib1dNV):
 GL_PREFIX(VertexAttrib1dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5528(%rax), %r11
+	movq	5552(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25981,13 +26132,13 @@ GL_PREFIX(VertexAttrib1dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5528(%rax), %r11
+	movq	5552(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5528(%rax), %r11
+	movq	5552(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25997,7 +26148,7 @@ GL_PREFIX(VertexAttrib1dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5528(%rax), %r11
+	movq	5552(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1dvNV), .-GL_PREFIX(VertexAttrib1dvNV)
@@ -26008,7 +26159,7 @@ GL_PREFIX(VertexAttrib1dvNV):
 GL_PREFIX(VertexAttrib1fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5536(%rax), %r11
+	movq	5560(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -26018,13 +26169,13 @@ GL_PREFIX(VertexAttrib1fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5536(%rax), %r11
+	movq	5560(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5536(%rax), %r11
+	movq	5560(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -26034,7 +26185,7 @@ GL_PREFIX(VertexAttrib1fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5536(%rax), %r11
+	movq	5560(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1fNV), .-GL_PREFIX(VertexAttrib1fNV)
@@ -26045,7 +26196,7 @@ GL_PREFIX(VertexAttrib1fNV):
 GL_PREFIX(VertexAttrib1fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5544(%rax), %r11
+	movq	5568(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26055,13 +26206,13 @@ GL_PREFIX(VertexAttrib1fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5544(%rax), %r11
+	movq	5568(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5544(%rax), %r11
+	movq	5568(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26071,7 +26222,7 @@ GL_PREFIX(VertexAttrib1fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5544(%rax), %r11
+	movq	5568(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1fvNV), .-GL_PREFIX(VertexAttrib1fvNV)
@@ -26082,7 +26233,7 @@ GL_PREFIX(VertexAttrib1fvNV):
 GL_PREFIX(VertexAttrib1sNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5552(%rax), %r11
+	movq	5576(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26092,13 +26243,13 @@ GL_PREFIX(VertexAttrib1sNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5552(%rax), %r11
+	movq	5576(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5552(%rax), %r11
+	movq	5576(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26108,7 +26259,7 @@ GL_PREFIX(VertexAttrib1sNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5552(%rax), %r11
+	movq	5576(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1sNV), .-GL_PREFIX(VertexAttrib1sNV)
@@ -26119,7 +26270,7 @@ GL_PREFIX(VertexAttrib1sNV):
 GL_PREFIX(VertexAttrib1svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5560(%rax), %r11
+	movq	5584(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26129,13 +26280,13 @@ GL_PREFIX(VertexAttrib1svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5560(%rax), %r11
+	movq	5584(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5560(%rax), %r11
+	movq	5584(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26145,7 +26296,7 @@ GL_PREFIX(VertexAttrib1svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5560(%rax), %r11
+	movq	5584(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1svNV), .-GL_PREFIX(VertexAttrib1svNV)
@@ -26156,7 +26307,7 @@ GL_PREFIX(VertexAttrib1svNV):
 GL_PREFIX(VertexAttrib2dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5568(%rax), %r11
+	movq	5592(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -26168,13 +26319,13 @@ GL_PREFIX(VertexAttrib2dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5568(%rax), %r11
+	movq	5592(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5568(%rax), %r11
+	movq	5592(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -26186,7 +26337,7 @@ GL_PREFIX(VertexAttrib2dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5568(%rax), %r11
+	movq	5592(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2dNV), .-GL_PREFIX(VertexAttrib2dNV)
@@ -26197,7 +26348,7 @@ GL_PREFIX(VertexAttrib2dNV):
 GL_PREFIX(VertexAttrib2dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5576(%rax), %r11
+	movq	5600(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26207,13 +26358,13 @@ GL_PREFIX(VertexAttrib2dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5576(%rax), %r11
+	movq	5600(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5576(%rax), %r11
+	movq	5600(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26223,7 +26374,7 @@ GL_PREFIX(VertexAttrib2dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5576(%rax), %r11
+	movq	5600(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2dvNV), .-GL_PREFIX(VertexAttrib2dvNV)
@@ -26234,7 +26385,7 @@ GL_PREFIX(VertexAttrib2dvNV):
 GL_PREFIX(VertexAttrib2fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5584(%rax), %r11
+	movq	5608(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -26246,13 +26397,13 @@ GL_PREFIX(VertexAttrib2fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5584(%rax), %r11
+	movq	5608(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5584(%rax), %r11
+	movq	5608(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -26264,7 +26415,7 @@ GL_PREFIX(VertexAttrib2fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5584(%rax), %r11
+	movq	5608(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2fNV), .-GL_PREFIX(VertexAttrib2fNV)
@@ -26275,7 +26426,7 @@ GL_PREFIX(VertexAttrib2fNV):
 GL_PREFIX(VertexAttrib2fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5592(%rax), %r11
+	movq	5616(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26285,13 +26436,13 @@ GL_PREFIX(VertexAttrib2fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5592(%rax), %r11
+	movq	5616(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5592(%rax), %r11
+	movq	5616(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26301,7 +26452,7 @@ GL_PREFIX(VertexAttrib2fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5592(%rax), %r11
+	movq	5616(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2fvNV), .-GL_PREFIX(VertexAttrib2fvNV)
@@ -26312,7 +26463,7 @@ GL_PREFIX(VertexAttrib2fvNV):
 GL_PREFIX(VertexAttrib2sNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5600(%rax), %r11
+	movq	5624(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26322,13 +26473,13 @@ GL_PREFIX(VertexAttrib2sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5600(%rax), %r11
+	movq	5624(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5600(%rax), %r11
+	movq	5624(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26338,7 +26489,7 @@ GL_PREFIX(VertexAttrib2sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5600(%rax), %r11
+	movq	5624(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2sNV), .-GL_PREFIX(VertexAttrib2sNV)
@@ -26349,7 +26500,7 @@ GL_PREFIX(VertexAttrib2sNV):
 GL_PREFIX(VertexAttrib2svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5608(%rax), %r11
+	movq	5632(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26359,13 +26510,13 @@ GL_PREFIX(VertexAttrib2svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5608(%rax), %r11
+	movq	5632(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5608(%rax), %r11
+	movq	5632(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26375,7 +26526,7 @@ GL_PREFIX(VertexAttrib2svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5608(%rax), %r11
+	movq	5632(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2svNV), .-GL_PREFIX(VertexAttrib2svNV)
@@ -26386,7 +26537,7 @@ GL_PREFIX(VertexAttrib2svNV):
 GL_PREFIX(VertexAttrib3dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5616(%rax), %r11
+	movq	5640(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -26400,13 +26551,13 @@ GL_PREFIX(VertexAttrib3dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5616(%rax), %r11
+	movq	5640(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5616(%rax), %r11
+	movq	5640(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -26420,7 +26571,7 @@ GL_PREFIX(VertexAttrib3dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5616(%rax), %r11
+	movq	5640(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3dNV), .-GL_PREFIX(VertexAttrib3dNV)
@@ -26431,7 +26582,7 @@ GL_PREFIX(VertexAttrib3dNV):
 GL_PREFIX(VertexAttrib3dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5624(%rax), %r11
+	movq	5648(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26441,13 +26592,13 @@ GL_PREFIX(VertexAttrib3dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5624(%rax), %r11
+	movq	5648(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5624(%rax), %r11
+	movq	5648(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26457,7 +26608,7 @@ GL_PREFIX(VertexAttrib3dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5624(%rax), %r11
+	movq	5648(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3dvNV), .-GL_PREFIX(VertexAttrib3dvNV)
@@ -26468,7 +26619,7 @@ GL_PREFIX(VertexAttrib3dvNV):
 GL_PREFIX(VertexAttrib3fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5632(%rax), %r11
+	movq	5656(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -26482,13 +26633,13 @@ GL_PREFIX(VertexAttrib3fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5632(%rax), %r11
+	movq	5656(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5632(%rax), %r11
+	movq	5656(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -26502,7 +26653,7 @@ GL_PREFIX(VertexAttrib3fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5632(%rax), %r11
+	movq	5656(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3fNV), .-GL_PREFIX(VertexAttrib3fNV)
@@ -26513,7 +26664,7 @@ GL_PREFIX(VertexAttrib3fNV):
 GL_PREFIX(VertexAttrib3fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5640(%rax), %r11
+	movq	5664(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26523,13 +26674,13 @@ GL_PREFIX(VertexAttrib3fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5640(%rax), %r11
+	movq	5664(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5640(%rax), %r11
+	movq	5664(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26539,7 +26690,7 @@ GL_PREFIX(VertexAttrib3fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5640(%rax), %r11
+	movq	5664(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3fvNV), .-GL_PREFIX(VertexAttrib3fvNV)
@@ -26550,7 +26701,7 @@ GL_PREFIX(VertexAttrib3fvNV):
 GL_PREFIX(VertexAttrib3sNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5648(%rax), %r11
+	movq	5672(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26564,13 +26715,13 @@ GL_PREFIX(VertexAttrib3sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5648(%rax), %r11
+	movq	5672(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5648(%rax), %r11
+	movq	5672(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26584,7 +26735,7 @@ GL_PREFIX(VertexAttrib3sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5648(%rax), %r11
+	movq	5672(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3sNV), .-GL_PREFIX(VertexAttrib3sNV)
@@ -26595,7 +26746,7 @@ GL_PREFIX(VertexAttrib3sNV):
 GL_PREFIX(VertexAttrib3svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5656(%rax), %r11
+	movq	5680(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26605,13 +26756,13 @@ GL_PREFIX(VertexAttrib3svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5656(%rax), %r11
+	movq	5680(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5656(%rax), %r11
+	movq	5680(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26621,7 +26772,7 @@ GL_PREFIX(VertexAttrib3svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5656(%rax), %r11
+	movq	5680(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3svNV), .-GL_PREFIX(VertexAttrib3svNV)
@@ -26632,7 +26783,7 @@ GL_PREFIX(VertexAttrib3svNV):
 GL_PREFIX(VertexAttrib4dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5664(%rax), %r11
+	movq	5688(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -26648,13 +26799,13 @@ GL_PREFIX(VertexAttrib4dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5664(%rax), %r11
+	movq	5688(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5664(%rax), %r11
+	movq	5688(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -26670,7 +26821,7 @@ GL_PREFIX(VertexAttrib4dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5664(%rax), %r11
+	movq	5688(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4dNV), .-GL_PREFIX(VertexAttrib4dNV)
@@ -26681,7 +26832,7 @@ GL_PREFIX(VertexAttrib4dNV):
 GL_PREFIX(VertexAttrib4dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5672(%rax), %r11
+	movq	5696(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26691,13 +26842,13 @@ GL_PREFIX(VertexAttrib4dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5672(%rax), %r11
+	movq	5696(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5672(%rax), %r11
+	movq	5696(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26707,7 +26858,7 @@ GL_PREFIX(VertexAttrib4dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5672(%rax), %r11
+	movq	5696(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4dvNV), .-GL_PREFIX(VertexAttrib4dvNV)
@@ -26718,7 +26869,7 @@ GL_PREFIX(VertexAttrib4dvNV):
 GL_PREFIX(VertexAttrib4fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5680(%rax), %r11
+	movq	5704(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -26734,13 +26885,13 @@ GL_PREFIX(VertexAttrib4fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5680(%rax), %r11
+	movq	5704(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5680(%rax), %r11
+	movq	5704(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -26756,7 +26907,7 @@ GL_PREFIX(VertexAttrib4fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5680(%rax), %r11
+	movq	5704(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4fNV), .-GL_PREFIX(VertexAttrib4fNV)
@@ -26767,7 +26918,7 @@ GL_PREFIX(VertexAttrib4fNV):
 GL_PREFIX(VertexAttrib4fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5688(%rax), %r11
+	movq	5712(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26777,13 +26928,13 @@ GL_PREFIX(VertexAttrib4fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5688(%rax), %r11
+	movq	5712(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5688(%rax), %r11
+	movq	5712(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26793,7 +26944,7 @@ GL_PREFIX(VertexAttrib4fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5688(%rax), %r11
+	movq	5712(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4fvNV), .-GL_PREFIX(VertexAttrib4fvNV)
@@ -26804,7 +26955,7 @@ GL_PREFIX(VertexAttrib4fvNV):
 GL_PREFIX(VertexAttrib4sNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5696(%rax), %r11
+	movq	5720(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26818,13 +26969,13 @@ GL_PREFIX(VertexAttrib4sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5696(%rax), %r11
+	movq	5720(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5696(%rax), %r11
+	movq	5720(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26838,7 +26989,7 @@ GL_PREFIX(VertexAttrib4sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5696(%rax), %r11
+	movq	5720(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4sNV), .-GL_PREFIX(VertexAttrib4sNV)
@@ -26849,7 +27000,7 @@ GL_PREFIX(VertexAttrib4sNV):
 GL_PREFIX(VertexAttrib4svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5704(%rax), %r11
+	movq	5728(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26859,13 +27010,13 @@ GL_PREFIX(VertexAttrib4svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5704(%rax), %r11
+	movq	5728(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5704(%rax), %r11
+	movq	5728(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26875,7 +27026,7 @@ GL_PREFIX(VertexAttrib4svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5704(%rax), %r11
+	movq	5728(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4svNV), .-GL_PREFIX(VertexAttrib4svNV)
@@ -26886,7 +27037,7 @@ GL_PREFIX(VertexAttrib4svNV):
 GL_PREFIX(VertexAttrib4ubNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5712(%rax), %r11
+	movq	5736(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26900,13 +27051,13 @@ GL_PREFIX(VertexAttrib4ubNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5712(%rax), %r11
+	movq	5736(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5712(%rax), %r11
+	movq	5736(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26920,7 +27071,7 @@ GL_PREFIX(VertexAttrib4ubNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5712(%rax), %r11
+	movq	5736(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4ubNV), .-GL_PREFIX(VertexAttrib4ubNV)
@@ -26931,7 +27082,7 @@ GL_PREFIX(VertexAttrib4ubNV):
 GL_PREFIX(VertexAttrib4ubvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5720(%rax), %r11
+	movq	5744(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26941,13 +27092,13 @@ GL_PREFIX(VertexAttrib4ubvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5720(%rax), %r11
+	movq	5744(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5720(%rax), %r11
+	movq	5744(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26957,7 +27108,7 @@ GL_PREFIX(VertexAttrib4ubvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5720(%rax), %r11
+	movq	5744(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4ubvNV), .-GL_PREFIX(VertexAttrib4ubvNV)
@@ -26968,7 +27119,7 @@ GL_PREFIX(VertexAttrib4ubvNV):
 GL_PREFIX(VertexAttribPointerNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5728(%rax), %r11
+	movq	5752(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26982,13 +27133,13 @@ GL_PREFIX(VertexAttribPointerNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5728(%rax), %r11
+	movq	5752(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5728(%rax), %r11
+	movq	5752(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27002,7 +27153,7 @@ GL_PREFIX(VertexAttribPointerNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5728(%rax), %r11
+	movq	5752(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribPointerNV), .-GL_PREFIX(VertexAttribPointerNV)
@@ -27013,7 +27164,7 @@ GL_PREFIX(VertexAttribPointerNV):
 GL_PREFIX(VertexAttribs1dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5736(%rax), %r11
+	movq	5760(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27023,13 +27174,13 @@ GL_PREFIX(VertexAttribs1dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5736(%rax), %r11
+	movq	5760(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5736(%rax), %r11
+	movq	5760(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27039,7 +27190,7 @@ GL_PREFIX(VertexAttribs1dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5736(%rax), %r11
+	movq	5760(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs1dvNV), .-GL_PREFIX(VertexAttribs1dvNV)
@@ -27050,7 +27201,7 @@ GL_PREFIX(VertexAttribs1dvNV):
 GL_PREFIX(VertexAttribs1fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5744(%rax), %r11
+	movq	5768(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27060,13 +27211,13 @@ GL_PREFIX(VertexAttribs1fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5744(%rax), %r11
+	movq	5768(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5744(%rax), %r11
+	movq	5768(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27076,7 +27227,7 @@ GL_PREFIX(VertexAttribs1fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5744(%rax), %r11
+	movq	5768(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs1fvNV), .-GL_PREFIX(VertexAttribs1fvNV)
@@ -27087,7 +27238,7 @@ GL_PREFIX(VertexAttribs1fvNV):
 GL_PREFIX(VertexAttribs1svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5752(%rax), %r11
+	movq	5776(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27097,13 +27248,13 @@ GL_PREFIX(VertexAttribs1svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5752(%rax), %r11
+	movq	5776(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5752(%rax), %r11
+	movq	5776(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27113,7 +27264,7 @@ GL_PREFIX(VertexAttribs1svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5752(%rax), %r11
+	movq	5776(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs1svNV), .-GL_PREFIX(VertexAttribs1svNV)
@@ -27124,7 +27275,7 @@ GL_PREFIX(VertexAttribs1svNV):
 GL_PREFIX(VertexAttribs2dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5760(%rax), %r11
+	movq	5784(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27134,13 +27285,13 @@ GL_PREFIX(VertexAttribs2dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5760(%rax), %r11
+	movq	5784(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5760(%rax), %r11
+	movq	5784(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27150,7 +27301,7 @@ GL_PREFIX(VertexAttribs2dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5760(%rax), %r11
+	movq	5784(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs2dvNV), .-GL_PREFIX(VertexAttribs2dvNV)
@@ -27161,7 +27312,7 @@ GL_PREFIX(VertexAttribs2dvNV):
 GL_PREFIX(VertexAttribs2fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5768(%rax), %r11
+	movq	5792(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27171,13 +27322,13 @@ GL_PREFIX(VertexAttribs2fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5768(%rax), %r11
+	movq	5792(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5768(%rax), %r11
+	movq	5792(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27187,7 +27338,7 @@ GL_PREFIX(VertexAttribs2fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5768(%rax), %r11
+	movq	5792(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs2fvNV), .-GL_PREFIX(VertexAttribs2fvNV)
@@ -27198,7 +27349,7 @@ GL_PREFIX(VertexAttribs2fvNV):
 GL_PREFIX(VertexAttribs2svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5776(%rax), %r11
+	movq	5800(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27208,13 +27359,13 @@ GL_PREFIX(VertexAttribs2svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5776(%rax), %r11
+	movq	5800(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5776(%rax), %r11
+	movq	5800(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27224,7 +27375,7 @@ GL_PREFIX(VertexAttribs2svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5776(%rax), %r11
+	movq	5800(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs2svNV), .-GL_PREFIX(VertexAttribs2svNV)
@@ -27235,7 +27386,7 @@ GL_PREFIX(VertexAttribs2svNV):
 GL_PREFIX(VertexAttribs3dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5784(%rax), %r11
+	movq	5808(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27245,13 +27396,13 @@ GL_PREFIX(VertexAttribs3dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5784(%rax), %r11
+	movq	5808(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5784(%rax), %r11
+	movq	5808(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27261,7 +27412,7 @@ GL_PREFIX(VertexAttribs3dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5784(%rax), %r11
+	movq	5808(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs3dvNV), .-GL_PREFIX(VertexAttribs3dvNV)
@@ -27272,7 +27423,7 @@ GL_PREFIX(VertexAttribs3dvNV):
 GL_PREFIX(VertexAttribs3fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5792(%rax), %r11
+	movq	5816(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27282,13 +27433,13 @@ GL_PREFIX(VertexAttribs3fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5792(%rax), %r11
+	movq	5816(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5792(%rax), %r11
+	movq	5816(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27298,7 +27449,7 @@ GL_PREFIX(VertexAttribs3fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5792(%rax), %r11
+	movq	5816(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs3fvNV), .-GL_PREFIX(VertexAttribs3fvNV)
@@ -27309,7 +27460,7 @@ GL_PREFIX(VertexAttribs3fvNV):
 GL_PREFIX(VertexAttribs3svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5800(%rax), %r11
+	movq	5824(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27319,13 +27470,13 @@ GL_PREFIX(VertexAttribs3svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5800(%rax), %r11
+	movq	5824(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5800(%rax), %r11
+	movq	5824(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27335,7 +27486,7 @@ GL_PREFIX(VertexAttribs3svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5800(%rax), %r11
+	movq	5824(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs3svNV), .-GL_PREFIX(VertexAttribs3svNV)
@@ -27346,7 +27497,7 @@ GL_PREFIX(VertexAttribs3svNV):
 GL_PREFIX(VertexAttribs4dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5808(%rax), %r11
+	movq	5832(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27356,13 +27507,13 @@ GL_PREFIX(VertexAttribs4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5808(%rax), %r11
+	movq	5832(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5808(%rax), %r11
+	movq	5832(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27372,7 +27523,7 @@ GL_PREFIX(VertexAttribs4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5808(%rax), %r11
+	movq	5832(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs4dvNV), .-GL_PREFIX(VertexAttribs4dvNV)
@@ -27383,7 +27534,7 @@ GL_PREFIX(VertexAttribs4dvNV):
 GL_PREFIX(VertexAttribs4fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5816(%rax), %r11
+	movq	5840(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27393,13 +27544,13 @@ GL_PREFIX(VertexAttribs4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5816(%rax), %r11
+	movq	5840(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5816(%rax), %r11
+	movq	5840(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27409,7 +27560,7 @@ GL_PREFIX(VertexAttribs4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5816(%rax), %r11
+	movq	5840(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs4fvNV), .-GL_PREFIX(VertexAttribs4fvNV)
@@ -27420,7 +27571,7 @@ GL_PREFIX(VertexAttribs4fvNV):
 GL_PREFIX(VertexAttribs4svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5824(%rax), %r11
+	movq	5848(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27430,13 +27581,13 @@ GL_PREFIX(VertexAttribs4svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5824(%rax), %r11
+	movq	5848(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5824(%rax), %r11
+	movq	5848(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27446,7 +27597,7 @@ GL_PREFIX(VertexAttribs4svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5824(%rax), %r11
+	movq	5848(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs4svNV), .-GL_PREFIX(VertexAttribs4svNV)
@@ -27457,7 +27608,7 @@ GL_PREFIX(VertexAttribs4svNV):
 GL_PREFIX(VertexAttribs4ubvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5832(%rax), %r11
+	movq	5856(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27467,13 +27618,13 @@ GL_PREFIX(VertexAttribs4ubvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5832(%rax), %r11
+	movq	5856(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5832(%rax), %r11
+	movq	5856(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27483,7 +27634,7 @@ GL_PREFIX(VertexAttribs4ubvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5832(%rax), %r11
+	movq	5856(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs4ubvNV), .-GL_PREFIX(VertexAttribs4ubvNV)
@@ -27494,7 +27645,7 @@ GL_PREFIX(VertexAttribs4ubvNV):
 GL_PREFIX(GetTexBumpParameterfvATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5840(%rax), %r11
+	movq	5864(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27504,13 +27655,13 @@ GL_PREFIX(GetTexBumpParameterfvATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5840(%rax), %r11
+	movq	5864(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5840(%rax), %r11
+	movq	5864(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27520,7 +27671,7 @@ GL_PREFIX(GetTexBumpParameterfvATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5840(%rax), %r11
+	movq	5864(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetTexBumpParameterfvATI), .-GL_PREFIX(GetTexBumpParameterfvATI)
@@ -27531,7 +27682,7 @@ GL_PREFIX(GetTexBumpParameterfvATI):
 GL_PREFIX(GetTexBumpParameterivATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5848(%rax), %r11
+	movq	5872(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27541,13 +27692,13 @@ GL_PREFIX(GetTexBumpParameterivATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5848(%rax), %r11
+	movq	5872(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5848(%rax), %r11
+	movq	5872(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27557,7 +27708,7 @@ GL_PREFIX(GetTexBumpParameterivATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5848(%rax), %r11
+	movq	5872(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetTexBumpParameterivATI), .-GL_PREFIX(GetTexBumpParameterivATI)
@@ -27568,7 +27719,7 @@ GL_PREFIX(GetTexBumpParameterivATI):
 GL_PREFIX(TexBumpParameterfvATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5856(%rax), %r11
+	movq	5880(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27578,13 +27729,13 @@ GL_PREFIX(TexBumpParameterfvATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5856(%rax), %r11
+	movq	5880(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5856(%rax), %r11
+	movq	5880(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27594,7 +27745,7 @@ GL_PREFIX(TexBumpParameterfvATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5856(%rax), %r11
+	movq	5880(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(TexBumpParameterfvATI), .-GL_PREFIX(TexBumpParameterfvATI)
@@ -27605,7 +27756,7 @@ GL_PREFIX(TexBumpParameterfvATI):
 GL_PREFIX(TexBumpParameterivATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5864(%rax), %r11
+	movq	5888(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27615,13 +27766,13 @@ GL_PREFIX(TexBumpParameterivATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5864(%rax), %r11
+	movq	5888(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5864(%rax), %r11
+	movq	5888(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27631,7 +27782,7 @@ GL_PREFIX(TexBumpParameterivATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5864(%rax), %r11
+	movq	5888(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(TexBumpParameterivATI), .-GL_PREFIX(TexBumpParameterivATI)
@@ -27642,7 +27793,7 @@ GL_PREFIX(TexBumpParameterivATI):
 GL_PREFIX(AlphaFragmentOp1ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5872(%rax), %r11
+	movq	5896(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27660,13 +27811,13 @@ GL_PREFIX(AlphaFragmentOp1ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5872(%rax), %r11
+	movq	5896(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5872(%rax), %r11
+	movq	5896(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27684,7 +27835,7 @@ GL_PREFIX(AlphaFragmentOp1ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5872(%rax), %r11
+	movq	5896(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(AlphaFragmentOp1ATI), .-GL_PREFIX(AlphaFragmentOp1ATI)
@@ -27695,7 +27846,7 @@ GL_PREFIX(AlphaFragmentOp1ATI):
 GL_PREFIX(AlphaFragmentOp2ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5880(%rax), %r11
+	movq	5904(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27713,13 +27864,13 @@ GL_PREFIX(AlphaFragmentOp2ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5880(%rax), %r11
+	movq	5904(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5880(%rax), %r11
+	movq	5904(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27737,7 +27888,7 @@ GL_PREFIX(AlphaFragmentOp2ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5880(%rax), %r11
+	movq	5904(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(AlphaFragmentOp2ATI), .-GL_PREFIX(AlphaFragmentOp2ATI)
@@ -27748,7 +27899,7 @@ GL_PREFIX(AlphaFragmentOp2ATI):
 GL_PREFIX(AlphaFragmentOp3ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5888(%rax), %r11
+	movq	5912(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27766,13 +27917,13 @@ GL_PREFIX(AlphaFragmentOp3ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5888(%rax), %r11
+	movq	5912(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5888(%rax), %r11
+	movq	5912(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27790,7 +27941,7 @@ GL_PREFIX(AlphaFragmentOp3ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5888(%rax), %r11
+	movq	5912(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(AlphaFragmentOp3ATI), .-GL_PREFIX(AlphaFragmentOp3ATI)
@@ -27801,25 +27952,25 @@ GL_PREFIX(AlphaFragmentOp3ATI):
 GL_PREFIX(BeginFragmentShaderATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5896(%rax), %r11
+	movq	5920(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	5896(%rax), %r11
+	movq	5920(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5896(%rax), %r11
+	movq	5920(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	5896(%rax), %r11
+	movq	5920(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BeginFragmentShaderATI), .-GL_PREFIX(BeginFragmentShaderATI)
@@ -27830,25 +27981,25 @@ GL_PREFIX(BeginFragmentShaderATI):
 GL_PREFIX(BindFragmentShaderATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5904(%rax), %r11
+	movq	5928(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5904(%rax), %r11
+	movq	5928(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5904(%rax), %r11
+	movq	5928(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5904(%rax), %r11
+	movq	5928(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindFragmentShaderATI), .-GL_PREFIX(BindFragmentShaderATI)
@@ -27859,7 +28010,7 @@ GL_PREFIX(BindFragmentShaderATI):
 GL_PREFIX(ColorFragmentOp1ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5912(%rax), %r11
+	movq	5936(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27877,13 +28028,13 @@ GL_PREFIX(ColorFragmentOp1ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5912(%rax), %r11
+	movq	5936(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5912(%rax), %r11
+	movq	5936(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27901,7 +28052,7 @@ GL_PREFIX(ColorFragmentOp1ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5912(%rax), %r11
+	movq	5936(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ColorFragmentOp1ATI), .-GL_PREFIX(ColorFragmentOp1ATI)
@@ -27912,7 +28063,7 @@ GL_PREFIX(ColorFragmentOp1ATI):
 GL_PREFIX(ColorFragmentOp2ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5920(%rax), %r11
+	movq	5944(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27930,13 +28081,13 @@ GL_PREFIX(ColorFragmentOp2ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5920(%rax), %r11
+	movq	5944(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5920(%rax), %r11
+	movq	5944(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27954,7 +28105,7 @@ GL_PREFIX(ColorFragmentOp2ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5920(%rax), %r11
+	movq	5944(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ColorFragmentOp2ATI), .-GL_PREFIX(ColorFragmentOp2ATI)
@@ -27965,7 +28116,7 @@ GL_PREFIX(ColorFragmentOp2ATI):
 GL_PREFIX(ColorFragmentOp3ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5928(%rax), %r11
+	movq	5952(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27983,13 +28134,13 @@ GL_PREFIX(ColorFragmentOp3ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5928(%rax), %r11
+	movq	5952(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5928(%rax), %r11
+	movq	5952(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28007,7 +28158,7 @@ GL_PREFIX(ColorFragmentOp3ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5928(%rax), %r11
+	movq	5952(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ColorFragmentOp3ATI), .-GL_PREFIX(ColorFragmentOp3ATI)
@@ -28018,25 +28169,25 @@ GL_PREFIX(ColorFragmentOp3ATI):
 GL_PREFIX(DeleteFragmentShaderATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5936(%rax), %r11
+	movq	5960(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5936(%rax), %r11
+	movq	5960(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5936(%rax), %r11
+	movq	5960(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5936(%rax), %r11
+	movq	5960(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteFragmentShaderATI), .-GL_PREFIX(DeleteFragmentShaderATI)
@@ -28047,25 +28198,25 @@ GL_PREFIX(DeleteFragmentShaderATI):
 GL_PREFIX(EndFragmentShaderATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5944(%rax), %r11
+	movq	5968(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	5944(%rax), %r11
+	movq	5968(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5944(%rax), %r11
+	movq	5968(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	5944(%rax), %r11
+	movq	5968(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EndFragmentShaderATI), .-GL_PREFIX(EndFragmentShaderATI)
@@ -28076,25 +28227,25 @@ GL_PREFIX(EndFragmentShaderATI):
 GL_PREFIX(GenFragmentShadersATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5952(%rax), %r11
+	movq	5976(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5952(%rax), %r11
+	movq	5976(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5952(%rax), %r11
+	movq	5976(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5952(%rax), %r11
+	movq	5976(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenFragmentShadersATI), .-GL_PREFIX(GenFragmentShadersATI)
@@ -28105,7 +28256,7 @@ GL_PREFIX(GenFragmentShadersATI):
 GL_PREFIX(PassTexCoordATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5960(%rax), %r11
+	movq	5984(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28115,13 +28266,13 @@ GL_PREFIX(PassTexCoordATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5960(%rax), %r11
+	movq	5984(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5960(%rax), %r11
+	movq	5984(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28131,7 +28282,7 @@ GL_PREFIX(PassTexCoordATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5960(%rax), %r11
+	movq	5984(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PassTexCoordATI), .-GL_PREFIX(PassTexCoordATI)
@@ -28142,7 +28293,7 @@ GL_PREFIX(PassTexCoordATI):
 GL_PREFIX(SampleMapATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5968(%rax), %r11
+	movq	5992(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28152,13 +28303,13 @@ GL_PREFIX(SampleMapATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5968(%rax), %r11
+	movq	5992(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5968(%rax), %r11
+	movq	5992(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28168,7 +28319,7 @@ GL_PREFIX(SampleMapATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5968(%rax), %r11
+	movq	5992(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SampleMapATI), .-GL_PREFIX(SampleMapATI)
@@ -28179,7 +28330,7 @@ GL_PREFIX(SampleMapATI):
 GL_PREFIX(SetFragmentShaderConstantATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5976(%rax), %r11
+	movq	6000(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28189,13 +28340,13 @@ GL_PREFIX(SetFragmentShaderConstantATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5976(%rax), %r11
+	movq	6000(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5976(%rax), %r11
+	movq	6000(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28205,7 +28356,7 @@ GL_PREFIX(SetFragmentShaderConstantATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5976(%rax), %r11
+	movq	6000(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SetFragmentShaderConstantATI), .-GL_PREFIX(SetFragmentShaderConstantATI)
@@ -28216,7 +28367,7 @@ GL_PREFIX(SetFragmentShaderConstantATI):
 GL_PREFIX(PointParameteriNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5984(%rax), %r11
+	movq	6008(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28226,13 +28377,13 @@ GL_PREFIX(PointParameteriNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5984(%rax), %r11
+	movq	6008(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5984(%rax), %r11
+	movq	6008(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28242,7 +28393,7 @@ GL_PREFIX(PointParameteriNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5984(%rax), %r11
+	movq	6008(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PointParameteriNV), .-GL_PREFIX(PointParameteriNV)
@@ -28253,7 +28404,7 @@ GL_PREFIX(PointParameteriNV):
 GL_PREFIX(PointParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5992(%rax), %r11
+	movq	6016(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28263,13 +28414,13 @@ GL_PREFIX(PointParameterivNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5992(%rax), %r11
+	movq	6016(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5992(%rax), %r11
+	movq	6016(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28279,79 +28430,79 @@ GL_PREFIX(PointParameterivNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5992(%rax), %r11
+	movq	6016(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PointParameterivNV), .-GL_PREFIX(PointParameterivNV)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_750)
-	.type	GL_PREFIX(_dispatch_stub_750), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_750))
-GL_PREFIX(_dispatch_stub_750):
+	.globl	GL_PREFIX(_dispatch_stub_753)
+	.type	GL_PREFIX(_dispatch_stub_753), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_753))
+GL_PREFIX(_dispatch_stub_753):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6000(%rax), %r11
+	movq	6024(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6000(%rax), %r11
+	movq	6024(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6000(%rax), %r11
+	movq	6024(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6000(%rax), %r11
+	movq	6024(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_750), .-GL_PREFIX(_dispatch_stub_750)
+	.size	GL_PREFIX(_dispatch_stub_753), .-GL_PREFIX(_dispatch_stub_753)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_751)
-	.type	GL_PREFIX(_dispatch_stub_751), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_751))
-GL_PREFIX(_dispatch_stub_751):
+	.globl	GL_PREFIX(_dispatch_stub_754)
+	.type	GL_PREFIX(_dispatch_stub_754), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_754))
+GL_PREFIX(_dispatch_stub_754):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6008(%rax), %r11
+	movq	6032(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6008(%rax), %r11
+	movq	6032(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6008(%rax), %r11
+	movq	6032(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6008(%rax), %r11
+	movq	6032(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_751), .-GL_PREFIX(_dispatch_stub_751)
+	.size	GL_PREFIX(_dispatch_stub_754), .-GL_PREFIX(_dispatch_stub_754)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_752)
-	.type	GL_PREFIX(_dispatch_stub_752), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_752))
-GL_PREFIX(_dispatch_stub_752):
+	.globl	GL_PREFIX(_dispatch_stub_755)
+	.type	GL_PREFIX(_dispatch_stub_755), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_755))
+GL_PREFIX(_dispatch_stub_755):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6016(%rax), %r11
+	movq	6040(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28361,13 +28512,13 @@ GL_PREFIX(_dispatch_stub_752):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6016(%rax), %r11
+	movq	6040(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6016(%rax), %r11
+	movq	6040(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28377,19 +28528,19 @@ GL_PREFIX(_dispatch_stub_752):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6016(%rax), %r11
+	movq	6040(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_752), .-GL_PREFIX(_dispatch_stub_752)
+	.size	GL_PREFIX(_dispatch_stub_755), .-GL_PREFIX(_dispatch_stub_755)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_753)
-	.type	GL_PREFIX(_dispatch_stub_753), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_753))
-GL_PREFIX(_dispatch_stub_753):
+	.globl	GL_PREFIX(_dispatch_stub_756)
+	.type	GL_PREFIX(_dispatch_stub_756), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_756))
+GL_PREFIX(_dispatch_stub_756):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6024(%rax), %r11
+	movq	6048(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28399,13 +28550,13 @@ GL_PREFIX(_dispatch_stub_753):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6024(%rax), %r11
+	movq	6048(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6024(%rax), %r11
+	movq	6048(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28415,40 +28566,40 @@ GL_PREFIX(_dispatch_stub_753):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6024(%rax), %r11
+	movq	6048(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_753), .-GL_PREFIX(_dispatch_stub_753)
+	.size	GL_PREFIX(_dispatch_stub_756), .-GL_PREFIX(_dispatch_stub_756)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_754)
-	.type	GL_PREFIX(_dispatch_stub_754), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_754))
-GL_PREFIX(_dispatch_stub_754):
+	.globl	GL_PREFIX(_dispatch_stub_757)
+	.type	GL_PREFIX(_dispatch_stub_757), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_757))
+GL_PREFIX(_dispatch_stub_757):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6032(%rax), %r11
+	movq	6056(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6032(%rax), %r11
+	movq	6056(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6032(%rax), %r11
+	movq	6056(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6032(%rax), %r11
+	movq	6056(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_754), .-GL_PREFIX(_dispatch_stub_754)
+	.size	GL_PREFIX(_dispatch_stub_757), .-GL_PREFIX(_dispatch_stub_757)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(GetProgramNamedParameterdvNV)
@@ -28456,7 +28607,7 @@ GL_PREFIX(_dispatch_stub_754):
 GL_PREFIX(GetProgramNamedParameterdvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6040(%rax), %r11
+	movq	6064(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28470,13 +28621,13 @@ GL_PREFIX(GetProgramNamedParameterdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6040(%rax), %r11
+	movq	6064(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6040(%rax), %r11
+	movq	6064(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28490,7 +28641,7 @@ GL_PREFIX(GetProgramNamedParameterdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6040(%rax), %r11
+	movq	6064(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramNamedParameterdvNV), .-GL_PREFIX(GetProgramNamedParameterdvNV)
@@ -28501,7 +28652,7 @@ GL_PREFIX(GetProgramNamedParameterdvNV):
 GL_PREFIX(GetProgramNamedParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6048(%rax), %r11
+	movq	6072(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28515,13 +28666,13 @@ GL_PREFIX(GetProgramNamedParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6048(%rax), %r11
+	movq	6072(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6048(%rax), %r11
+	movq	6072(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28535,7 +28686,7 @@ GL_PREFIX(GetProgramNamedParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6048(%rax), %r11
+	movq	6072(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramNamedParameterfvNV), .-GL_PREFIX(GetProgramNamedParameterfvNV)
@@ -28546,7 +28697,7 @@ GL_PREFIX(GetProgramNamedParameterfvNV):
 GL_PREFIX(ProgramNamedParameter4dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6056(%rax), %r11
+	movq	6080(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$56, %rsp
@@ -28566,13 +28717,13 @@ GL_PREFIX(ProgramNamedParameter4dNV):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	6056(%rax), %r11
+	movq	6080(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6056(%rax), %r11
+	movq	6080(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$56, %rsp
@@ -28592,7 +28743,7 @@ GL_PREFIX(ProgramNamedParameter4dNV):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	6056(%rax), %r11
+	movq	6080(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramNamedParameter4dNV), .-GL_PREFIX(ProgramNamedParameter4dNV)
@@ -28603,7 +28754,7 @@ GL_PREFIX(ProgramNamedParameter4dNV):
 GL_PREFIX(ProgramNamedParameter4dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6064(%rax), %r11
+	movq	6088(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28617,13 +28768,13 @@ GL_PREFIX(ProgramNamedParameter4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6064(%rax), %r11
+	movq	6088(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6064(%rax), %r11
+	movq	6088(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28637,7 +28788,7 @@ GL_PREFIX(ProgramNamedParameter4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6064(%rax), %r11
+	movq	6088(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramNamedParameter4dvNV), .-GL_PREFIX(ProgramNamedParameter4dvNV)
@@ -28648,7 +28799,7 @@ GL_PREFIX(ProgramNamedParameter4dvNV):
 GL_PREFIX(ProgramNamedParameter4fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6072(%rax), %r11
+	movq	6096(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$56, %rsp
@@ -28668,13 +28819,13 @@ GL_PREFIX(ProgramNamedParameter4fNV):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	6072(%rax), %r11
+	movq	6096(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6072(%rax), %r11
+	movq	6096(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$56, %rsp
@@ -28694,7 +28845,7 @@ GL_PREFIX(ProgramNamedParameter4fNV):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	6072(%rax), %r11
+	movq	6096(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramNamedParameter4fNV), .-GL_PREFIX(ProgramNamedParameter4fNV)
@@ -28705,7 +28856,7 @@ GL_PREFIX(ProgramNamedParameter4fNV):
 GL_PREFIX(ProgramNamedParameter4fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6080(%rax), %r11
+	movq	6104(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28719,13 +28870,13 @@ GL_PREFIX(ProgramNamedParameter4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6080(%rax), %r11
+	movq	6104(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6080(%rax), %r11
+	movq	6104(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28739,19 +28890,19 @@ GL_PREFIX(ProgramNamedParameter4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6080(%rax), %r11
+	movq	6104(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramNamedParameter4fvNV), .-GL_PREFIX(ProgramNamedParameter4fvNV)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_761)
-	.type	GL_PREFIX(_dispatch_stub_761), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_761))
-GL_PREFIX(_dispatch_stub_761):
+	.globl	GL_PREFIX(_dispatch_stub_764)
+	.type	GL_PREFIX(_dispatch_stub_764), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_764))
+GL_PREFIX(_dispatch_stub_764):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6088(%rax), %r11
+	movq	6112(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28761,13 +28912,13 @@ GL_PREFIX(_dispatch_stub_761):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6088(%rax), %r11
+	movq	6112(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6088(%rax), %r11
+	movq	6112(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28777,19 +28928,19 @@ GL_PREFIX(_dispatch_stub_761):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6088(%rax), %r11
+	movq	6112(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_761), .-GL_PREFIX(_dispatch_stub_761)
+	.size	GL_PREFIX(_dispatch_stub_764), .-GL_PREFIX(_dispatch_stub_764)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_762)
-	.type	GL_PREFIX(_dispatch_stub_762), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_762))
-GL_PREFIX(_dispatch_stub_762):
+	.globl	GL_PREFIX(_dispatch_stub_765)
+	.type	GL_PREFIX(_dispatch_stub_765), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_765))
+GL_PREFIX(_dispatch_stub_765):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6096(%rax), %r11
+	movq	6120(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28799,13 +28950,13 @@ GL_PREFIX(_dispatch_stub_762):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6096(%rax), %r11
+	movq	6120(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6096(%rax), %r11
+	movq	6120(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28815,10 +28966,10 @@ GL_PREFIX(_dispatch_stub_762):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6096(%rax), %r11
+	movq	6120(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_762), .-GL_PREFIX(_dispatch_stub_762)
+	.size	GL_PREFIX(_dispatch_stub_765), .-GL_PREFIX(_dispatch_stub_765)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(BindFramebufferEXT)
@@ -28826,7 +28977,7 @@ GL_PREFIX(_dispatch_stub_762):
 GL_PREFIX(BindFramebufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6104(%rax), %r11
+	movq	6128(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28836,13 +28987,13 @@ GL_PREFIX(BindFramebufferEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6104(%rax), %r11
+	movq	6128(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6104(%rax), %r11
+	movq	6128(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28852,7 +29003,7 @@ GL_PREFIX(BindFramebufferEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6104(%rax), %r11
+	movq	6128(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindFramebufferEXT), .-GL_PREFIX(BindFramebufferEXT)
@@ -28863,7 +29014,7 @@ GL_PREFIX(BindFramebufferEXT):
 GL_PREFIX(BindRenderbufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6112(%rax), %r11
+	movq	6136(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28873,13 +29024,13 @@ GL_PREFIX(BindRenderbufferEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6112(%rax), %r11
+	movq	6136(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6112(%rax), %r11
+	movq	6136(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28889,7 +29040,7 @@ GL_PREFIX(BindRenderbufferEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6112(%rax), %r11
+	movq	6136(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindRenderbufferEXT), .-GL_PREFIX(BindRenderbufferEXT)
@@ -28900,25 +29051,25 @@ GL_PREFIX(BindRenderbufferEXT):
 GL_PREFIX(CheckFramebufferStatusEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6120(%rax), %r11
+	movq	6144(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6120(%rax), %r11
+	movq	6144(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6120(%rax), %r11
+	movq	6144(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6120(%rax), %r11
+	movq	6144(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CheckFramebufferStatusEXT), .-GL_PREFIX(CheckFramebufferStatusEXT)
@@ -28929,7 +29080,7 @@ GL_PREFIX(CheckFramebufferStatusEXT):
 GL_PREFIX(DeleteFramebuffersEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6128(%rax), %r11
+	movq	6152(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28939,13 +29090,13 @@ GL_PREFIX(DeleteFramebuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6128(%rax), %r11
+	movq	6152(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6128(%rax), %r11
+	movq	6152(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28955,7 +29106,7 @@ GL_PREFIX(DeleteFramebuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6128(%rax), %r11
+	movq	6152(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteFramebuffersEXT), .-GL_PREFIX(DeleteFramebuffersEXT)
@@ -28966,7 +29117,7 @@ GL_PREFIX(DeleteFramebuffersEXT):
 GL_PREFIX(DeleteRenderbuffersEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6136(%rax), %r11
+	movq	6160(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28976,13 +29127,13 @@ GL_PREFIX(DeleteRenderbuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6136(%rax), %r11
+	movq	6160(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6136(%rax), %r11
+	movq	6160(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28992,7 +29143,7 @@ GL_PREFIX(DeleteRenderbuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6136(%rax), %r11
+	movq	6160(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteRenderbuffersEXT), .-GL_PREFIX(DeleteRenderbuffersEXT)
@@ -29003,7 +29154,7 @@ GL_PREFIX(DeleteRenderbuffersEXT):
 GL_PREFIX(FramebufferRenderbufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6144(%rax), %r11
+	movq	6168(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29017,13 +29168,13 @@ GL_PREFIX(FramebufferRenderbufferEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6144(%rax), %r11
+	movq	6168(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6144(%rax), %r11
+	movq	6168(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29037,7 +29188,7 @@ GL_PREFIX(FramebufferRenderbufferEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6144(%rax), %r11
+	movq	6168(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferRenderbufferEXT), .-GL_PREFIX(FramebufferRenderbufferEXT)
@@ -29048,7 +29199,7 @@ GL_PREFIX(FramebufferRenderbufferEXT):
 GL_PREFIX(FramebufferTexture1DEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6152(%rax), %r11
+	movq	6176(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29062,13 +29213,13 @@ GL_PREFIX(FramebufferTexture1DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6152(%rax), %r11
+	movq	6176(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6152(%rax), %r11
+	movq	6176(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29082,7 +29233,7 @@ GL_PREFIX(FramebufferTexture1DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6152(%rax), %r11
+	movq	6176(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferTexture1DEXT), .-GL_PREFIX(FramebufferTexture1DEXT)
@@ -29093,7 +29244,7 @@ GL_PREFIX(FramebufferTexture1DEXT):
 GL_PREFIX(FramebufferTexture2DEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6160(%rax), %r11
+	movq	6184(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29107,13 +29258,13 @@ GL_PREFIX(FramebufferTexture2DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6160(%rax), %r11
+	movq	6184(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6160(%rax), %r11
+	movq	6184(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29127,7 +29278,7 @@ GL_PREFIX(FramebufferTexture2DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6160(%rax), %r11
+	movq	6184(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferTexture2DEXT), .-GL_PREFIX(FramebufferTexture2DEXT)
@@ -29138,7 +29289,7 @@ GL_PREFIX(FramebufferTexture2DEXT):
 GL_PREFIX(FramebufferTexture3DEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6168(%rax), %r11
+	movq	6192(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29156,13 +29307,13 @@ GL_PREFIX(FramebufferTexture3DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6168(%rax), %r11
+	movq	6192(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6168(%rax), %r11
+	movq	6192(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29180,7 +29331,7 @@ GL_PREFIX(FramebufferTexture3DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6168(%rax), %r11
+	movq	6192(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferTexture3DEXT), .-GL_PREFIX(FramebufferTexture3DEXT)
@@ -29191,7 +29342,7 @@ GL_PREFIX(FramebufferTexture3DEXT):
 GL_PREFIX(GenFramebuffersEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6176(%rax), %r11
+	movq	6200(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29201,13 +29352,13 @@ GL_PREFIX(GenFramebuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6176(%rax), %r11
+	movq	6200(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6176(%rax), %r11
+	movq	6200(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29217,7 +29368,7 @@ GL_PREFIX(GenFramebuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6176(%rax), %r11
+	movq	6200(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenFramebuffersEXT), .-GL_PREFIX(GenFramebuffersEXT)
@@ -29228,7 +29379,7 @@ GL_PREFIX(GenFramebuffersEXT):
 GL_PREFIX(GenRenderbuffersEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6184(%rax), %r11
+	movq	6208(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29238,13 +29389,13 @@ GL_PREFIX(GenRenderbuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6184(%rax), %r11
+	movq	6208(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6184(%rax), %r11
+	movq	6208(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29254,7 +29405,7 @@ GL_PREFIX(GenRenderbuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6184(%rax), %r11
+	movq	6208(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenRenderbuffersEXT), .-GL_PREFIX(GenRenderbuffersEXT)
@@ -29265,25 +29416,25 @@ GL_PREFIX(GenRenderbuffersEXT):
 GL_PREFIX(GenerateMipmapEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6192(%rax), %r11
+	movq	6216(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6192(%rax), %r11
+	movq	6216(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6192(%rax), %r11
+	movq	6216(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6192(%rax), %r11
+	movq	6216(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenerateMipmapEXT), .-GL_PREFIX(GenerateMipmapEXT)
@@ -29294,7 +29445,7 @@ GL_PREFIX(GenerateMipmapEXT):
 GL_PREFIX(GetFramebufferAttachmentParameterivEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6200(%rax), %r11
+	movq	6224(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29308,13 +29459,13 @@ GL_PREFIX(GetFramebufferAttachmentParameterivEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6200(%rax), %r11
+	movq	6224(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6200(%rax), %r11
+	movq	6224(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29328,7 +29479,7 @@ GL_PREFIX(GetFramebufferAttachmentParameterivEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6200(%rax), %r11
+	movq	6224(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetFramebufferAttachmentParameterivEXT), .-GL_PREFIX(GetFramebufferAttachmentParameterivEXT)
@@ -29339,7 +29490,7 @@ GL_PREFIX(GetFramebufferAttachmentParameterivEXT):
 GL_PREFIX(GetRenderbufferParameterivEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6208(%rax), %r11
+	movq	6232(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29349,13 +29500,13 @@ GL_PREFIX(GetRenderbufferParameterivEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6208(%rax), %r11
+	movq	6232(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6208(%rax), %r11
+	movq	6232(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29365,7 +29516,7 @@ GL_PREFIX(GetRenderbufferParameterivEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6208(%rax), %r11
+	movq	6232(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetRenderbufferParameterivEXT), .-GL_PREFIX(GetRenderbufferParameterivEXT)
@@ -29376,25 +29527,25 @@ GL_PREFIX(GetRenderbufferParameterivEXT):
 GL_PREFIX(IsFramebufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6216(%rax), %r11
+	movq	6240(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6216(%rax), %r11
+	movq	6240(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6216(%rax), %r11
+	movq	6240(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6216(%rax), %r11
+	movq	6240(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsFramebufferEXT), .-GL_PREFIX(IsFramebufferEXT)
@@ -29405,25 +29556,25 @@ GL_PREFIX(IsFramebufferEXT):
 GL_PREFIX(IsRenderbufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6224(%rax), %r11
+	movq	6248(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6224(%rax), %r11
+	movq	6248(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6224(%rax), %r11
+	movq	6248(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6224(%rax), %r11
+	movq	6248(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsRenderbufferEXT), .-GL_PREFIX(IsRenderbufferEXT)
@@ -29434,7 +29585,7 @@ GL_PREFIX(IsRenderbufferEXT):
 GL_PREFIX(RenderbufferStorageEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6232(%rax), %r11
+	movq	6256(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29448,13 +29599,13 @@ GL_PREFIX(RenderbufferStorageEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6232(%rax), %r11
+	movq	6256(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6232(%rax), %r11
+	movq	6256(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29468,19 +29619,19 @@ GL_PREFIX(RenderbufferStorageEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6232(%rax), %r11
+	movq	6256(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(RenderbufferStorageEXT), .-GL_PREFIX(RenderbufferStorageEXT)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_780)
-	.type	GL_PREFIX(_dispatch_stub_780), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_780))
-GL_PREFIX(_dispatch_stub_780):
+	.globl	GL_PREFIX(_dispatch_stub_783)
+	.type	GL_PREFIX(_dispatch_stub_783), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_783))
+GL_PREFIX(_dispatch_stub_783):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6240(%rax), %r11
+	movq	6264(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29498,13 +29649,13 @@ GL_PREFIX(_dispatch_stub_780):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6240(%rax), %r11
+	movq	6264(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6240(%rax), %r11
+	movq	6264(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29522,19 +29673,19 @@ GL_PREFIX(_dispatch_stub_780):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6240(%rax), %r11
+	movq	6264(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_780), .-GL_PREFIX(_dispatch_stub_780)
+	.size	GL_PREFIX(_dispatch_stub_783), .-GL_PREFIX(_dispatch_stub_783)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_781)
-	.type	GL_PREFIX(_dispatch_stub_781), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_781))
-GL_PREFIX(_dispatch_stub_781):
+	.globl	GL_PREFIX(_dispatch_stub_784)
+	.type	GL_PREFIX(_dispatch_stub_784), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_784))
+GL_PREFIX(_dispatch_stub_784):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6248(%rax), %r11
+	movq	6272(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29544,13 +29695,13 @@ GL_PREFIX(_dispatch_stub_781):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6248(%rax), %r11
+	movq	6272(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6248(%rax), %r11
+	movq	6272(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29560,19 +29711,19 @@ GL_PREFIX(_dispatch_stub_781):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6248(%rax), %r11
+	movq	6272(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_781), .-GL_PREFIX(_dispatch_stub_781)
+	.size	GL_PREFIX(_dispatch_stub_784), .-GL_PREFIX(_dispatch_stub_784)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_782)
-	.type	GL_PREFIX(_dispatch_stub_782), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_782))
-GL_PREFIX(_dispatch_stub_782):
+	.globl	GL_PREFIX(_dispatch_stub_785)
+	.type	GL_PREFIX(_dispatch_stub_785), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_785))
+GL_PREFIX(_dispatch_stub_785):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6256(%rax), %r11
+	movq	6280(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29582,13 +29733,13 @@ GL_PREFIX(_dispatch_stub_782):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6256(%rax), %r11
+	movq	6280(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6256(%rax), %r11
+	movq	6280(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29598,10 +29749,10 @@ GL_PREFIX(_dispatch_stub_782):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6256(%rax), %r11
+	movq	6280(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_782), .-GL_PREFIX(_dispatch_stub_782)
+	.size	GL_PREFIX(_dispatch_stub_785), .-GL_PREFIX(_dispatch_stub_785)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(FramebufferTextureLayerEXT)
@@ -29609,7 +29760,7 @@ GL_PREFIX(_dispatch_stub_782):
 GL_PREFIX(FramebufferTextureLayerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6264(%rax), %r11
+	movq	6288(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29623,13 +29774,13 @@ GL_PREFIX(FramebufferTextureLayerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6264(%rax), %r11
+	movq	6288(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6264(%rax), %r11
+	movq	6288(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29643,7 +29794,7 @@ GL_PREFIX(FramebufferTextureLayerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6264(%rax), %r11
+	movq	6288(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferTextureLayerEXT), .-GL_PREFIX(FramebufferTextureLayerEXT)
@@ -29654,37 +29805,37 @@ GL_PREFIX(FramebufferTextureLayerEXT):
 GL_PREFIX(ProvokingVertexEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6272(%rax), %r11
+	movq	6296(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6272(%rax), %r11
+	movq	6296(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6272(%rax), %r11
+	movq	6296(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6272(%rax), %r11
+	movq	6296(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProvokingVertexEXT), .-GL_PREFIX(ProvokingVertexEXT)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_785)
-	.type	GL_PREFIX(_dispatch_stub_785), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_785))
-GL_PREFIX(_dispatch_stub_785):
+	.globl	GL_PREFIX(_dispatch_stub_788)
+	.type	GL_PREFIX(_dispatch_stub_788), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_788))
+GL_PREFIX(_dispatch_stub_788):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6280(%rax), %r11
+	movq	6304(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29694,13 +29845,13 @@ GL_PREFIX(_dispatch_stub_785):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6280(%rax), %r11
+	movq	6304(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6280(%rax), %r11
+	movq	6304(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29710,19 +29861,19 @@ GL_PREFIX(_dispatch_stub_785):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6280(%rax), %r11
+	movq	6304(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_785), .-GL_PREFIX(_dispatch_stub_785)
+	.size	GL_PREFIX(_dispatch_stub_788), .-GL_PREFIX(_dispatch_stub_788)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_786)
-	.type	GL_PREFIX(_dispatch_stub_786), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_786))
-GL_PREFIX(_dispatch_stub_786):
+	.globl	GL_PREFIX(_dispatch_stub_789)
+	.type	GL_PREFIX(_dispatch_stub_789), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_789))
+GL_PREFIX(_dispatch_stub_789):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6288(%rax), %r11
+	movq	6312(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29732,13 +29883,13 @@ GL_PREFIX(_dispatch_stub_786):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6288(%rax), %r11
+	movq	6312(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6288(%rax), %r11
+	movq	6312(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29748,19 +29899,19 @@ GL_PREFIX(_dispatch_stub_786):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6288(%rax), %r11
+	movq	6312(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_786), .-GL_PREFIX(_dispatch_stub_786)
+	.size	GL_PREFIX(_dispatch_stub_789), .-GL_PREFIX(_dispatch_stub_789)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_787)
-	.type	GL_PREFIX(_dispatch_stub_787), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_787))
-GL_PREFIX(_dispatch_stub_787):
+	.globl	GL_PREFIX(_dispatch_stub_790)
+	.type	GL_PREFIX(_dispatch_stub_790), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_790))
+GL_PREFIX(_dispatch_stub_790):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6296(%rax), %r11
+	movq	6320(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29774,13 +29925,13 @@ GL_PREFIX(_dispatch_stub_787):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6296(%rax), %r11
+	movq	6320(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6296(%rax), %r11
+	movq	6320(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29794,19 +29945,19 @@ GL_PREFIX(_dispatch_stub_787):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6296(%rax), %r11
+	movq	6320(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_787), .-GL_PREFIX(_dispatch_stub_787)
+	.size	GL_PREFIX(_dispatch_stub_790), .-GL_PREFIX(_dispatch_stub_790)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_788)
-	.type	GL_PREFIX(_dispatch_stub_788), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_788))
-GL_PREFIX(_dispatch_stub_788):
+	.globl	GL_PREFIX(_dispatch_stub_791)
+	.type	GL_PREFIX(_dispatch_stub_791), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_791))
+GL_PREFIX(_dispatch_stub_791):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6304(%rax), %r11
+	movq	6328(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29820,13 +29971,13 @@ GL_PREFIX(_dispatch_stub_788):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6304(%rax), %r11
+	movq	6328(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6304(%rax), %r11
+	movq	6328(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29840,19 +29991,19 @@ GL_PREFIX(_dispatch_stub_788):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6304(%rax), %r11
+	movq	6328(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_788), .-GL_PREFIX(_dispatch_stub_788)
+	.size	GL_PREFIX(_dispatch_stub_791), .-GL_PREFIX(_dispatch_stub_791)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_789)
-	.type	GL_PREFIX(_dispatch_stub_789), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_789))
-GL_PREFIX(_dispatch_stub_789):
+	.globl	GL_PREFIX(_dispatch_stub_792)
+	.type	GL_PREFIX(_dispatch_stub_792), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_792))
+GL_PREFIX(_dispatch_stub_792):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6312(%rax), %r11
+	movq	6336(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29866,13 +30017,13 @@ GL_PREFIX(_dispatch_stub_789):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6312(%rax), %r11
+	movq	6336(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6312(%rax), %r11
+	movq	6336(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29886,19 +30037,19 @@ GL_PREFIX(_dispatch_stub_789):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6312(%rax), %r11
+	movq	6336(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_789), .-GL_PREFIX(_dispatch_stub_789)
+	.size	GL_PREFIX(_dispatch_stub_792), .-GL_PREFIX(_dispatch_stub_792)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_790)
-	.type	GL_PREFIX(_dispatch_stub_790), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_790))
-GL_PREFIX(_dispatch_stub_790):
+	.globl	GL_PREFIX(_dispatch_stub_793)
+	.type	GL_PREFIX(_dispatch_stub_793), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_793))
+GL_PREFIX(_dispatch_stub_793):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6320(%rax), %r11
+	movq	6344(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29908,13 +30059,13 @@ GL_PREFIX(_dispatch_stub_790):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6320(%rax), %r11
+	movq	6344(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6320(%rax), %r11
+	movq	6344(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29924,19 +30075,19 @@ GL_PREFIX(_dispatch_stub_790):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6320(%rax), %r11
+	movq	6344(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_790), .-GL_PREFIX(_dispatch_stub_790)
+	.size	GL_PREFIX(_dispatch_stub_793), .-GL_PREFIX(_dispatch_stub_793)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_791)
-	.type	GL_PREFIX(_dispatch_stub_791), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_791))
-GL_PREFIX(_dispatch_stub_791):
+	.globl	GL_PREFIX(_dispatch_stub_794)
+	.type	GL_PREFIX(_dispatch_stub_794), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_794))
+GL_PREFIX(_dispatch_stub_794):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6328(%rax), %r11
+	movq	6352(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29946,13 +30097,13 @@ GL_PREFIX(_dispatch_stub_791):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6328(%rax), %r11
+	movq	6352(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6328(%rax), %r11
+	movq	6352(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29962,10 +30113,10 @@ GL_PREFIX(_dispatch_stub_791):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6328(%rax), %r11
+	movq	6352(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_791), .-GL_PREFIX(_dispatch_stub_791)
+	.size	GL_PREFIX(_dispatch_stub_794), .-GL_PREFIX(_dispatch_stub_794)
 
 	.globl GL_PREFIX(ArrayElementEXT) ; .set GL_PREFIX(ArrayElementEXT), GL_PREFIX(ArrayElement)
 	.globl GL_PREFIX(BindTextureEXT) ; .set GL_PREFIX(BindTextureEXT), GL_PREFIX(BindTexture)
@@ -30220,9 +30371,9 @@ GL_PREFIX(_dispatch_stub_791):
 	.globl GL_PREFIX(IsProgramARB) ; .set GL_PREFIX(IsProgramARB), GL_PREFIX(IsProgramNV)
 	.globl GL_PREFIX(PointParameteri) ; .set GL_PREFIX(PointParameteri), GL_PREFIX(PointParameteriNV)
 	.globl GL_PREFIX(PointParameteriv) ; .set GL_PREFIX(PointParameteriv), GL_PREFIX(PointParameterivNV)
-	.globl GL_PREFIX(DeleteVertexArrays) ; .set GL_PREFIX(DeleteVertexArrays), GL_PREFIX(_dispatch_stub_752)
-	.globl GL_PREFIX(IsVertexArray) ; .set GL_PREFIX(IsVertexArray), GL_PREFIX(_dispatch_stub_754)
-	.globl GL_PREFIX(BlendEquationSeparate) ; .set GL_PREFIX(BlendEquationSeparate), GL_PREFIX(_dispatch_stub_762)
+	.globl GL_PREFIX(DeleteVertexArrays) ; .set GL_PREFIX(DeleteVertexArrays), GL_PREFIX(_dispatch_stub_755)
+	.globl GL_PREFIX(IsVertexArray) ; .set GL_PREFIX(IsVertexArray), GL_PREFIX(_dispatch_stub_757)
+	.globl GL_PREFIX(BlendEquationSeparate) ; .set GL_PREFIX(BlendEquationSeparate), GL_PREFIX(_dispatch_stub_765)
 	.globl GL_PREFIX(BindFramebuffer) ; .set GL_PREFIX(BindFramebuffer), GL_PREFIX(BindFramebufferEXT)
 	.globl GL_PREFIX(BindRenderbuffer) ; .set GL_PREFIX(BindRenderbuffer), GL_PREFIX(BindRenderbufferEXT)
 	.globl GL_PREFIX(CheckFramebufferStatus) ; .set GL_PREFIX(CheckFramebufferStatus), GL_PREFIX(CheckFramebufferStatusEXT)
@@ -30240,8 +30391,9 @@ GL_PREFIX(_dispatch_stub_791):
 	.globl GL_PREFIX(IsFramebuffer) ; .set GL_PREFIX(IsFramebuffer), GL_PREFIX(IsFramebufferEXT)
 	.globl GL_PREFIX(IsRenderbuffer) ; .set GL_PREFIX(IsRenderbuffer), GL_PREFIX(IsRenderbufferEXT)
 	.globl GL_PREFIX(RenderbufferStorage) ; .set GL_PREFIX(RenderbufferStorage), GL_PREFIX(RenderbufferStorageEXT)
-	.globl GL_PREFIX(BlitFramebuffer) ; .set GL_PREFIX(BlitFramebuffer), GL_PREFIX(_dispatch_stub_780)
+	.globl GL_PREFIX(BlitFramebuffer) ; .set GL_PREFIX(BlitFramebuffer), GL_PREFIX(_dispatch_stub_783)
 	.globl GL_PREFIX(FramebufferTextureLayer) ; .set GL_PREFIX(FramebufferTextureLayer), GL_PREFIX(FramebufferTextureLayerEXT)
+	.globl GL_PREFIX(ProvokingVertex) ; .set GL_PREFIX(ProvokingVertex), GL_PREFIX(ProvokingVertexEXT)
 
 #if defined(GLX_USE_TLS) && defined(__linux__)
 	.section ".note.ABI-tag", "a"
diff --git a/src/mesa/x86/glapi_x86.S b/src/mesa/x86/glapi_x86.S
index 46794adaf7..12c77f434e 100644
--- a/src/mesa/x86/glapi_x86.S
+++ b/src/mesa/x86/glapi_x86.S
@@ -725,23 +725,26 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(GetSynciv, _gloffset_GetSynciv, GetSynciv@20)
 	GL_STUB(IsSync, _gloffset_IsSync, IsSync@4)
 	GL_STUB(WaitSync, _gloffset_WaitSync, WaitSync@12)
+	GL_STUB(DrawElementsBaseVertex, _gloffset_DrawElementsBaseVertex, DrawElementsBaseVertex@20)
+	GL_STUB(DrawRangeElementsBaseVertex, _gloffset_DrawRangeElementsBaseVertex, DrawRangeElementsBaseVertex@28)
+	GL_STUB(MultiDrawElementsBaseVertex, _gloffset_MultiDrawElementsBaseVertex, MultiDrawElementsBaseVertex@24)
 	GL_STUB(PolygonOffsetEXT, _gloffset_PolygonOffsetEXT, PolygonOffsetEXT@8)
-	GL_STUB(_dispatch_stub_575, _gloffset_GetPixelTexGenParameterfvSGIS, _dispatch_stub_575@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_575, _dispatch_stub_575@8))
-	GL_STUB(_dispatch_stub_576, _gloffset_GetPixelTexGenParameterivSGIS, _dispatch_stub_576@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_576, _dispatch_stub_576@8))
-	GL_STUB(_dispatch_stub_577, _gloffset_PixelTexGenParameterfSGIS, _dispatch_stub_577@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_577, _dispatch_stub_577@8))
-	GL_STUB(_dispatch_stub_578, _gloffset_PixelTexGenParameterfvSGIS, _dispatch_stub_578@8)
+	GL_STUB(_dispatch_stub_578, _gloffset_GetPixelTexGenParameterfvSGIS, _dispatch_stub_578@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_578, _dispatch_stub_578@8))
-	GL_STUB(_dispatch_stub_579, _gloffset_PixelTexGenParameteriSGIS, _dispatch_stub_579@8)
+	GL_STUB(_dispatch_stub_579, _gloffset_GetPixelTexGenParameterivSGIS, _dispatch_stub_579@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_579, _dispatch_stub_579@8))
-	GL_STUB(_dispatch_stub_580, _gloffset_PixelTexGenParameterivSGIS, _dispatch_stub_580@8)
+	GL_STUB(_dispatch_stub_580, _gloffset_PixelTexGenParameterfSGIS, _dispatch_stub_580@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_580, _dispatch_stub_580@8))
-	GL_STUB(_dispatch_stub_581, _gloffset_SampleMaskSGIS, _dispatch_stub_581@8)
+	GL_STUB(_dispatch_stub_581, _gloffset_PixelTexGenParameterfvSGIS, _dispatch_stub_581@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_581, _dispatch_stub_581@8))
-	GL_STUB(_dispatch_stub_582, _gloffset_SamplePatternSGIS, _dispatch_stub_582@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_582, _dispatch_stub_582@4))
+	GL_STUB(_dispatch_stub_582, _gloffset_PixelTexGenParameteriSGIS, _dispatch_stub_582@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_582, _dispatch_stub_582@8))
+	GL_STUB(_dispatch_stub_583, _gloffset_PixelTexGenParameterivSGIS, _dispatch_stub_583@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_583, _dispatch_stub_583@8))
+	GL_STUB(_dispatch_stub_584, _gloffset_SampleMaskSGIS, _dispatch_stub_584@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_584, _dispatch_stub_584@8))
+	GL_STUB(_dispatch_stub_585, _gloffset_SamplePatternSGIS, _dispatch_stub_585@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_585, _dispatch_stub_585@4))
 	GL_STUB(ColorPointerEXT, _gloffset_ColorPointerEXT, ColorPointerEXT@20)
 	GL_STUB(EdgeFlagPointerEXT, _gloffset_EdgeFlagPointerEXT, EdgeFlagPointerEXT@12)
 	GL_STUB(IndexPointerEXT, _gloffset_IndexPointerEXT, IndexPointerEXT@16)
@@ -752,10 +755,10 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(PointParameterfvEXT, _gloffset_PointParameterfvEXT, PointParameterfvEXT@8)
 	GL_STUB(LockArraysEXT, _gloffset_LockArraysEXT, LockArraysEXT@8)
 	GL_STUB(UnlockArraysEXT, _gloffset_UnlockArraysEXT, UnlockArraysEXT@0)
-	GL_STUB(_dispatch_stub_593, _gloffset_CullParameterdvEXT, _dispatch_stub_593@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_593, _dispatch_stub_593@8))
-	GL_STUB(_dispatch_stub_594, _gloffset_CullParameterfvEXT, _dispatch_stub_594@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_594, _dispatch_stub_594@8))
+	GL_STUB(_dispatch_stub_596, _gloffset_CullParameterdvEXT, _dispatch_stub_596@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_596, _dispatch_stub_596@8))
+	GL_STUB(_dispatch_stub_597, _gloffset_CullParameterfvEXT, _dispatch_stub_597@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_597, _dispatch_stub_597@8))
 	GL_STUB(SecondaryColor3bEXT, _gloffset_SecondaryColor3bEXT, SecondaryColor3bEXT@12)
 	GL_STUB(SecondaryColor3bvEXT, _gloffset_SecondaryColor3bvEXT, SecondaryColor3bvEXT@4)
 	GL_STUB(SecondaryColor3dEXT, _gloffset_SecondaryColor3dEXT, SecondaryColor3dEXT@24)
@@ -780,8 +783,8 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(FogCoorddvEXT, _gloffset_FogCoorddvEXT, FogCoorddvEXT@4)
 	GL_STUB(FogCoordfEXT, _gloffset_FogCoordfEXT, FogCoordfEXT@4)
 	GL_STUB(FogCoordfvEXT, _gloffset_FogCoordfvEXT, FogCoordfvEXT@4)
-	GL_STUB(_dispatch_stub_619, _gloffset_PixelTexGenSGIX, _dispatch_stub_619@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_619, _dispatch_stub_619@4))
+	GL_STUB(_dispatch_stub_622, _gloffset_PixelTexGenSGIX, _dispatch_stub_622@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_622, _dispatch_stub_622@4))
 	GL_STUB(BlendFuncSeparateEXT, _gloffset_BlendFuncSeparateEXT, BlendFuncSeparateEXT@16)
 	GL_STUB(FlushVertexArrayRangeNV, _gloffset_FlushVertexArrayRangeNV, FlushVertexArrayRangeNV@0)
 	GL_STUB(VertexArrayRangeNV, _gloffset_VertexArrayRangeNV, VertexArrayRangeNV@8)
@@ -823,24 +826,24 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(WindowPos4ivMESA, _gloffset_WindowPos4ivMESA, WindowPos4ivMESA@4)
 	GL_STUB(WindowPos4sMESA, _gloffset_WindowPos4sMESA, WindowPos4sMESA@16)
 	GL_STUB(WindowPos4svMESA, _gloffset_WindowPos4svMESA, WindowPos4svMESA@4)
-	GL_STUB(_dispatch_stub_661, _gloffset_MultiModeDrawArraysIBM, _dispatch_stub_661@20)
-	HIDDEN(GL_PREFIX(_dispatch_stub_661, _dispatch_stub_661@20))
-	GL_STUB(_dispatch_stub_662, _gloffset_MultiModeDrawElementsIBM, _dispatch_stub_662@24)
-	HIDDEN(GL_PREFIX(_dispatch_stub_662, _dispatch_stub_662@24))
-	GL_STUB(_dispatch_stub_663, _gloffset_DeleteFencesNV, _dispatch_stub_663@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_663, _dispatch_stub_663@8))
-	GL_STUB(_dispatch_stub_664, _gloffset_FinishFenceNV, _dispatch_stub_664@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_664, _dispatch_stub_664@4))
-	GL_STUB(_dispatch_stub_665, _gloffset_GenFencesNV, _dispatch_stub_665@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_665, _dispatch_stub_665@8))
-	GL_STUB(_dispatch_stub_666, _gloffset_GetFenceivNV, _dispatch_stub_666@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_666, _dispatch_stub_666@12))
-	GL_STUB(_dispatch_stub_667, _gloffset_IsFenceNV, _dispatch_stub_667@4)
+	GL_STUB(_dispatch_stub_664, _gloffset_MultiModeDrawArraysIBM, _dispatch_stub_664@20)
+	HIDDEN(GL_PREFIX(_dispatch_stub_664, _dispatch_stub_664@20))
+	GL_STUB(_dispatch_stub_665, _gloffset_MultiModeDrawElementsIBM, _dispatch_stub_665@24)
+	HIDDEN(GL_PREFIX(_dispatch_stub_665, _dispatch_stub_665@24))
+	GL_STUB(_dispatch_stub_666, _gloffset_DeleteFencesNV, _dispatch_stub_666@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_666, _dispatch_stub_666@8))
+	GL_STUB(_dispatch_stub_667, _gloffset_FinishFenceNV, _dispatch_stub_667@4)
 	HIDDEN(GL_PREFIX(_dispatch_stub_667, _dispatch_stub_667@4))
-	GL_STUB(_dispatch_stub_668, _gloffset_SetFenceNV, _dispatch_stub_668@8)
+	GL_STUB(_dispatch_stub_668, _gloffset_GenFencesNV, _dispatch_stub_668@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_668, _dispatch_stub_668@8))
-	GL_STUB(_dispatch_stub_669, _gloffset_TestFenceNV, _dispatch_stub_669@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_669, _dispatch_stub_669@4))
+	GL_STUB(_dispatch_stub_669, _gloffset_GetFenceivNV, _dispatch_stub_669@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_669, _dispatch_stub_669@12))
+	GL_STUB(_dispatch_stub_670, _gloffset_IsFenceNV, _dispatch_stub_670@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_670, _dispatch_stub_670@4))
+	GL_STUB(_dispatch_stub_671, _gloffset_SetFenceNV, _dispatch_stub_671@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_671, _dispatch_stub_671@8))
+	GL_STUB(_dispatch_stub_672, _gloffset_TestFenceNV, _dispatch_stub_672@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_672, _dispatch_stub_672@4))
 	GL_STUB(AreProgramsResidentNV, _gloffset_AreProgramsResidentNV, AreProgramsResidentNV@12)
 	GL_STUB(BindProgramNV, _gloffset_BindProgramNV, BindProgramNV@8)
 	GL_STUB(DeleteProgramsNV, _gloffset_DeleteProgramsNV, DeleteProgramsNV@8)
@@ -921,26 +924,26 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(SetFragmentShaderConstantATI, _gloffset_SetFragmentShaderConstantATI, SetFragmentShaderConstantATI@8)
 	GL_STUB(PointParameteriNV, _gloffset_PointParameteriNV, PointParameteriNV@8)
 	GL_STUB(PointParameterivNV, _gloffset_PointParameterivNV, PointParameterivNV@8)
-	GL_STUB(_dispatch_stub_750, _gloffset_ActiveStencilFaceEXT, _dispatch_stub_750@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_750, _dispatch_stub_750@4))
-	GL_STUB(_dispatch_stub_751, _gloffset_BindVertexArrayAPPLE, _dispatch_stub_751@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_751, _dispatch_stub_751@4))
-	GL_STUB(_dispatch_stub_752, _gloffset_DeleteVertexArraysAPPLE, _dispatch_stub_752@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_752, _dispatch_stub_752@8))
-	GL_STUB(_dispatch_stub_753, _gloffset_GenVertexArraysAPPLE, _dispatch_stub_753@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_753, _dispatch_stub_753@8))
-	GL_STUB(_dispatch_stub_754, _gloffset_IsVertexArrayAPPLE, _dispatch_stub_754@4)
+	GL_STUB(_dispatch_stub_753, _gloffset_ActiveStencilFaceEXT, _dispatch_stub_753@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_753, _dispatch_stub_753@4))
+	GL_STUB(_dispatch_stub_754, _gloffset_BindVertexArrayAPPLE, _dispatch_stub_754@4)
 	HIDDEN(GL_PREFIX(_dispatch_stub_754, _dispatch_stub_754@4))
+	GL_STUB(_dispatch_stub_755, _gloffset_DeleteVertexArraysAPPLE, _dispatch_stub_755@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_755, _dispatch_stub_755@8))
+	GL_STUB(_dispatch_stub_756, _gloffset_GenVertexArraysAPPLE, _dispatch_stub_756@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_756, _dispatch_stub_756@8))
+	GL_STUB(_dispatch_stub_757, _gloffset_IsVertexArrayAPPLE, _dispatch_stub_757@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_757, _dispatch_stub_757@4))
 	GL_STUB(GetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV, GetProgramNamedParameterdvNV@16)
 	GL_STUB(GetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV, GetProgramNamedParameterfvNV@16)
 	GL_STUB(ProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV, ProgramNamedParameter4dNV@44)
 	GL_STUB(ProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV, ProgramNamedParameter4dvNV@16)
 	GL_STUB(ProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV, ProgramNamedParameter4fNV@28)
 	GL_STUB(ProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV, ProgramNamedParameter4fvNV@16)
-	GL_STUB(_dispatch_stub_761, _gloffset_DepthBoundsEXT, _dispatch_stub_761@16)
-	HIDDEN(GL_PREFIX(_dispatch_stub_761, _dispatch_stub_761@16))
-	GL_STUB(_dispatch_stub_762, _gloffset_BlendEquationSeparateEXT, _dispatch_stub_762@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_762, _dispatch_stub_762@8))
+	GL_STUB(_dispatch_stub_764, _gloffset_DepthBoundsEXT, _dispatch_stub_764@16)
+	HIDDEN(GL_PREFIX(_dispatch_stub_764, _dispatch_stub_764@16))
+	GL_STUB(_dispatch_stub_765, _gloffset_BlendEquationSeparateEXT, _dispatch_stub_765@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_765, _dispatch_stub_765@8))
 	GL_STUB(BindFramebufferEXT, _gloffset_BindFramebufferEXT, BindFramebufferEXT@8)
 	GL_STUB(BindRenderbufferEXT, _gloffset_BindRenderbufferEXT, BindRenderbufferEXT@8)
 	GL_STUB(CheckFramebufferStatusEXT, _gloffset_CheckFramebufferStatusEXT, CheckFramebufferStatusEXT@4)
@@ -958,28 +961,28 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(IsFramebufferEXT, _gloffset_IsFramebufferEXT, IsFramebufferEXT@4)
 	GL_STUB(IsRenderbufferEXT, _gloffset_IsRenderbufferEXT, IsRenderbufferEXT@4)
 	GL_STUB(RenderbufferStorageEXT, _gloffset_RenderbufferStorageEXT, RenderbufferStorageEXT@16)
-	GL_STUB(_dispatch_stub_780, _gloffset_BlitFramebufferEXT, _dispatch_stub_780@40)
-	HIDDEN(GL_PREFIX(_dispatch_stub_780, _dispatch_stub_780@40))
-	GL_STUB(_dispatch_stub_781, _gloffset_BufferParameteriAPPLE, _dispatch_stub_781@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_781, _dispatch_stub_781@12))
-	GL_STUB(_dispatch_stub_782, _gloffset_FlushMappedBufferRangeAPPLE, _dispatch_stub_782@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_782, _dispatch_stub_782@12))
+	GL_STUB(_dispatch_stub_783, _gloffset_BlitFramebufferEXT, _dispatch_stub_783@40)
+	HIDDEN(GL_PREFIX(_dispatch_stub_783, _dispatch_stub_783@40))
+	GL_STUB(_dispatch_stub_784, _gloffset_BufferParameteriAPPLE, _dispatch_stub_784@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_784, _dispatch_stub_784@12))
+	GL_STUB(_dispatch_stub_785, _gloffset_FlushMappedBufferRangeAPPLE, _dispatch_stub_785@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_785, _dispatch_stub_785@12))
 	GL_STUB(FramebufferTextureLayerEXT, _gloffset_FramebufferTextureLayerEXT, FramebufferTextureLayerEXT@20)
 	GL_STUB(ProvokingVertexEXT, _gloffset_ProvokingVertexEXT, ProvokingVertexEXT@4)
-	GL_STUB(_dispatch_stub_785, _gloffset_GetTexParameterPointervAPPLE, _dispatch_stub_785@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_785, _dispatch_stub_785@12))
-	GL_STUB(_dispatch_stub_786, _gloffset_TextureRangeAPPLE, _dispatch_stub_786@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_786, _dispatch_stub_786@12))
-	GL_STUB(_dispatch_stub_787, _gloffset_StencilFuncSeparateATI, _dispatch_stub_787@16)
-	HIDDEN(GL_PREFIX(_dispatch_stub_787, _dispatch_stub_787@16))
-	GL_STUB(_dispatch_stub_788, _gloffset_ProgramEnvParameters4fvEXT, _dispatch_stub_788@16)
-	HIDDEN(GL_PREFIX(_dispatch_stub_788, _dispatch_stub_788@16))
-	GL_STUB(_dispatch_stub_789, _gloffset_ProgramLocalParameters4fvEXT, _dispatch_stub_789@16)
-	HIDDEN(GL_PREFIX(_dispatch_stub_789, _dispatch_stub_789@16))
-	GL_STUB(_dispatch_stub_790, _gloffset_GetQueryObjecti64vEXT, _dispatch_stub_790@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_790, _dispatch_stub_790@12))
-	GL_STUB(_dispatch_stub_791, _gloffset_GetQueryObjectui64vEXT, _dispatch_stub_791@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_791, _dispatch_stub_791@12))
+	GL_STUB(_dispatch_stub_788, _gloffset_GetTexParameterPointervAPPLE, _dispatch_stub_788@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_788, _dispatch_stub_788@12))
+	GL_STUB(_dispatch_stub_789, _gloffset_TextureRangeAPPLE, _dispatch_stub_789@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_789, _dispatch_stub_789@12))
+	GL_STUB(_dispatch_stub_790, _gloffset_StencilFuncSeparateATI, _dispatch_stub_790@16)
+	HIDDEN(GL_PREFIX(_dispatch_stub_790, _dispatch_stub_790@16))
+	GL_STUB(_dispatch_stub_791, _gloffset_ProgramEnvParameters4fvEXT, _dispatch_stub_791@16)
+	HIDDEN(GL_PREFIX(_dispatch_stub_791, _dispatch_stub_791@16))
+	GL_STUB(_dispatch_stub_792, _gloffset_ProgramLocalParameters4fvEXT, _dispatch_stub_792@16)
+	HIDDEN(GL_PREFIX(_dispatch_stub_792, _dispatch_stub_792@16))
+	GL_STUB(_dispatch_stub_793, _gloffset_GetQueryObjecti64vEXT, _dispatch_stub_793@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_793, _dispatch_stub_793@12))
+	GL_STUB(_dispatch_stub_794, _gloffset_GetQueryObjectui64vEXT, _dispatch_stub_794@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_794, _dispatch_stub_794@12))
 	GL_STUB_ALIAS(ArrayElementEXT, _gloffset_ArrayElement, ArrayElementEXT@4, ArrayElement, ArrayElement@4)
 	GL_STUB_ALIAS(BindTextureEXT, _gloffset_BindTexture, BindTextureEXT@8, BindTexture, BindTexture@8)
 	GL_STUB_ALIAS(DrawArraysEXT, _gloffset_DrawArrays, DrawArraysEXT@12, DrawArrays, DrawArrays@12)
@@ -1313,6 +1316,7 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB_ALIAS(IsRenderbuffer, _gloffset_IsRenderbufferEXT, IsRenderbuffer@4, IsRenderbufferEXT, IsRenderbufferEXT@4)
 	GL_STUB_ALIAS(RenderbufferStorage, _gloffset_RenderbufferStorageEXT, RenderbufferStorage@16, RenderbufferStorageEXT, RenderbufferStorageEXT@16)
 	GL_STUB_ALIAS(FramebufferTextureLayer, _gloffset_FramebufferTextureLayerEXT, FramebufferTextureLayer@20, FramebufferTextureLayerEXT, FramebufferTextureLayerEXT@20)
+	GL_STUB_ALIAS(ProvokingVertex, _gloffset_ProvokingVertexEXT, ProvokingVertex@4, ProvokingVertexEXT, ProvokingVertexEXT@4)
 
 		GLOBL	GLNAME(gl_dispatch_functions_end)
 		HIDDEN(GLNAME(gl_dispatch_functions_end))
diff --git a/src/mesa/x86/x86_xform.c b/src/mesa/x86/x86_xform.c
index 16b2b26bcc..52f6b25d81 100644
--- a/src/mesa/x86/x86_xform.c
+++ b/src/mesa/x86/x86_xform.c
@@ -60,21 +60,24 @@ _mesa_x86_cliptest_points4( GLvector4f *clip_vec,
 			    GLvector4f *proj_vec,
 			    GLubyte clipMask[],
 			    GLubyte *orMask,
-			    GLubyte *andMask );
+			    GLubyte *andMask,
+			    GLboolean viewport_z_clip );
 
 extern GLvector4f * _ASMAPI
 _mesa_x86_cliptest_points4_np( GLvector4f *clip_vec,
 			       GLvector4f *proj_vec,
 			       GLubyte clipMask[],
 			       GLubyte *orMask,
-			       GLubyte *andMask );
+			       GLubyte *andMask,
+			       GLboolean viewport_z_clip );
 
 extern void _ASMAPI
 _mesa_v16_x86_cliptest_points4( GLfloat *first_vert,
 				GLfloat *last_vert,
 				GLubyte *or_mask,
 				GLubyte *and_mask,
-				GLubyte *clip_mask );
+				GLubyte *clip_mask,
+				GLboolean viewport_z_clip );
 
 extern void _ASMAPI
 _mesa_v16_x86_general_xform( GLfloat *dest,
diff --git a/src/xvmc/context.c b/src/xvmc/context.c
index 273f658029..9c2b6648bb 100644
--- a/src/xvmc/context.c
+++ b/src/xvmc/context.c
@@ -1,6 +1,7 @@
 #include <assert.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/XvMClib.h>
+#include <X11/Xlibint.h>
 #include <pipe/p_context.h>
 #include <vl_display.h>
 #include <vl_screen.h>
@@ -137,6 +138,7 @@ Status XvMCCreateContext(Display *display, XvPortID port, int surface_type_id, i
 	struct vlScreen		*vl_scrn;
 	struct vlContext	*vl_ctx;
 	struct pipe_context	*pipe;
+	Display			*dpy = display;
 
 	assert(display);
 
@@ -176,6 +178,7 @@ Status XvMCCreateContext(Display *display, XvPortID port, int surface_type_id, i
 	context->port = port;
 	context->privData = vl_ctx;
 
+	SyncHandle();
 	return Success;
 }
 
diff --git a/src/xvmc/subpicture.c b/src/xvmc/subpicture.c
index c8f70c90d0..09e9c98e6a 100644
--- a/src/xvmc/subpicture.c
+++ b/src/xvmc/subpicture.c
@@ -2,6 +2,7 @@
 #include <X11/Xlib.h>
 #include <X11/extensions/Xvlib.h>
 #include <X11/extensions/XvMC.h>
+#include <X11/Xlibint.h>
 
 Status XvMCCreateSubpicture
 (
@@ -13,6 +14,7 @@ Status XvMCCreateSubpicture
 	int xvimage_id
 )
 {
+	Display *dpy = display;
 	assert(display);
 	
 	if (!context)
@@ -38,7 +40,8 @@ Status XvMCCreateSubpicture
 	subpicture->component_order[2] = 0;
 	subpicture->component_order[3] = 0;
 	/* TODO: subpicture->privData = ;*/
-	
+
+	SyncHandle();
 	return Success;
 }
 
diff --git a/src/xvmc/surface.c b/src/xvmc/surface.c
index 7c5f45bd34..fea351b84f 100644
--- a/src/xvmc/surface.c
+++ b/src/xvmc/surface.c
@@ -1,6 +1,7 @@
 #include <assert.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/XvMC.h>
+#include <X11/Xlibint.h>
 #include <vl_display.h>
 #include <vl_screen.h>
 #include <vl_context.h>
@@ -61,6 +62,7 @@ Status XvMCCreateSurface(Display *display, XvMCContext *context, XvMCSurface *su
 {
 	struct vlContext *vl_ctx;
 	struct vlSurface *vl_sfc;
+	Display *dpy = display;
 
 	assert(display);
 
@@ -90,6 +92,7 @@ Status XvMCCreateSurface(Display *display, XvMCContext *context, XvMCSurface *su
 	surface->height = context->height;
 	surface->privData = vl_sfc;
 
+	SyncHandle();
 	return Success;
 }
 
diff --git a/windows/VC7/mesa/mesa/mesa.vcproj b/windows/VC7/mesa/mesa/mesa.vcproj
index 4d5d4c744b..4d7df74170 100644
--- a/windows/VC7/mesa/mesa/mesa.vcproj
+++ b/windows/VC7/mesa/mesa/mesa.vcproj
@@ -416,9 +416,6 @@
 				RelativePath="..\..\..\..\src\mesa\swrast\s_fragprog.c">
 			</File>
 			<File
-				RelativePath="..\..\..\..\src\mesa\swrast\s_imaging.c">
-			</File>
-			<File
 				RelativePath="..\..\..\..\src\mesa\swrast\s_lines.c">
 			</File>
 			<File
@@ -446,9 +443,6 @@
 				RelativePath="..\..\..\..\src\mesa\swrast\s_texfilter.c">
 			</File>
 			<File
-				RelativePath="..\..\..\..\src\mesa\swrast\s_texstore.c">
-			</File>
-			<File
 				RelativePath="..\..\..\..\src\mesa\swrast\s_triangle.c">
 			</File>
 			<File
diff --git a/windows/VC8/mesa/mesa/mesa.vcproj b/windows/VC8/mesa/mesa/mesa.vcproj
index 068da1612d..f15c4435f6 100644
--- a/windows/VC8/mesa/mesa/mesa.vcproj
+++ b/windows/VC8/mesa/mesa/mesa.vcproj
@@ -783,10 +783,6 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\..\src\mesa\swrast\s_imaging.c"
-				>
-			</File>
-			<File
 				RelativePath="..\..\..\..\src\mesa\swrast\s_lines.c"
 				>
 			</File>
@@ -823,10 +819,6 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\..\src\mesa\swrast\s_texstore.c"
-				>
-			</File>
-			<File
 				RelativePath="..\..\..\..\src\mesa\swrast\s_triangle.c"
 				>
 			</File>
author	Nicolai Hähnle <nhaehnle@gmail.com>	2009-09-21 13:26:50 +0200
committer	Nicolai Hähnle <nhaehnle@gmail.com>	2009-09-21 13:26:50 +0200
commit	81c7561d9d3faf70ac22c6a5f3fbea18f53eed92 (patch)
tree	5ec097e0e1fe99804104d3a56923c16edf1533aa
parent	f02f63997ce65530788a6dfcb28f11790a14d938 (diff)
parent	3083ba38f4c884b32cd0460607b5064b6b7008d2 (diff)