libX11 libXext libXft mesa libxcb mkfontscale pixman xserver

xkeyboard-config git update 19 oct 2011

45 files changed, 1382 insertions, 1605 deletions

diff --git a/mesalib/src/mesa/SConscript b/mesalib/src/mesa/SConscript
index 9f142bf08..45414bcde 100644
--- a/mesalib/src/mesa/SConscript
+++ b/mesalib/src/mesa/SConscript
@@ -129,6 +129,7 @@ main_sources = [
     'main/texstore.c',
     'main/texturebarrier.c',
     'main/transformfeedback.c',
+    'main/uniform_query.cpp',
     'main/uniforms.c',
     'main/varray.c',
     'main/version.c',
diff --git a/mesalib/src/mesa/drivers/common/driverfuncs.c b/mesalib/src/mesa/drivers/common/driverfuncs.c
index 33da9346c..263d4025f 100644
--- a/mesalib/src/mesa/drivers/common/driverfuncs.c
+++ b/mesalib/src/mesa/drivers/common/driverfuncs.c
@@ -208,6 +208,7 @@ _mesa_init_driver_functions(struct dd_function_table *driver)
    driver->ProgramStringNotify = _tnl_program_string;
    driver->FlushVertices = NULL;
    driver->SaveFlushVertices = NULL;
+   driver->PrepareExecBegin = NULL;
    driver->NotifySaveBegin = NULL;
    driver->LightingSpaceChange = NULL;
 
diff --git a/mesalib/src/mesa/drivers/common/meta.c b/mesalib/src/mesa/drivers/common/meta.c
index 5b73dcdfb..c7bb93380 100644
--- a/mesalib/src/mesa/drivers/common/meta.c
+++ b/mesalib/src/mesa/drivers/common/meta.c
@@ -44,6 +44,7 @@
 #include "main/depth.h"
 #include "main/enable.h"
 #include "main/fbobject.h"
+#include "main/feedback.h"
 #include "main/formats.h"
 #include "main/image.h"
 #include "main/macros.h"
@@ -172,6 +173,11 @@ struct save_state
    struct gl_query_object *CondRenderQuery;
    GLenum CondRenderMode;
 
+   /** MESA_META_SELECT_FEEDBACK */
+   GLenum RenderMode;
+   struct gl_selection Select;
+   struct gl_feedback Feedback;
+
    /** Miscellaneous (always disabled) */
    GLboolean Lighting;
 };
@@ -273,7 +279,7 @@ struct decompress_state
 };
 
 
-#define MAX_META_OPS_DEPTH      2
+#define MAX_META_OPS_DEPTH      8
 /**
  * All per-context meta state.
  */
@@ -464,7 +470,7 @@ _mesa_meta_begin(struct gl_context *ctx, GLbitfield state)
 	 _mesa_reference_shader_program(ctx, &save->FragmentShader,
 					ctx->Shader.CurrentFragmentProgram);
 	 _mesa_reference_shader_program(ctx, &save->ActiveShader,
-					ctx->Shader.CurrentFragmentProgram);
+					ctx->Shader.ActiveProgram);
 
          _mesa_UseProgramObjectARB(0);
       }
@@ -608,6 +614,17 @@ _mesa_meta_begin(struct gl_context *ctx, GLbitfield state)
 	 _mesa_EndConditionalRender();
    }
 
+   if (state & MESA_META_SELECT_FEEDBACK) {
+      save->RenderMode = ctx->RenderMode;
+      if (ctx->RenderMode == GL_SELECT) {
+	 save->Select = ctx->Select; /* struct copy */
+	 _mesa_RenderMode(GL_RENDER);
+      } else if (ctx->RenderMode == GL_FEEDBACK) {
+	 save->Feedback = ctx->Feedback; /* struct copy */
+	 _mesa_RenderMode(GL_RENDER);
+      }
+   }
+
    /* misc */
    {
       save->Lighting = ctx->Light.Enabled;
@@ -893,6 +910,16 @@ _mesa_meta_end(struct gl_context *ctx)
 				      save->CondRenderMode);
    }
 
+   if (state & MESA_META_SELECT_FEEDBACK) {
+      if (save->RenderMode == GL_SELECT) {
+	 _mesa_RenderMode(GL_SELECT);
+	 ctx->Select = save->Select;
+      } else if (save->RenderMode == GL_FEEDBACK) {
+	 _mesa_RenderMode(GL_FEEDBACK);
+	 ctx->Feedback = save->Feedback;
+      }
+   }
+
    /* misc */
    if (save->Lighting) {
       _mesa_set_enable(ctx, GL_LIGHTING, GL_TRUE);
@@ -2942,7 +2969,7 @@ get_temp_image_type(struct gl_context *ctx, GLenum baseFormat)
    case GL_INTENSITY:
       if (ctx->DrawBuffer->Visual.redBits <= 8)
          return GL_UNSIGNED_BYTE;
-      else if (ctx->DrawBuffer->Visual.redBits <= 8)
+      else if (ctx->DrawBuffer->Visual.redBits <= 16)
          return GL_UNSIGNED_SHORT;
       else
          return GL_FLOAT;
diff --git a/mesalib/src/mesa/drivers/common/meta.h b/mesalib/src/mesa/drivers/common/meta.h
index 7ec568388..e0435a822 100644
--- a/mesalib/src/mesa/drivers/common/meta.h
+++ b/mesalib/src/mesa/drivers/common/meta.h
@@ -54,6 +54,7 @@
 #define MESA_META_CLAMP_VERTEX_COLOR    0x10000
 #define MESA_META_CONDITIONAL_RENDER    0x20000
 #define MESA_META_CLIP                  0x40000
+#define MESA_META_SELECT_FEEDBACK       0x80000
 /**\}*/
 
 extern void
diff --git a/mesalib/src/mesa/main/context.c b/mesalib/src/mesa/main/context.c
index fc52e8c15..e0af6ee67 100644
--- a/mesalib/src/mesa/main/context.c
+++ b/mesalib/src/mesa/main/context.c
@@ -1833,8 +1833,6 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
       shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentFragmentProgram;
 
       for (i = 0; i < MESA_SHADER_TYPES; i++) {
-	 struct gl_shader *sh;
-
 	 if (shProg[i] == NULL || shProg[i]->_Used
 	     || shProg[i]->_LinkedShaders[i] == NULL)
 	    continue;
@@ -1842,27 +1840,13 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
 	 /* This is the first time this shader is being used.
 	  * Append shader's constants/uniforms to log file.
 	  *
-	  * The logic is a little odd here.  We only want to log data for each
-	  * shader target that will actually be used, and we only want to log
-	  * it once.  It's possible to have a program bound to the vertex
+	  * Only log data for the program target that matches the shader
+	  * target.  It's possible to have a program bound to the vertex
 	  * shader target that also supplied a fragment shader.  If that
 	  * program isn't also bound to the fragment shader target we don't
 	  * want to log its fragment data.
 	  */
-	 sh = shProg[i]->_LinkedShaders[i];
-	 switch (sh->Type) {
-	 case GL_VERTEX_SHADER:
-	    _mesa_append_uniforms_to_file(sh, sh->Program);
-	    break;
-
-	 case GL_GEOMETRY_SHADER_ARB:
-	    _mesa_append_uniforms_to_file(sh, sh->Program);
-	    break;
-
-	 case GL_FRAGMENT_SHADER:
-	    _mesa_append_uniforms_to_file(sh, sh->Program);
-	    break;
-	 }
+	 _mesa_append_uniforms_to_file(shProg[i]->_LinkedShaders[i]);
       }
 
       for (i = 0; i < MESA_SHADER_TYPES; i++) {
diff --git a/mesalib/src/mesa/main/dd.h b/mesalib/src/mesa/main/dd.h
index 4e017ae38..8607008de 100644
--- a/mesalib/src/mesa/main/dd.h
+++ b/mesalib/src/mesa/main/dd.h
@@ -861,6 +861,14 @@ struct dd_function_table {
    void (*SaveFlushVertices)( struct gl_context *ctx );
 
    /**
+    * \brief Hook for drivers to prepare for a glBegin/glEnd block
+    *
+    * This hook is called in vbo_exec_Begin() before any action, including
+    * state updates, occurs.
+    */
+   void (*PrepareExecBegin)( struct gl_context *ctx );
+
+   /**
     * Give the driver the opportunity to hook in its own vtxfmt for
     * compiling optimized display lists.  This is called on each valid
     * glBegin() during list compilation.
diff --git a/mesalib/src/mesa/main/dlist.c b/mesalib/src/mesa/main/dlist.c
index 343feec6f..625649e9d 100644
--- a/mesalib/src/mesa/main/dlist.c
+++ b/mesalib/src/mesa/main/dlist.c
@@ -875,7 +875,7 @@ translate_id(GLsizei n, GLenum type, const GLvoid * list)
 /**********************************************************************/
 
 /**
- * Wrapper for _mesa_unpack_image() that handles pixel buffer objects.
+ * Wrapper for _mesa_unpack_image/bitmap() that handles pixel buffer objects.
  * If width < 0 or height < 0 or format or type are invalid we'll just
  * return NULL.  We will not generate an error since OpenGL command
  * arguments aren't error-checked until the command is actually executed
@@ -899,8 +899,13 @@ unpack_image(struct gl_context *ctx, GLuint dimensions,
 
    if (!_mesa_is_bufferobj(unpack->BufferObj)) {
       /* no PBO */
-      GLvoid *image = _mesa_unpack_image(dimensions, width, height, depth,
-                                         format, type, pixels, unpack);
+      GLvoid *image;
+
+      if (type == GL_BITMAP)
+         image = _mesa_unpack_bitmap(width, height, pixels, unpack);
+      else
+         image = _mesa_unpack_image(dimensions, width, height, depth,
+                                    format, type, pixels, unpack);
       if (pixels && !image) {
          _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
       }
@@ -921,8 +926,11 @@ unpack_image(struct gl_context *ctx, GLuint dimensions,
       }
 
       src = ADD_POINTERS(map, pixels);
-      image = _mesa_unpack_image(dimensions, width, height, depth,
-                                 format, type, src, unpack);
+      if (type == GL_BITMAP)
+         image = _mesa_unpack_bitmap(width, height, src, unpack);
+      else
+         image = _mesa_unpack_image(dimensions, width, height, depth,
+                                    format, type, src, unpack);
 
       ctx->Driver.UnmapBuffer(ctx, unpack->BufferObj);
 
@@ -935,7 +943,6 @@ unpack_image(struct gl_context *ctx, GLuint dimensions,
    return NULL;
 }
 
-
 /**
  * Allocate space for a display list instruction (opcode + payload space).
  * \param opcode  the instruction opcode (OPCODE_* value)
@@ -1121,7 +1128,8 @@ save_Bitmap(GLsizei width, GLsizei height,
       n[4].f = yorig;
       n[5].f = xmove;
       n[6].f = ymove;
-      n[7].data = _mesa_unpack_bitmap(width, height, pixels, &ctx->Unpack);
+      n[7].data = unpack_image(ctx, 2, width, height, 1, GL_COLOR_INDEX,
+                               GL_BITMAP, pixels, &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_Bitmap(ctx->Exec, (width, height,
@@ -4509,6 +4517,24 @@ save_MultTransposeMatrixfARB(const GLfloat m[16])
    save_MultMatrixf(tm);
 }
 
+static GLvoid *copy_data(const GLvoid *data, GLsizei size, const char *func)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLvoid *image;
+
+   if (!data)
+      return NULL;
+
+   image = malloc(size);
+   if (!image) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
+      return NULL;
+   }
+   memcpy(image, data, size);
+
+   return image;
+}
+
 
 /* GL_ARB_texture_compression */
 static void GLAPIENTRY
@@ -4526,15 +4552,8 @@ save_CompressedTexImage1DARB(GLenum target, GLint level,
    }
    else {
       Node *n;
-      GLvoid *image;
       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      /* make copy of image */
-      image = malloc(imageSize);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
-         return;
-      }
-      memcpy(image, data, imageSize);
+
       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7);
       if (n) {
          n[1].e = target;
@@ -4543,10 +4562,7 @@ save_CompressedTexImage1DARB(GLenum target, GLint level,
          n[4].i = (GLint) width;
          n[5].i = border;
          n[6].i = imageSize;
-         n[7].data = image;
-      }
-      else if (image) {
-         free(image);
+         n[7].data = copy_data(data, imageSize, "glCompressedTexImage1DARB");
       }
       if (ctx->ExecuteFlag) {
          CALL_CompressedTexImage1DARB(ctx->Exec,
@@ -4572,15 +4588,8 @@ save_CompressedTexImage2DARB(GLenum target, GLint level,
    }
    else {
       Node *n;
-      GLvoid *image;
       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      /* make copy of image */
-      image = malloc(imageSize);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
-         return;
-      }
-      memcpy(image, data, imageSize);
+
       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8);
       if (n) {
          n[1].e = target;
@@ -4590,10 +4599,7 @@ save_CompressedTexImage2DARB(GLenum target, GLint level,
          n[5].i = (GLint) height;
          n[6].i = border;
          n[7].i = imageSize;
-         n[8].data = image;
-      }
-      else if (image) {
-         free(image);
+         n[8].data = copy_data(data, imageSize, "glCompressedTexImage2DARB");
       }
       if (ctx->ExecuteFlag) {
          CALL_CompressedTexImage2DARB(ctx->Exec,
@@ -4619,15 +4625,8 @@ save_CompressedTexImage3DARB(GLenum target, GLint level,
    }
    else {
       Node *n;
-      GLvoid *image;
       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      /* make copy of image */
-      image = malloc(imageSize);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
-         return;
-      }
-      memcpy(image, data, imageSize);
+
       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9);
       if (n) {
          n[1].e = target;
@@ -4638,10 +4637,7 @@ save_CompressedTexImage3DARB(GLenum target, GLint level,
          n[6].i = (GLint) depth;
          n[7].i = border;
          n[8].i = imageSize;
-         n[9].data = image;
-      }
-      else if (image) {
-         free(image);
+         n[9].data = copy_data(data, imageSize, "glCompressedTexImage3DARB");
       }
       if (ctx->ExecuteFlag) {
          CALL_CompressedTexImage3DARB(ctx->Exec,
@@ -4659,18 +4655,9 @@ save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
                                 GLsizei imageSize, const GLvoid * data)
 {
    Node *n;
-   GLvoid *image;
-
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
 
-   /* make copy of image */
-   image = malloc(imageSize);
-   if (!image) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage1DARB");
-      return;
-   }
-   memcpy(image, data, imageSize);
    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7);
    if (n) {
       n[1].e = target;
@@ -4679,10 +4666,7 @@ save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
       n[4].i = (GLint) width;
       n[5].e = format;
       n[6].i = imageSize;
-      n[7].data = image;
-   }
-   else if (image) {
-      free(image);
+      n[7].data = copy_data(data, imageSize, "glCompressedTexSubImage1DARB");
    }
    if (ctx->ExecuteFlag) {
       CALL_CompressedTexSubImage1DARB(ctx->Exec, (target, level, xoffset,
@@ -4699,18 +4683,9 @@ save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
                                 const GLvoid * data)
 {
    Node *n;
-   GLvoid *image;
-
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
 
-   /* make copy of image */
-   image = malloc(imageSize);
-   if (!image) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2DARB");
-      return;
-   }
-   memcpy(image, data, imageSize);
    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9);
    if (n) {
       n[1].e = target;
@@ -4721,10 +4696,7 @@ save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
       n[6].i = (GLint) height;
       n[7].e = format;
       n[8].i = imageSize;
-      n[9].data = image;
-   }
-   else if (image) {
-      free(image);
+      n[9].data = copy_data(data, imageSize, "glCompressedTexSubImage2DARB");
    }
    if (ctx->ExecuteFlag) {
       CALL_CompressedTexSubImage2DARB(ctx->Exec,
@@ -4741,18 +4713,9 @@ save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
                                 GLsizei imageSize, const GLvoid * data)
 {
    Node *n;
-   GLvoid *image;
-
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
 
-   /* make copy of image */
-   image = malloc(imageSize);
-   if (!image) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage3DARB");
-      return;
-   }
-   memcpy(image, data, imageSize);
    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11);
    if (n) {
       n[1].e = target;
@@ -4765,10 +4728,7 @@ save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
       n[8].i = (GLint) depth;
       n[9].e = format;
       n[10].i = imageSize;
-      n[11].data = image;
-   }
-   else if (image) {
-      free(image);
+      n[11].data = copy_data(data, imageSize, "glCompressedTexSubImage3DARB");
    }
    if (ctx->ExecuteFlag) {
       CALL_CompressedTexSubImage3DARB(ctx->Exec,
diff --git a/mesalib/src/mesa/main/fbobject.c b/mesalib/src/mesa/main/fbobject.c
index 757115584..f9da54e73 100644
--- a/mesalib/src/mesa/main/fbobject.c
+++ b/mesalib/src/mesa/main/fbobject.c
@@ -254,14 +254,8 @@ _mesa_get_attachment(struct gl_context *ctx, struct gl_framebuffer *fb,
       if (ctx->API != API_OPENGL)
 	 return NULL;
       /* fall-through */
-   case GL_DEPTH_BUFFER:
-      /* fall-through / new in GL 3.0 */
    case GL_DEPTH_ATTACHMENT_EXT:
       return &fb->Attachment[BUFFER_DEPTH];
-   case GL_STENCIL_BUFFER:
-      if (ctx->API != API_OPENGL)
-	 return NULL;
-      /* fall-through / new in GL 3.0 */
    case GL_STENCIL_ATTACHMENT_EXT:
       return &fb->Attachment[BUFFER_STENCIL];
    default:
@@ -294,13 +288,34 @@ _mesa_get_fb0_attachment(struct gl_context *ctx, struct gl_framebuffer *fb,
          return &fb->Attachment[BUFFER_AUX0];
       }
       return NULL;
-   case GL_DEPTH_BUFFER:
-      /* fall-through / new in GL 3.0 */
-   case GL_DEPTH_ATTACHMENT_EXT:
+
+   /* Page 336 (page 352 of the PDF) of the OpenGL 3.0 spec says:
+    *
+    *     "If the default framebuffer is bound to target, then attachment must
+    *     be one of FRONT LEFT, FRONT RIGHT, BACK LEFT, BACK RIGHT, or AUXi,
+    *     identifying a color buffer; DEPTH, identifying the depth buffer; or
+    *     STENCIL, identifying the stencil buffer."
+    *
+    * Revision #34 of the ARB_framebuffer_object spec has essentially the same
+    * language.  However, revision #33 of the ARB_framebuffer_object spec
+    * says:
+    *
+    *     "If the default framebuffer is bound to <target>, then <attachment>
+    *     must be one of FRONT_LEFT, FRONT_RIGHT, BACK_LEFT, BACK_RIGHT, AUXi,
+    *     DEPTH_BUFFER, or STENCIL_BUFFER, identifying a color buffer, the
+    *     depth buffer, or the stencil buffer, and <pname> may be
+    *     FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE or
+    *     FRAMEBUFFER_ATTACHMENT_OBJECT_NAME."
+    *
+    * The enum values for DEPTH_BUFFER and STENCIL_BUFFER have been removed
+    * from glext.h, so shipping apps should not use those values.
+    *
+    * Note that neither EXT_framebuffer_object nor OES_framebuffer_object
+    * support queries of the window system FBO.
+    */
+   case GL_DEPTH:
       return &fb->Attachment[BUFFER_DEPTH];
-   case GL_STENCIL_BUFFER:
-      /* fall-through / new in GL 3.0 */
-   case GL_STENCIL_ATTACHMENT_EXT:
+   case GL_STENCIL:
       return &fb->Attachment[BUFFER_STENCIL];
    default:
       return NULL;
@@ -2261,6 +2276,21 @@ _mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment,
    }
 
    if (is_winsys_fbo(buffer)) {
+      /* Page 126 (page 136 of the PDF) of the OpenGL ES 2.0.25 spec
+       * says:
+       *
+       *     "If the framebuffer currently bound to target is zero, then
+       *     INVALID_OPERATION is generated."
+       *
+       * The EXT_framebuffer_object spec has the same wording, and the
+       * OES_framebuffer_object spec refers to the EXT_framebuffer_object
+       * spec.
+       */
+      if (ctx->API != API_OPENGL || !ctx->Extensions.ARB_framebuffer_object) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION,
+		     "glGetFramebufferAttachmentParameteriv(bound FBO = 0)");
+	 return;
+      }
       /* the default / window-system FBO */
       att = _mesa_get_fb0_attachment(ctx, buffer, attachment);
    }
diff --git a/mesalib/src/mesa/main/feedback.c b/mesalib/src/mesa/main/feedback.c
index cb5f49f67..f95e3b5d4 100644
--- a/mesalib/src/mesa/main/feedback.c
+++ b/mesalib/src/mesa/main/feedback.c
@@ -418,7 +418,7 @@ _mesa_PopName( void )
  * __struct gl_contextRec::RenderMode and notifies the driver via the
  * dd_function_table::RenderMode callback.
  */
-static GLint GLAPIENTRY
+GLint GLAPIENTRY
 _mesa_RenderMode( GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
diff --git a/mesalib/src/mesa/main/feedback.h b/mesalib/src/mesa/main/feedback.h
index 6d256ee8f..c64db3134 100644
--- a/mesalib/src/mesa/main/feedback.h
+++ b/mesalib/src/mesa/main/feedback.h
@@ -33,6 +33,9 @@
 
 #if FEATURE_feedback
 
+extern GLint GLAPIENTRY
+_mesa_RenderMode( GLenum mode );
+
 extern void
 _mesa_feedback_vertex( struct gl_context *ctx,
                        const GLfloat win[4],
diff --git a/mesalib/src/mesa/main/ff_fragment_shader.cpp b/mesalib/src/mesa/main/ff_fragment_shader.cpp
index e6451c98b..160a97c0c 100644
--- a/mesalib/src/mesa/main/ff_fragment_shader.cpp
+++ b/mesalib/src/mesa/main/ff_fragment_shader.cpp
@@ -3,6 +3,7 @@
  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
  * All Rights Reserved.
  * Copyright 2009 VMware, Inc.  All Rights Reserved.
+ * Copyright © 2010-2011 Intel Corporation
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
@@ -30,6 +31,8 @@ extern "C" {
 #include "glheader.h"
 #include "imports.h"
 #include "mtypes.h"
+#include "main/uniforms.h"
+#include "main/macros.h"
 #include "program/program.h"
 #include "program/prog_parameter.h"
 #include "program/prog_cache.h"
@@ -39,6 +42,13 @@ extern "C" {
 #include "program/programopt.h"
 #include "texenvprogram.h"
 }
+#include "../glsl/glsl_types.h"
+#include "../glsl/ir.h"
+#include "../glsl/glsl_symbol_table.h"
+#include "../glsl/glsl_parser_extras.h"
+#include "../glsl/ir_optimization.h"
+#include "../glsl/ir_print_visitor.h"
+#include "../program/ir_to_mesa.h"
 
 /*
  * Note on texture units:
@@ -59,7 +69,7 @@ struct texenvprog_cache_item
 {
    GLuint hash;
    void *key;
-   struct gl_fragment_program *data;
+   struct gl_shader_program *data;
    struct texenvprog_cache_item *next;
 };
 
@@ -76,13 +86,6 @@ texenv_doing_secondary_color(struct gl_context *ctx)
    return GL_FALSE;
 }
 
-/**
- * Up to nine instructions per tex unit, plus fog, specular color.
- */
-#define MAX_INSTRUCTIONS ((MAX_TEXTURE_COORD_UNITS * 9) + 12)
-
-#define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM)
-
 struct mode_opt {
 #ifdef __GNUC__
    __extension__ GLubyte Source:4;  /**< SRC_x */
@@ -116,8 +119,6 @@ struct state_key {
       GLuint NumArgsA:3;  /**< up to MAX_COMBINER_TERMS */
       GLuint ModeA:5;     /**< MODE_x */
 
-      GLuint texture_cyl_wrap:1; /**< For gallium test/debug only */
-
       struct mode_opt OptRGB[MAX_COMBINER_TERMS];
       struct mode_opt OptA[MAX_COMBINER_TERMS];
    } unit[MAX_TEXTURE_UNITS];
@@ -470,10 +471,6 @@ static GLuint make_state_key( struct gl_context *ctx,  struct state_key *key )
          key->unit[i].OptRGB[1].Operand = OPR_SRC_COLOR;
          key->unit[i].OptRGB[1].Source = texUnit->BumpTarget - GL_TEXTURE0 + SRC_TEXTURE0;
        }
-
-      /* this is a back-door for enabling cylindrical texture wrap mode */
-      if (texObj->Priority == 0.125)
-         key->unit[i].texture_cyl_wrap = 1;
    }
 
    /* _NEW_LIGHT | _NEW_FOG */
@@ -502,40 +499,15 @@ static GLuint make_state_key( struct gl_context *ctx,  struct state_key *key )
 }
 
 
-/**
- * Use uregs to represent registers internally, translate to Mesa's
- * expected formats on emit.  
- *
- * NOTE: These are passed by value extensively in this file rather
- * than as usual by pointer reference.  If this disturbs you, try
- * remembering they are just 32bits in size.
- *
- * GCC is smart enough to deal with these dword-sized structures in
- * much the same way as if I had defined them as dwords and was using
- * macros to access and set the fields.  This is much nicer and easier
- * to evolve.
- */
-struct ureg {
-   GLuint file:4;
-   GLuint idx:8;
-   GLuint negatebase:1;
-   GLuint swz:12;
-   GLuint pad:7;
-};
-
-static const struct ureg undef = { 
-   PROGRAM_UNDEFINED,
-   255,
-   0,
-   0,
-   0
-};
-
-
 /** State used to build the fragment program:
  */
 struct texenv_fragment_program {
+   struct gl_shader_program *shader_program;
+   struct gl_shader *shader;
    struct gl_fragment_program *program;
+   exec_list *instructions;
+   exec_list *top_instructions;
+   void *mem_ctx;
    struct state_key *state;
 
    GLbitfield alu_temps;	/**< Track texture indirections, see spec. */
@@ -543,386 +515,60 @@ struct texenv_fragment_program {
    GLbitfield temp_in_use;	/**< Tracks temporary regs which are in use. */
    GLboolean error;
 
-   struct ureg src_texture[MAX_TEXTURE_COORD_UNITS];   
+   ir_variable *src_texture[MAX_TEXTURE_COORD_UNITS];
    /* Reg containing each texture unit's sampled texture color,
     * else undef.
     */
 
-   struct ureg texcoord_tex[MAX_TEXTURE_COORD_UNITS];
+   /* Texcoord override from bumpmapping. */
+   struct ir_variable *texcoord_tex[MAX_TEXTURE_COORD_UNITS];
+
    /* Reg containing texcoord for a texture unit,
     * needed for bump mapping, else undef.
     */
 
-   struct ureg src_previous;	/**< Reg containing color from previous 
+   ir_rvalue *src_previous;	/**< Reg containing color from previous
 				 * stage.  May need to be decl'd.
 				 */
 
    GLuint last_tex_stage;	/**< Number of last enabled texture unit */
-
-   struct ureg half;
-   struct ureg one;
-   struct ureg zero;
 };
 
-
-
-static struct ureg make_ureg(GLuint file, GLuint idx)
+static ir_rvalue *
+get_current_attrib(struct texenv_fragment_program *p, GLuint attrib)
 {
-   struct ureg reg;
-   reg.file = file;
-   reg.idx = idx;
-   reg.negatebase = 0;
-   reg.swz = SWIZZLE_NOOP;
-   reg.pad = 0;
-   return reg;
+   ir_variable *current;
+   ir_rvalue *val;
+
+   current = p->shader->symbols->get_variable("gl_CurrentAttribFragMESA");
+   current->max_array_access = MAX2(current->max_array_access, attrib);
+   val = new(p->mem_ctx) ir_dereference_variable(current);
+   ir_rvalue *index = new(p->mem_ctx) ir_constant(attrib);
+   return new(p->mem_ctx) ir_dereference_array(val, index);
 }
 
-static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
+static ir_rvalue *
+get_gl_Color(struct texenv_fragment_program *p)
 {
-   reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),
-			   GET_SWZ(reg.swz, y),
-			   GET_SWZ(reg.swz, z),
-			   GET_SWZ(reg.swz, w));
-
-   return reg;
-}
-
-static struct ureg swizzle1( struct ureg reg, int x )
-{
-   return swizzle(reg, x, x, x, x);
-}
-
-static struct ureg negate( struct ureg reg )
-{
-   reg.negatebase ^= 1;
-   return reg;
-}
-
-static GLboolean is_undef( struct ureg reg )
-{
-   return reg.file == PROGRAM_UNDEFINED;
-}
-
-
-static struct ureg get_temp( struct texenv_fragment_program *p )
-{
-   GLint bit;
-   
-   /* First try and reuse temps which have been used already:
-    */
-   bit = _mesa_ffs( ~p->temp_in_use & p->alu_temps );
-
-   /* Then any unused temporary:
-    */
-   if (!bit)
-      bit = _mesa_ffs( ~p->temp_in_use );
-
-   if (!bit) {
-      _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
-      exit(1);
+   if (p->state->inputs_available & FRAG_BIT_COL0) {
+      ir_variable *var = p->shader->symbols->get_variable("gl_Color");
+      assert(var);
+      return new(p->mem_ctx) ir_dereference_variable(var);
+   } else {
+      return get_current_attrib(p, VERT_ATTRIB_COLOR0);
    }
-
-   if ((GLuint) bit > p->program->Base.NumTemporaries)
-      p->program->Base.NumTemporaries = bit;
-
-   p->temp_in_use |= 1<<(bit-1);
-   return make_ureg(PROGRAM_TEMPORARY, (bit-1));
 }
 
-static struct ureg get_tex_temp( struct texenv_fragment_program *p )
+static ir_rvalue *
+get_source(struct texenv_fragment_program *p,
+	   GLuint src, GLuint unit)
 {
-   int bit;
-   
-   /* First try to find available temp not previously used (to avoid
-    * starting a new texture indirection).  According to the spec, the
-    * ~p->temps_output isn't necessary, but will keep it there for
-    * now:
-    */
-   bit = _mesa_ffs( ~p->temp_in_use & ~p->alu_temps & ~p->temps_output );
-
-   /* Then any unused temporary:
-    */
-   if (!bit) 
-      bit = _mesa_ffs( ~p->temp_in_use );
-
-   if (!bit) {
-      _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
-      exit(1);
-   }
+   ir_variable *var;
+   ir_dereference *deref;
 
-   if ((GLuint) bit > p->program->Base.NumTemporaries)
-      p->program->Base.NumTemporaries = bit;
-
-   p->temp_in_use |= 1<<(bit-1);
-   return make_ureg(PROGRAM_TEMPORARY, (bit-1));
-}
-
-
-/** Mark a temp reg as being no longer allocatable. */
-static void reserve_temp( struct texenv_fragment_program *p, struct ureg r )
-{
-   if (r.file == PROGRAM_TEMPORARY)
-      p->temps_output |= (1 << r.idx);
-}
-
-
-static void release_temps(struct gl_context *ctx, struct texenv_fragment_program *p )
-{
-   GLuint max_temp = ctx->Const.FragmentProgram.MaxTemps;
-
-   /* KW: To support tex_env_crossbar, don't release the registers in
-    * temps_output.
-    */
-   if (max_temp >= sizeof(int) * 8)
-      p->temp_in_use = p->temps_output;
-   else
-      p->temp_in_use = ~((1<<max_temp)-1) | p->temps_output;
-}
-
-
-static struct ureg register_param5( struct texenv_fragment_program *p, 
-				    GLint s0,
-				    GLint s1,
-				    GLint s2,
-				    GLint s3,
-				    GLint s4)
-{
-   int tokens[STATE_LENGTH];
-   GLuint idx;
-   tokens[0] = s0;
-   tokens[1] = s1;
-   tokens[2] = s2;
-   tokens[3] = s3;
-   tokens[4] = s4;
-   idx = _mesa_add_state_reference(p->program->Base.Parameters,
-				   (gl_state_index *)tokens);
-   return make_ureg(PROGRAM_STATE_VAR, idx);
-}
-
-
-#define register_param1(p,s0)          register_param5(p,s0,0,0,0,0)
-#define register_param2(p,s0,s1)       register_param5(p,s0,s1,0,0,0)
-#define register_param3(p,s0,s1,s2)    register_param5(p,s0,s1,s2,0,0)
-#define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
-
-static GLuint frag_to_vert_attrib( GLuint attrib )
-{
-   switch (attrib) {
-   case FRAG_ATTRIB_COL0: return VERT_ATTRIB_COLOR0;
-   case FRAG_ATTRIB_COL1: return VERT_ATTRIB_COLOR1;
-   default:
-      assert(attrib >= FRAG_ATTRIB_TEX0);
-      assert(attrib <= FRAG_ATTRIB_TEX7);
-      return attrib - FRAG_ATTRIB_TEX0 + VERT_ATTRIB_TEX0;
-   }
-}
-
-
-static struct ureg register_input( struct texenv_fragment_program *p, GLuint input )
-{
-   if (p->state->inputs_available & (1<<input)) {
-      p->program->Base.InputsRead |= (1 << input);
-      return make_ureg(PROGRAM_INPUT, input);
-   }
-   else {
-      GLuint idx = frag_to_vert_attrib( input );
-      return register_param3( p, STATE_INTERNAL, STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED, idx );
-   }
-}
-
-
-static void emit_arg( struct prog_src_register *reg,
-		      struct ureg ureg )
-{
-   reg->File = ureg.file;
-   reg->Index = ureg.idx;
-   reg->Swizzle = ureg.swz;
-   reg->Negate = ureg.negatebase ? NEGATE_XYZW : NEGATE_NONE;
-   reg->Abs = GL_FALSE;
-}
-
-static void emit_dst( struct prog_dst_register *dst,
-		      struct ureg ureg, GLuint mask )
-{
-   dst->File = ureg.file;
-   dst->Index = ureg.idx;
-   dst->WriteMask = mask;
-   dst->CondMask = COND_TR;  /* always pass cond test */
-   dst->CondSwizzle = SWIZZLE_NOOP;
-}
-
-static struct prog_instruction *
-emit_op(struct texenv_fragment_program *p,
-	enum prog_opcode op,
-	struct ureg dest,
-	GLuint mask,
-	GLboolean saturate,
-	struct ureg src0,
-	struct ureg src1,
-	struct ureg src2 )
-{
-   const GLuint nr = p->program->Base.NumInstructions++;
-   struct prog_instruction *inst = &p->program->Base.Instructions[nr];
-
-   assert(nr < MAX_INSTRUCTIONS);
-
-   _mesa_init_instructions(inst, 1);
-   inst->Opcode = op;
-   
-   emit_arg( &inst->SrcReg[0], src0 );
-   emit_arg( &inst->SrcReg[1], src1 );
-   emit_arg( &inst->SrcReg[2], src2 );
-   
-   inst->SaturateMode = saturate ? SATURATE_ZERO_ONE : SATURATE_OFF;
-
-   emit_dst( &inst->DstReg, dest, mask );
-
-#if 0
-   /* Accounting for indirection tracking:
-    */
-   if (dest.file == PROGRAM_TEMPORARY)
-      p->temps_output |= 1 << dest.idx;
-#endif
-
-   return inst;
-}
-   
-
-static struct ureg emit_arith( struct texenv_fragment_program *p,
-			       enum prog_opcode op,
-			       struct ureg dest,
-			       GLuint mask,
-			       GLboolean saturate,
-			       struct ureg src0,
-			       struct ureg src1,
-			       struct ureg src2 )
-{
-   emit_op(p, op, dest, mask, saturate, src0, src1, src2);
-   
-   /* Accounting for indirection tracking:
-    */
-   if (src0.file == PROGRAM_TEMPORARY)
-      p->alu_temps |= 1 << src0.idx;
-
-   if (!is_undef(src1) && src1.file == PROGRAM_TEMPORARY)
-      p->alu_temps |= 1 << src1.idx;
-
-   if (!is_undef(src2) && src2.file == PROGRAM_TEMPORARY)
-      p->alu_temps |= 1 << src2.idx;
-
-   if (dest.file == PROGRAM_TEMPORARY)
-      p->alu_temps |= 1 << dest.idx;
-       
-   p->program->Base.NumAluInstructions++;
-   return dest;
-}
-
-static struct ureg emit_texld( struct texenv_fragment_program *p,
-			       enum prog_opcode op,
-			       struct ureg dest,
-			       GLuint destmask,
-			       GLuint tex_unit,
-			       GLuint tex_idx,
-                               GLuint tex_shadow,
-			       struct ureg coord )
-{
-   struct prog_instruction *inst = emit_op( p, op, 
-					  dest, destmask, 
-					  GL_FALSE,	/* don't saturate? */
-					  coord, 	/* arg 0? */
-					  undef,
-					  undef);
-   
-   inst->TexSrcTarget = tex_idx;
-   inst->TexSrcUnit = tex_unit;
-   inst->TexShadow = tex_shadow;
-
-   p->program->Base.NumTexInstructions++;
-
-   /* Accounting for indirection tracking:
-    */
-   reserve_temp(p, dest);
-
-#if 0
-   /* Is this a texture indirection?
-    */
-   if ((coord.file == PROGRAM_TEMPORARY &&
-	(p->temps_output & (1<<coord.idx))) ||
-       (dest.file == PROGRAM_TEMPORARY &&
-	(p->alu_temps & (1<<dest.idx)))) {
-      p->program->Base.NumTexIndirections++;
-      p->temps_output = 1<<coord.idx;
-      p->alu_temps = 0;
-      assert(0);		/* KW: texture env crossbar */
-   }
-#endif
-
-   return dest;
-}
-
-
-static struct ureg register_const4f( struct texenv_fragment_program *p, 
-				     GLfloat s0,
-				     GLfloat s1,
-				     GLfloat s2,
-				     GLfloat s3)
-{
-   GLfloat values[4];
-   GLuint idx, swizzle;
-   struct ureg r;
-   values[0] = s0;
-   values[1] = s1;
-   values[2] = s2;
-   values[3] = s3;
-   idx = _mesa_add_unnamed_constant( p->program->Base.Parameters,
-                                     (gl_constant_value *) values, 4,
-                                     &swizzle );
-   r = make_ureg(PROGRAM_CONSTANT, idx);
-   r.swz = swizzle;
-   return r;
-}
-
-#define register_scalar_const(p, s0)    register_const4f(p, s0, s0, s0, s0)
-#define register_const1f(p, s0)         register_const4f(p, s0, 0, 0, 1)
-#define register_const2f(p, s0, s1)     register_const4f(p, s0, s1, 0, 1)
-#define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
-
-
-static struct ureg get_one( struct texenv_fragment_program *p )
-{
-   if (is_undef(p->one)) 
-      p->one = register_scalar_const(p, 1.0);
-   return p->one;
-}
-
-static struct ureg get_half( struct texenv_fragment_program *p )
-{
-   if (is_undef(p->half)) 
-      p->half = register_scalar_const(p, 0.5);
-   return p->half;
-}
-
-static struct ureg get_zero( struct texenv_fragment_program *p )
-{
-   if (is_undef(p->zero)) 
-      p->zero = register_scalar_const(p, 0.0);
-   return p->zero;
-}
-
-
-static void program_error( struct texenv_fragment_program *p, const char *msg )
-{
-   _mesa_problem(NULL, "%s", msg);
-   p->error = 1;
-}
-
-static struct ureg get_source( struct texenv_fragment_program *p, 
-			       GLuint src, GLuint unit )
-{
    switch (src) {
    case SRC_TEXTURE: 
-      assert(!is_undef(p->src_texture[unit]));
-      return p->src_texture[unit];
+      return new(p->mem_ctx) ir_dereference_variable(p->src_texture[unit]);
 
    case SRC_TEXTURE0:
    case SRC_TEXTURE1:
@@ -932,66 +578,67 @@ static struct ureg get_source( struct texenv_fragment_program *p,
    case SRC_TEXTURE5:
    case SRC_TEXTURE6:
    case SRC_TEXTURE7: 
-      assert(!is_undef(p->src_texture[src - SRC_TEXTURE0]));
-      return p->src_texture[src - SRC_TEXTURE0];
+      return new(p->mem_ctx)
+	 ir_dereference_variable(p->src_texture[src - SRC_TEXTURE0]);
 
    case SRC_CONSTANT:
-      return register_param2(p, STATE_TEXENV_COLOR, unit);
+      var = p->shader->symbols->get_variable("gl_TextureEnvColor");
+      assert(var);
+      deref = new(p->mem_ctx) ir_dereference_variable(var);
+      var->max_array_access = MAX2(var->max_array_access, unit);
+      return new(p->mem_ctx) ir_dereference_array(deref,
+						  new(p->mem_ctx) ir_constant(unit));
 
    case SRC_PRIMARY_COLOR:
-      return register_input(p, FRAG_ATTRIB_COL0);
+      var = p->shader->symbols->get_variable("gl_Color");
+      assert(var);
+      return new(p->mem_ctx) ir_dereference_variable(var);
 
    case SRC_ZERO:
-      return get_zero(p);
+      return new(p->mem_ctx) ir_constant(0.0f);
 
    case SRC_PREVIOUS:
-      if (is_undef(p->src_previous))
-	 return register_input(p, FRAG_ATTRIB_COL0);
-      else
-	 return p->src_previous;
+      if (!p->src_previous) {
+	 return get_gl_Color(p);
+      } else {
+	 return p->src_previous->clone(p->mem_ctx, NULL);
+      }
 
    default:
       assert(0);
-      return undef;
+      return NULL;
    }
 }
 
-static struct ureg emit_combine_source( struct texenv_fragment_program *p, 
-					GLuint mask,
-					GLuint unit,
-					GLuint source, 
-					GLuint operand )
+static ir_rvalue *
+emit_combine_source(struct texenv_fragment_program *p,
+		    GLuint unit,
+		    GLuint source,
+		    GLuint operand)
 {
-   struct ureg arg, src, one;
+   ir_rvalue *src;
 
    src = get_source(p, source, unit);
 
    switch (operand) {
    case OPR_ONE_MINUS_SRC_COLOR: 
-      /* Get unused tmp,
-       * Emit tmp = 1.0 - arg.xyzw
-       */
-      arg = get_temp( p );
-      one = get_one( p );
-      return emit_arith( p, OPCODE_SUB, arg, mask, 0, one, src, undef);
+      return new(p->mem_ctx) ir_expression(ir_binop_sub,
+					   new(p->mem_ctx) ir_constant(1.0f),
+					   src);
 
    case OPR_SRC_ALPHA: 
-      if (mask == WRITEMASK_W)
-	 return src;
-      else
-	 return swizzle1( src, SWIZZLE_W );
+      return new(p->mem_ctx) ir_swizzle(src, 3, 3, 3, 3, 1);
+
    case OPR_ONE_MINUS_SRC_ALPHA: 
-      /* Get unused tmp,
-       * Emit tmp = 1.0 - arg.wwww
-       */
-      arg = get_temp(p);
-      one = get_one(p);
-      return emit_arith(p, OPCODE_SUB, arg, mask, 0,
-			one, swizzle1(src, SWIZZLE_W), undef);
+      return new(p->mem_ctx) ir_expression(ir_binop_sub,
+					   new(p->mem_ctx) ir_constant(1.0f),
+					   new(p->mem_ctx) ir_swizzle(src,
+								      3, 3,
+								      3, 3, 1));
    case OPR_ZERO:
-      return get_zero(p);
+      return new(p->mem_ctx) ir_constant(0.0f);
    case OPR_ONE:
-      return get_one(p);
+      return new(p->mem_ctx) ir_constant(1.0f);
    case OPR_SRC_COLOR: 
       return src;
    default:
@@ -1040,112 +687,104 @@ static GLboolean args_match( const struct state_key *key, GLuint unit )
    return GL_TRUE;
 }
 
-static struct ureg emit_combine( struct texenv_fragment_program *p,
-				 struct ureg dest,
-				 GLuint mask,
-				 GLboolean saturate,
-				 GLuint unit,
-				 GLuint nr,
-				 GLuint mode,
-				 const struct mode_opt *opt)
+static ir_rvalue *
+smear(struct texenv_fragment_program *p, ir_rvalue *val)
 {
-   struct ureg src[MAX_COMBINER_TERMS];
-   struct ureg tmp, half;
+   if (!val->type->is_scalar())
+      return val;
+
+   return new(p->mem_ctx) ir_swizzle(val, 0, 0, 0, 0, 4);
+}
+
+static ir_rvalue *
+emit_combine(struct texenv_fragment_program *p,
+	     GLuint unit,
+	     GLuint nr,
+	     GLuint mode,
+	     const struct mode_opt *opt)
+{
+   ir_rvalue *src[MAX_COMBINER_TERMS];
+   ir_rvalue *tmp0, *tmp1;
    GLuint i;
 
    assert(nr <= MAX_COMBINER_TERMS);
 
    for (i = 0; i < nr; i++)
-      src[i] = emit_combine_source( p, mask, unit, opt[i].Source, opt[i].Operand );
+      src[i] = emit_combine_source( p, unit, opt[i].Source, opt[i].Operand );
 
    switch (mode) {
    case MODE_REPLACE: 
-      if (mask == WRITEMASK_XYZW && !saturate)
-	 return src[0];
-      else
-	 return emit_arith( p, OPCODE_MOV, dest, mask, saturate, src[0], undef, undef );
+      return src[0];
+
    case MODE_MODULATE: 
-      return emit_arith( p, OPCODE_MUL, dest, mask, saturate,
-			 src[0], src[1], undef );
+      return new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[1]);
+
    case MODE_ADD: 
-      return emit_arith( p, OPCODE_ADD, dest, mask, saturate, 
-			 src[0], src[1], undef );
+      return new(p->mem_ctx) ir_expression(ir_binop_add, src[0], src[1]);
+
    case MODE_ADD_SIGNED:
-      /* tmp = arg0 + arg1
-       * result = tmp - .5
-       */
-      half = get_half(p);
-      tmp = get_temp( p );
-      emit_arith( p, OPCODE_ADD, tmp, mask, 0, src[0], src[1], undef );
-      emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp, half, undef );
-      return dest;
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add, src[0], src[1]);
+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0,
+					   new(p->mem_ctx) ir_constant(-0.5f));
+
    case MODE_INTERPOLATE: 
-      /* Arg0 * (Arg2) + Arg1 * (1-Arg2) -- note arguments are reordered:
-       */
-      return emit_arith( p, OPCODE_LRP, dest, mask, saturate, src[2], src[0], src[1] );
+      /* Arg0 * (Arg2) + Arg1 * (1-Arg2) */
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[2]);
+
+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_sub,
+					   new(p->mem_ctx) ir_constant(1.0f),
+					   src[2]->clone(p->mem_ctx, NULL));
+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[1], tmp1);
+
+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, tmp1);
 
    case MODE_SUBTRACT: 
-      return emit_arith( p, OPCODE_SUB, dest, mask, saturate, src[0], src[1], undef );
+      return new(p->mem_ctx) ir_expression(ir_binop_sub, src[0], src[1]);
 
    case MODE_DOT3_RGBA:
    case MODE_DOT3_RGBA_EXT: 
    case MODE_DOT3_RGB_EXT:
    case MODE_DOT3_RGB: {
-      struct ureg tmp0 = get_temp( p );
-      struct ureg tmp1 = get_temp( p );
-      struct ureg neg1 = register_scalar_const(p, -1);
-      struct ureg two  = register_scalar_const(p, 2);
-
-      /* tmp0 = 2*src0 - 1
-       * tmp1 = 2*src1 - 1
-       *
-       * dst = tmp0 dot3 tmp1 
-       */
-      emit_arith( p, OPCODE_MAD, tmp0, WRITEMASK_XYZW, 0, 
-		  two, src[0], neg1);
-
-      if (memcmp(&src[0], &src[1], sizeof(struct ureg)) == 0)
-	 tmp1 = tmp0;
-      else
-	 emit_arith( p, OPCODE_MAD, tmp1, WRITEMASK_XYZW, 0, 
-		     two, src[1], neg1);
-      emit_arith( p, OPCODE_DP3, dest, mask, saturate, tmp0, tmp1, undef);
-      return dest;
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0],
+					   new(p->mem_ctx) ir_constant(2.0f));
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add, tmp0,
+					   new(p->mem_ctx) ir_constant(-1.0f));
+      tmp0 = new(p->mem_ctx) ir_swizzle(smear(p, tmp0), 0, 1, 2, 3, 3);
+
+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[1],
+					   new(p->mem_ctx) ir_constant(2.0f));
+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_add, tmp1,
+					   new(p->mem_ctx) ir_constant(-1.0f));
+      tmp1 = new(p->mem_ctx) ir_swizzle(smear(p, tmp1), 0, 1, 2, 3, 3);
+
+      return new(p->mem_ctx) ir_expression(ir_binop_dot, tmp0, tmp1);
    }
    case MODE_MODULATE_ADD_ATI:
-      /* Arg0 * Arg2 + Arg1 */
-      return emit_arith( p, OPCODE_MAD, dest, mask, saturate,
-			 src[0], src[2], src[1] );
-   case MODE_MODULATE_SIGNED_ADD_ATI: {
-      /* Arg0 * Arg2 + Arg1 - 0.5 */
-      struct ureg tmp0 = get_temp(p);
-      half = get_half(p);
-      emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[0], src[2], src[1] );
-      emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );
-      return dest;
-   }
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[2]);
+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, src[1]);
+
+   case MODE_MODULATE_SIGNED_ADD_ATI:
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[2]);
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, src[1]);
+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0,
+					   new(p->mem_ctx) ir_constant(-0.5f));
+
    case MODE_MODULATE_SUBTRACT_ATI:
-      /* Arg0 * Arg2 - Arg1 */
-      emit_arith( p, OPCODE_MAD, dest, mask, 0, src[0], src[2], negate(src[1]) );
-      return dest;
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[2]);
+      return new(p->mem_ctx) ir_expression(ir_binop_sub, tmp0, src[1]);
+
    case MODE_ADD_PRODUCTS:
-      /* Arg0 * Arg1 + Arg2 * Arg3 */
-      {
-         struct ureg tmp0 = get_temp(p);
-         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );
-         emit_arith( p, OPCODE_MAD, dest, mask, saturate, src[2], src[3], tmp0 );
-      }
-      return dest;
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[1]);
+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[2], src[3]);
+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, tmp1);
+
    case MODE_ADD_PRODUCTS_SIGNED:
-      /* Arg0 * Arg1 + Arg2 * Arg3 - 0.5 */
-      {
-         struct ureg tmp0 = get_temp(p);
-         half = get_half(p);
-         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );
-         emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[2], src[3], tmp0 );
-         emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );
-      }
-      return dest;
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[1]);
+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[2], src[3]);
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, tmp1);
+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0,
+					   new(p->mem_ctx) ir_constant(-0.5f));
+
    case MODE_BUMP_ENVMAP_ATI:
       /* special - not handled here */
       assert(0);
@@ -1156,17 +795,24 @@ static struct ureg emit_combine( struct texenv_fragment_program *p,
    }
 }
 
+static ir_rvalue *
+saturate(struct texenv_fragment_program *p, ir_rvalue *val)
+{
+   val = new(p->mem_ctx) ir_expression(ir_binop_min, val,
+				       new(p->mem_ctx) ir_constant(1.0f));
+   return new(p->mem_ctx) ir_expression(ir_binop_max, val,
+					new(p->mem_ctx) ir_constant(0.0f));
+}
 
 /**
  * Generate instructions for one texture unit's env/combiner mode.
  */
-static struct ureg
+static ir_rvalue *
 emit_texenv(struct texenv_fragment_program *p, GLuint unit)
 {
    const struct state_key *key = p->state;
    GLboolean rgb_saturate, alpha_saturate;
    GLuint rgb_shift, alpha_shift;
-   struct ureg out, dest;
 
    if (!key->unit[unit].enabled) {
       return get_source(p, SRC_PREVIOUS, 0);
@@ -1208,74 +854,99 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
    else
       alpha_saturate = GL_FALSE;
 
-   /* If this is the very last calculation (and various other conditions
-    * are met), emit directly to the color output register.  Otherwise,
-    * emit to a temporary register.
-    */
-   if (key->separate_specular ||
-       unit != p->last_tex_stage ||
-       alpha_shift ||
-       key->num_draw_buffers != 1 ||
-       rgb_shift)
-      dest = get_temp( p );
-   else
-      dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR);
+   ir_variable *temp_var = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
+						       "texenv_combine",
+						       ir_var_temporary);
+   p->instructions->push_tail(temp_var);
+
+   ir_dereference *deref;
+   ir_assignment *assign;
+   ir_rvalue *val;
 
    /* Emit the RGB and A combine ops
     */
    if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&
        args_match(key, unit)) {
-      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
-			  unit,
-			  key->unit[unit].NumArgsRGB,
-			  key->unit[unit].ModeRGB,
-			  key->unit[unit].OptRGB);
+      val = emit_combine(p, unit,
+			 key->unit[unit].NumArgsRGB,
+			 key->unit[unit].ModeRGB,
+			 key->unit[unit].OptRGB);
+      val = smear(p, val);
+      if (rgb_saturate)
+	 val = saturate(p, val);
+
+      deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
+      assign = new(p->mem_ctx) ir_assignment(deref, val);
+      p->instructions->push_tail(assign);
    }
    else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||
 	    key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {
-      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
-			  unit,
-			  key->unit[unit].NumArgsRGB,
-			  key->unit[unit].ModeRGB,
-			  key->unit[unit].OptRGB);
+      ir_rvalue *val = emit_combine(p, unit,
+				    key->unit[unit].NumArgsRGB,
+				    key->unit[unit].ModeRGB,
+				    key->unit[unit].OptRGB);
+      val = smear(p, val);
+      if (rgb_saturate)
+	 val = saturate(p, val);
+      deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
+      assign = new(p->mem_ctx) ir_assignment(deref, val);
+      p->instructions->push_tail(assign);
    }
    else {
       /* Need to do something to stop from re-emitting identical
        * argument calculations here:
        */
-      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, alpha_saturate,
-			  unit,
-			  key->unit[unit].NumArgsA,
-			  key->unit[unit].ModeA,
-			  key->unit[unit].OptA);
+      val = emit_combine(p, unit,
+			 key->unit[unit].NumArgsRGB,
+			 key->unit[unit].ModeRGB,
+			 key->unit[unit].OptRGB);
+      val = smear(p, val);
+      val = new(p->mem_ctx) ir_swizzle(val, 0, 1, 2, 3, 3);
+      if (rgb_saturate)
+	 val = saturate(p, val);
+      deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
+      assign = new(p->mem_ctx) ir_assignment(deref, val, NULL, WRITEMASK_XYZ);
+      p->instructions->push_tail(assign);
+
+      val = emit_combine(p, unit,
+			 key->unit[unit].NumArgsA,
+			 key->unit[unit].ModeA,
+			 key->unit[unit].OptA);
+      val = smear(p, val);
+      val = new(p->mem_ctx) ir_swizzle(val, 3, 3, 3, 3, 1);
+      if (alpha_saturate)
+	 val = saturate(p, val);
+      deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
+      assign = new(p->mem_ctx) ir_assignment(deref, val, NULL, WRITEMASK_W);
+      p->instructions->push_tail(assign);
    }
 
+   deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
+
    /* Deal with the final shift:
     */
    if (alpha_shift || rgb_shift) {
-      struct ureg shift;
-      GLboolean saturate = GL_TRUE;  /* always saturate at this point */
+      ir_constant *shift;
 
       if (rgb_shift == alpha_shift) {
-	 shift = register_scalar_const(p, (GLfloat)(1<<rgb_shift));
+	 shift = new(p->mem_ctx) ir_constant((float)(1 << rgb_shift));
       }
       else {
-	 shift = register_const4f(p, 
-				  (GLfloat)(1<<rgb_shift),
-				  (GLfloat)(1<<rgb_shift),
-				  (GLfloat)(1<<rgb_shift),
-				  (GLfloat)(1<<alpha_shift));
+	 float const_data[4] = {
+	    1 << rgb_shift,
+	    1 << rgb_shift,
+	    1 << rgb_shift,
+	    1 << alpha_shift
+	 };
+	 shift = new(p->mem_ctx) ir_constant(glsl_type::vec4_type,
+					     (ir_constant_data *)const_data);
       }
-      return emit_arith( p, OPCODE_MUL, dest, WRITEMASK_XYZW, 
-			 saturate, out, shift, undef );
+
+      return saturate(p, new(p->mem_ctx) ir_expression(ir_binop_mul,
+						       deref, shift));
    }
    else
-      return out;
+      return deref;
 }
 
 
@@ -1284,53 +955,131 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
  */
 static void load_texture( struct texenv_fragment_program *p, GLuint unit )
 {
-   if (is_undef(p->src_texture[unit])) {
-      const GLuint texTarget = p->state->unit[unit].source_index;
-      struct ureg texcoord;
-      struct ureg tmp = get_tex_temp( p );
+   ir_dereference *deref;
+   ir_assignment *assign;
 
-      if (is_undef(p->texcoord_tex[unit])) {
-         texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit);
-      }
-      else {
-         /* might want to reuse this reg for tex output actually */
-         texcoord = p->texcoord_tex[unit];
-      }
+   if (p->src_texture[unit])
+      return;
 
-      /* TODO: Use D0_MASK_XY where possible.
-       */
-      if (p->state->unit[unit].enabled) {
-         GLboolean shadow = GL_FALSE;
-
-	 if (p->state->unit[unit].shadow) {
-	    p->program->Base.ShadowSamplers |= 1 << unit;
-            shadow = GL_TRUE;
-         }
-
-	 p->src_texture[unit] = emit_texld( p, OPCODE_TXP,
-					    tmp, WRITEMASK_XYZW, 
-					    unit, texTarget, shadow,
-                                            texcoord );
-
-         p->program->Base.SamplersUsed |= (1 << unit);
-         /* This identity mapping should already be in place
-          * (see _mesa_init_program_struct()) but let's be safe.
-          */
-         p->program->Base.SamplerUnits[unit] = unit;
-      }
+   const GLuint texTarget = p->state->unit[unit].source_index;
+   ir_rvalue *texcoord;
+
+   if (!(p->state->inputs_available & (FRAG_BIT_TEX0 << unit))) {
+      texcoord = get_current_attrib(p, VERT_ATTRIB_TEX0 + unit);
+   } else if (p->texcoord_tex[unit]) {
+      texcoord = new(p->mem_ctx) ir_dereference_variable(p->texcoord_tex[unit]);
+   } else {
+      ir_variable *tc_array = p->shader->symbols->get_variable("gl_TexCoord");
+      assert(tc_array);
+      texcoord = new(p->mem_ctx) ir_dereference_variable(tc_array);
+      ir_rvalue *index = new(p->mem_ctx) ir_constant(unit);
+      texcoord = new(p->mem_ctx) ir_dereference_array(texcoord, index);
+      tc_array->max_array_access = MAX2(tc_array->max_array_access, unit);
+   }
+
+   if (!p->state->unit[unit].enabled) {
+      p->src_texture[unit] = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
+							 "dummy_tex",
+							 ir_var_temporary);
+      p->instructions->push_tail(p->src_texture[unit]);
+
+      deref = new(p->mem_ctx) ir_dereference_variable(p->src_texture[unit]);
+      assign = new(p->mem_ctx) ir_assignment(deref,
+					     new(p->mem_ctx) ir_constant(0.0f));
+      p->instructions->push_tail(assign);
+      return ;
+   }
+
+   const glsl_type *sampler_type = NULL;
+   int coords = 0;
+
+   switch (texTarget) {
+   case TEXTURE_1D_INDEX:
+      if (p->state->unit[unit].shadow)
+	 sampler_type = p->shader->symbols->get_type("sampler1DShadow");
+      else
+	 sampler_type = p->shader->symbols->get_type("sampler1D");
+      coords = 1;
+      break;
+   case TEXTURE_1D_ARRAY_INDEX:
+      if (p->state->unit[unit].shadow)
+	 sampler_type = p->shader->symbols->get_type("sampler1DArrayShadow");
       else
-	 p->src_texture[unit] = get_zero(p);
+	 sampler_type = p->shader->symbols->get_type("sampler1DArray");
+      coords = 2;
+      break;
+   case TEXTURE_2D_INDEX:
+      if (p->state->unit[unit].shadow)
+	 sampler_type = p->shader->symbols->get_type("sampler2DShadow");
+      else
+	 sampler_type = p->shader->symbols->get_type("sampler2D");
+      coords = 2;
+      break;
+   case TEXTURE_2D_ARRAY_INDEX:
+      if (p->state->unit[unit].shadow)
+	 sampler_type = p->shader->symbols->get_type("sampler2DArrayShadow");
+      else
+	 sampler_type = p->shader->symbols->get_type("sampler2DArray");
+      coords = 3;
+      break;
+   case TEXTURE_RECT_INDEX:
+      if (p->state->unit[unit].shadow)
+	 sampler_type = p->shader->symbols->get_type("sampler2DRectShadow");
+      else
+	 sampler_type = p->shader->symbols->get_type("sampler2DRect");
+      coords = 2;
+      break;
+   case TEXTURE_3D_INDEX:
+      assert(!p->state->unit[unit].shadow);
+      sampler_type = p->shader->symbols->get_type("sampler3D");
+      coords = 3;
+      break;
+   case TEXTURE_CUBE_INDEX:
+      if (p->state->unit[unit].shadow)
+	 sampler_type = p->shader->symbols->get_type("samplerCubeShadow");
+      else
+	 sampler_type = p->shader->symbols->get_type("samplerCube");
+      coords = 3;
+      break;
+   }
+
+   p->src_texture[unit] = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
+						      "tex",
+						      ir_var_temporary);
+   p->instructions->push_tail(p->src_texture[unit]);
+
+   ir_texture *tex = new(p->mem_ctx) ir_texture(ir_tex);
 
-      if (p->state->unit[unit].texture_cyl_wrap) {
-         /* set flag which is checked by Mesa->Gallium program translation */
-         p->program->Base.InputFlags[0] |= PROG_PARAM_BIT_CYL_WRAP;
-      }
 
+   char *sampler_name = ralloc_asprintf(p->mem_ctx, "sampler_%d", unit);
+   ir_variable *sampler = new(p->mem_ctx) ir_variable(sampler_type,
+						      sampler_name,
+						      ir_var_uniform);
+   p->top_instructions->push_head(sampler);
+   deref = new(p->mem_ctx) ir_dereference_variable(sampler);
+   tex->set_sampler(deref, glsl_type::vec4_type);
+
+   tex->coordinate = new(p->mem_ctx) ir_swizzle(texcoord, 0, 1, 2, 3, coords);
+
+   if (p->state->unit[unit].shadow) {
+      texcoord = texcoord->clone(p->mem_ctx, NULL);
+      tex->shadow_comparitor = new(p->mem_ctx) ir_swizzle(texcoord,
+							  coords, 0, 0, 0,
+							  1);
+      coords++;
    }
+
+   texcoord = texcoord->clone(p->mem_ctx, NULL);
+   tex->projector = new(p->mem_ctx) ir_swizzle(texcoord, 3, 0, 0, 0, 1);
+
+   deref = new(p->mem_ctx) ir_dereference_variable(p->src_texture[unit]);
+   assign = new(p->mem_ctx) ir_assignment(deref, tex);
+   p->instructions->push_tail(assign);
 }
 
-static GLboolean load_texenv_source( struct texenv_fragment_program *p, 
-				     GLuint src, GLuint unit )
+static void
+load_texenv_source(struct texenv_fragment_program *p,
+		   GLuint src, GLuint unit)
 {
    switch (src) {
    case SRC_TEXTURE:
@@ -1352,8 +1101,6 @@ static GLboolean load_texenv_source( struct texenv_fragment_program *p,
       /* not a texture src - do nothing */
       break;
    }
- 
-   return GL_TRUE;
 }
 
 
@@ -1380,108 +1127,214 @@ load_texunit_sources( struct texenv_fragment_program *p, GLuint unit )
 /**
  * Generate instructions for loading bump map textures.
  */
-static GLboolean
+static void
 load_texunit_bumpmap( struct texenv_fragment_program *p, GLuint unit )
 {
    const struct state_key *key = p->state;
    GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0;
-   struct ureg texcDst, bumpMapRes;
-   struct ureg constdudvcolor = register_const4f(p, 0.0, 0.0, 0.0, 1.0);
-   struct ureg texcSrc = register_input(p, FRAG_ATTRIB_TEX0 + bumpedUnitNr);
-   struct ureg rotMat0 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_0, unit );
-   struct ureg rotMat1 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_1, unit );
+   ir_rvalue *bump;
+   ir_rvalue *texcoord;
+   ir_variable *rot_mat_0_var, *rot_mat_1_var;
+   ir_dereference_variable *rot_mat_0, *rot_mat_1;
+
+   rot_mat_0_var = p->shader->symbols->get_variable("gl_MESABumpRotMatrix0");
+   rot_mat_1_var = p->shader->symbols->get_variable("gl_MESABumpRotMatrix1");
+   rot_mat_0 = new(p->mem_ctx) ir_dereference_variable(rot_mat_0_var);
+   rot_mat_1 = new(p->mem_ctx) ir_dereference_variable(rot_mat_1_var);
+
+   ir_variable *tc_array = p->shader->symbols->get_variable("gl_TexCoord");
+   assert(tc_array);
+   texcoord = new(p->mem_ctx) ir_dereference_variable(tc_array);
+   ir_rvalue *index = new(p->mem_ctx) ir_constant(bumpedUnitNr);
+   texcoord = new(p->mem_ctx) ir_dereference_array(texcoord, index);
+   tc_array->max_array_access = MAX2(tc_array->max_array_access, unit);
 
    load_texenv_source( p, unit + SRC_TEXTURE0, unit );
 
-   bumpMapRes = get_source(p, key->unit[unit].OptRGB[0].Source, unit);
-   texcDst = get_tex_temp( p );
-   p->texcoord_tex[bumpedUnitNr] = texcDst;
-
    /* Apply rot matrix and add coords to be available in next phase.
-    * dest = (Arg0.xxxx * rotMat0 + Arg1) + (Arg0.yyyy * rotMat1)
+    * dest = Arg1 + (Arg0.xx * rotMat0) + (Arg0.yy * rotMat1)
     * note only 2 coords are affected the rest are left unchanged (mul by 0)
     */
-   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,
-               swizzle1(bumpMapRes, SWIZZLE_X), rotMat0, texcSrc );
-   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,
-               swizzle1(bumpMapRes, SWIZZLE_Y), rotMat1, texcDst );
-
-   /* Move 0,0,0,1 into bumpmap src if someone (crossbar) is foolish
-    * enough to access this later, should optimize away.
-    */
-   emit_arith( p, OPCODE_MOV, bumpMapRes, WRITEMASK_XYZW, 0,
-               constdudvcolor, undef, undef );
-
-   return GL_TRUE;
+   ir_dereference *deref;
+   ir_assignment *assign;
+   ir_rvalue *bump_x, *bump_y;
+
+   texcoord = smear(p, texcoord);
+
+   /* bump_texcoord = texcoord */
+   ir_variable *bumped = new(p->mem_ctx) ir_variable(texcoord->type,
+						     "bump_texcoord",
+						     ir_var_temporary);
+   p->instructions->push_tail(bumped);
+
+   deref = new(p->mem_ctx) ir_dereference_variable(bumped);
+   assign = new(p->mem_ctx) ir_assignment(deref, texcoord);
+   p->instructions->push_tail(assign);
+
+   /* bump_texcoord.xy += arg0.x * rotmat0 + arg0.y * rotmat1 */
+   bump = get_source(p, key->unit[unit].OptRGB[0].Source, unit);
+   bump_x = new(p->mem_ctx) ir_swizzle(bump, 0, 0, 0, 0, 1);
+   bump = bump->clone(p->mem_ctx, NULL);
+   bump_y = new(p->mem_ctx) ir_swizzle(bump, 1, 0, 0, 0, 1);
+
+   bump_x = new(p->mem_ctx) ir_expression(ir_binop_mul, bump_x, rot_mat_0);
+   bump_y = new(p->mem_ctx) ir_expression(ir_binop_mul, bump_y, rot_mat_1);
+
+   ir_expression *expr;
+   expr = new(p->mem_ctx) ir_expression(ir_binop_add, bump_x, bump_y);
+
+   deref = new(p->mem_ctx) ir_dereference_variable(bumped);
+   expr = new(p->mem_ctx) ir_expression(ir_binop_add,
+					new(p->mem_ctx) ir_swizzle(deref,
+								   0, 1, 1, 1,
+								   2),
+					expr);
+
+   deref = new(p->mem_ctx) ir_dereference_variable(bumped);
+   assign = new(p->mem_ctx) ir_assignment(deref, expr, NULL, WRITEMASK_XY);
+   p->instructions->push_tail(assign);
+
+   p->texcoord_tex[bumpedUnitNr] = bumped;
 }
 
 /**
- * Generate a new fragment program which implements the context's
- * current texture env/combine mode.
+ * Applies the fog calculations.
+ *
+ * This is basically like the ARB_fragment_prorgam fog options.  Note
+ * that ffvertex_prog.c produces fogcoord for us when
+ * GL_FOG_COORDINATE_EXT is set to GL_FRAGMENT_DEPTH_EXT.
  */
-static void
-create_new_program(struct gl_context *ctx, struct state_key *key,
-                   struct gl_fragment_program *program)
+static ir_rvalue *
+emit_fog_instructions(struct texenv_fragment_program *p,
+		      ir_rvalue *fragcolor)
 {
-   struct prog_instruction instBuffer[MAX_INSTRUCTIONS];
-   struct texenv_fragment_program p;
-   GLuint unit;
-   struct ureg cf, out;
-   int i;
-
-   memset(&p, 0, sizeof(p));
-   p.state = key;
-   p.program = program;
-
-   /* During code generation, use locally-allocated instruction buffer,
-    * then alloc dynamic storage below.
+   struct state_key *key = p->state;
+   ir_rvalue *f, *temp;
+   ir_variable *params, *oparams;
+   ir_variable *fogcoord;
+   ir_assignment *assign;
+
+   /* Temporary storage for the whole fog result.  Fog calculations
+    * only affect rgb so we're hanging on to the .a value of fragcolor
+    * this way.
     */
-   p.program->Base.Instructions = instBuffer;
-   p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB;
-   p.program->Base.String = NULL;
-   p.program->Base.NumTexIndirections = 1; /* is this right? */
-   p.program->Base.NumTexInstructions = 0;
-   p.program->Base.NumAluInstructions = 0;
-   p.program->Base.NumInstructions = 0;
-   p.program->Base.NumTemporaries = 0;
-   p.program->Base.NumParameters = 0;
-   p.program->Base.NumAttributes = 0;
-   p.program->Base.NumAddressRegs = 0;
-   p.program->Base.Parameters = _mesa_new_parameter_list();
-   p.program->Base.InputsRead = 0x0;
-
-   if (key->num_draw_buffers == 1)
-      p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR;
-   else {
-      for (i = 0; i < key->num_draw_buffers; i++)
-	 p.program->Base.OutputsWritten |= (1 << (FRAG_RESULT_DATA0 + i));
-   }
+   ir_variable *fog_result = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
+							 "fog_result",
+							 ir_var_auto);
+   p->instructions->push_tail(fog_result);
+   temp = new(p->mem_ctx) ir_dereference_variable(fog_result);
+   assign = new(p->mem_ctx) ir_assignment(temp, fragcolor);
+   p->instructions->push_tail(assign);
+
+   temp = new(p->mem_ctx) ir_dereference_variable(fog_result);
+   fragcolor = new(p->mem_ctx) ir_swizzle(temp, 0, 1, 2, 3, 3);
+
+   oparams = p->shader->symbols->get_variable("gl_MESAFogParamsOptimized");
+   fogcoord = p->shader->symbols->get_variable("gl_FogFragCoord");
+   params = p->shader->symbols->get_variable("gl_Fog");
+   f = new(p->mem_ctx) ir_dereference_variable(fogcoord);
+
+   ir_variable *f_var = new(p->mem_ctx) ir_variable(glsl_type::float_type,
+						    "fog_factor", ir_var_auto);
+   p->instructions->push_tail(f_var);
+
+   switch (key->fog_mode) {
+   case FOG_LINEAR:
+      /* f = (end - z) / (end - start)
+       *
+       * gl_MesaFogParamsOptimized gives us (-1 / (end - start)) and
+       * (end / (end - start)) so we can generate a single MAD.
+       */
+      temp = new(p->mem_ctx) ir_dereference_variable(oparams);
+      temp = new(p->mem_ctx) ir_swizzle(temp, 0, 0, 0, 0, 1);
+      f = new(p->mem_ctx) ir_expression(ir_binop_mul, f, temp);
 
-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
-      p.src_texture[unit] = undef;
-      p.texcoord_tex[unit] = undef;
+      temp = new(p->mem_ctx) ir_dereference_variable(oparams);
+      temp = new(p->mem_ctx) ir_swizzle(temp, 1, 0, 0, 0, 1);
+      f = new(p->mem_ctx) ir_expression(ir_binop_add, f, temp);
+      break;
+   case FOG_EXP:
+      /* f = e^(-(density * fogcoord))
+       *
+       * gl_MesaFogParamsOptimized gives us density/ln(2) so we can
+       * use EXP2 which is generally the native instruction without
+       * having to do any further math on the fog density uniform.
+       */
+      temp = new(p->mem_ctx) ir_dereference_variable(oparams);
+      temp = new(p->mem_ctx) ir_swizzle(temp, 2, 0, 0, 0, 1);
+      f = new(p->mem_ctx) ir_expression(ir_binop_mul, f, temp);
+      f = new(p->mem_ctx) ir_expression(ir_unop_neg, f);
+      f = new(p->mem_ctx) ir_expression(ir_unop_exp2, f);
+      break;
+   case FOG_EXP2:
+      /* f = e^(-(density * fogcoord)^2)
+       *
+       * gl_MesaFogParamsOptimized gives us density/sqrt(ln(2)) so we
+       * can do this like FOG_EXP but with a squaring after the
+       * multiply by density.
+       */
+      ir_variable *temp_var = new(p->mem_ctx) ir_variable(glsl_type::float_type,
+							  "fog_temp",
+							  ir_var_auto);
+      p->instructions->push_tail(temp_var);
+
+      temp = new(p->mem_ctx) ir_dereference_variable(oparams);
+      temp = new(p->mem_ctx) ir_swizzle(temp, 3, 0, 0, 0, 1);
+      f = new(p->mem_ctx) ir_expression(ir_binop_mul,
+					f, temp);
+
+      temp = new(p->mem_ctx) ir_dereference_variable(temp_var);
+      ir_assignment *assign = new(p->mem_ctx) ir_assignment(temp, f);
+      p->instructions->push_tail(assign);
+
+      f = new(p->mem_ctx) ir_dereference_variable(temp_var);
+      temp = new(p->mem_ctx) ir_dereference_variable(temp_var);
+      f = new(p->mem_ctx) ir_expression(ir_binop_mul, f, temp);
+      f = new(p->mem_ctx) ir_expression(ir_unop_neg, f);
+      f = new(p->mem_ctx) ir_expression(ir_unop_exp2, f);
+      break;
    }
 
-   p.src_previous = undef;
-   p.half = undef;
-   p.zero = undef;
-   p.one = undef;
+   f = saturate(p, f);
 
-   p.last_tex_stage = 0;
-   release_temps(ctx, &p);
+   temp = new(p->mem_ctx) ir_dereference_variable(f_var);
+   assign = new(p->mem_ctx) ir_assignment(temp, f);
+   p->instructions->push_tail(assign);
+
+   f = new(p->mem_ctx) ir_dereference_variable(f_var);
+   f = new(p->mem_ctx) ir_expression(ir_binop_sub,
+				     new(p->mem_ctx) ir_constant(1.0f),
+				     f);
+   temp = new(p->mem_ctx) ir_dereference_variable(params);
+   temp = new(p->mem_ctx) ir_dereference_record(temp, "color");
+   temp = new(p->mem_ctx) ir_swizzle(temp, 0, 1, 2, 3, 3);
+   temp = new(p->mem_ctx) ir_expression(ir_binop_mul, temp, f);
 
-   if (key->enabled_units && key->num_draw_buffers) {
-      GLboolean needbumpstage = GL_FALSE;
+   f = new(p->mem_ctx) ir_dereference_variable(f_var);
+   f = new(p->mem_ctx) ir_expression(ir_binop_mul, fragcolor, f);
+   f = new(p->mem_ctx) ir_expression(ir_binop_add, temp, f);
 
+   ir_dereference *deref = new(p->mem_ctx) ir_dereference_variable(fog_result);
+   assign = new(p->mem_ctx) ir_assignment(deref, f, NULL, WRITEMASK_XYZ);
+   p->instructions->push_tail(assign);
+
+   return new(p->mem_ctx) ir_dereference_variable(fog_result);
+}
+
+static void
+emit_instructions(struct texenv_fragment_program *p)
+{
+   struct state_key *key = p->state;
+   GLuint unit;
+
+   if (key->enabled_units) {
       /* Zeroth pass - bump map textures first */
-      for (unit = 0; unit < key->nr_enabled_units; unit++)
+      for (unit = 0; unit < key->nr_enabled_units; unit++) {
 	 if (key->unit[unit].enabled &&
              key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {
-	    needbumpstage = GL_TRUE;
-	    load_texunit_bumpmap( &p, unit );
+	    load_texunit_bumpmap(p, unit);
 	 }
-      if (needbumpstage)
-	 p.program->Base.NumTexIndirections++;
+      }
 
       /* First pass - to support texture_env_crossbar, first identify
        * all referenced texture sources and emit texld instructions
@@ -1489,98 +1342,172 @@ create_new_program(struct gl_context *ctx, struct state_key *key,
        */
       for (unit = 0; unit < key->nr_enabled_units; unit++)
 	 if (key->unit[unit].enabled) {
-	    load_texunit_sources( &p, unit );
-	    p.last_tex_stage = unit;
+	    load_texunit_sources(p, unit);
+	    p->last_tex_stage = unit;
 	 }
 
       /* Second pass - emit combine instructions to build final color:
        */
-      for (unit = 0; unit < key->nr_enabled_units; unit++)
+      for (unit = 0; unit < key->nr_enabled_units; unit++) {
 	 if (key->unit[unit].enabled) {
-	    p.src_previous = emit_texenv( &p, unit );
-            reserve_temp(&p, p.src_previous); /* don't re-use this temp reg */
-	    release_temps(ctx, &p);	/* release all temps */
+	    p->src_previous = emit_texenv(p, unit);
 	 }
+      }
    }
 
-   cf = get_source( &p, SRC_PREVIOUS, 0 );
-
-   for (i = 0; i < key->num_draw_buffers; i++) {
-      if (key->num_draw_buffers == 1)
-	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLOR );
-      else {
-	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_DATA0 + i );
+   ir_rvalue *cf = get_source(p, SRC_PREVIOUS, 0);
+   ir_dereference_variable *deref;
+   ir_assignment *assign;
+
+   if (key->separate_specular) {
+      ir_rvalue *tmp0;
+      ir_variable *spec_result = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
+							    "specular_add",
+							    ir_var_temporary);
+
+      p->instructions->push_tail(spec_result);
+
+      deref = new(p->mem_ctx) ir_dereference_variable(spec_result);
+      assign = new(p->mem_ctx) ir_assignment(deref, cf);
+      p->instructions->push_tail(assign);
+
+      deref = new(p->mem_ctx) ir_dereference_variable(spec_result);
+      tmp0 = new(p->mem_ctx) ir_swizzle(deref, 0, 1, 2, 3, 3);
+
+      ir_rvalue *secondary;
+      if (p->state->inputs_available & FRAG_BIT_COL1) {
+	 ir_variable *var =
+	    p->shader->symbols->get_variable("gl_SecondaryColor");
+	 assert(var);
+	 secondary = new(p->mem_ctx) ir_dereference_variable(var);
+      } else {
+	 secondary = get_current_attrib(p, VERT_ATTRIB_COLOR1);
       }
+      secondary = new(p->mem_ctx) ir_swizzle(secondary, 0, 1, 2, 3, 3);
 
-      if (key->separate_specular) {
-	 /* Emit specular add.
-	  */
-	 struct ureg s = register_input(&p, FRAG_ATTRIB_COL1);
-	 emit_arith( &p, OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );
-	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );
-      }
-      else if (memcmp(&cf, &out, sizeof(cf)) != 0) {
-	 /* Will wind up in here if no texture enabled or a couple of
-	  * other scenarios (GL_REPLACE for instance).
-	  */
-	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );
-      }
+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, secondary);
+
+      deref = new(p->mem_ctx) ir_dereference_variable(spec_result);
+      assign = new(p->mem_ctx) ir_assignment(deref, tmp0, NULL, WRITEMASK_XYZ);
+      p->instructions->push_tail(assign);
+
+      cf = new(p->mem_ctx) ir_dereference_variable(spec_result);
    }
-   /* Finish up:
-    */
-   emit_arith( &p, OPCODE_END, undef, WRITEMASK_XYZW, 0, undef, undef, undef);
 
-   /* Allocate final instruction array.  This has to be done before calling
-    * _mesa_append_fog_code because that function frees the Base.Instructions.
-    * At this point, Base.Instructions points to stack data, so it's a really
-    * bad idea to free it.
-    */
-   p.program->Base.Instructions
-      = _mesa_alloc_instructions(p.program->Base.NumInstructions);
-   if (!p.program->Base.Instructions) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY,
-                  "generating tex env program");
-      return;
+   if (key->fog_enabled) {
+      cf = emit_fog_instructions(p, cf);
    }
-   _mesa_copy_instructions(p.program->Base.Instructions, instBuffer,
-                           p.program->Base.NumInstructions);
 
-   /* Append fog code.  This must be done before checking the program against
-    * the limits becuase it will potentially add some instructions.
+   ir_variable *frag_color = p->shader->symbols->get_variable("gl_FragColor");
+   assert(frag_color);
+   deref = new(p->mem_ctx) ir_dereference_variable(frag_color);
+   assign = new(p->mem_ctx) ir_assignment(deref, cf);
+   p->instructions->push_tail(assign);
+}
+
+/**
+ * Generate a new fragment program which implements the context's
+ * current texture env/combine mode.
+ */
+static struct gl_shader_program *
+create_new_program(struct gl_context *ctx, struct state_key *key)
+{
+   struct texenv_fragment_program p;
+   unsigned int unit;
+   _mesa_glsl_parse_state *state;
+
+   memset(&p, 0, sizeof(p));
+   p.mem_ctx = ralloc_context(NULL);
+   p.shader = ctx->Driver.NewShader(ctx, 0, GL_FRAGMENT_SHADER);
+   p.shader->ir = new(p.shader) exec_list;
+   state = new(p.shader) _mesa_glsl_parse_state(ctx, GL_FRAGMENT_SHADER,
+						p.shader);
+   p.shader->symbols = state->symbols;
+   p.top_instructions = p.shader->ir;
+   p.instructions = p.shader->ir;
+   p.state = key;
+   p.shader_program = ctx->Driver.NewShaderProgram(ctx, 0);
+
+   /* Tell the linker to ignore the fact that we're building a
+    * separate shader, in case we're in a GLES2 context that would
+    * normally reject that.  The real problem is that we're building a
+    * fixed function program in a GLES2 context at all, but that's a
+    * big mess to clean up.
     */
-   if (key->fog_enabled) {
-      _mesa_append_fog_code(ctx, p.program, ctx->Fog.Mode, GL_FALSE);
+   p.shader_program->InternalSeparateShader = GL_TRUE;
+
+   state->language_version = 130;
+   _mesa_glsl_initialize_types(state);
+   _mesa_glsl_initialize_variables(p.instructions, state);
+
+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+      p.src_texture[unit] = NULL;
+      p.texcoord_tex[unit] = NULL;
    }
 
-   if (p.program->Base.NumTexIndirections > ctx->Const.FragmentProgram.MaxTexIndirections) 
-      program_error(&p, "Exceeded max nr indirect texture lookups");
+   p.src_previous = NULL;
+
+   p.last_tex_stage = 0;
+
+   ir_function *main_f = new(p.mem_ctx) ir_function("main");
+   p.instructions->push_tail(main_f);
+   state->symbols->add_function(main_f);
 
-   if (p.program->Base.NumTexInstructions > ctx->Const.FragmentProgram.MaxTexInstructions)
-      program_error(&p, "Exceeded max TEX instructions");
+   ir_function_signature *main_sig =
+      new(p.mem_ctx) ir_function_signature(p.shader->symbols->get_type("void"));
+   main_sig->is_defined = true;
+   main_f->add_signature(main_sig);
 
-   if (p.program->Base.NumAluInstructions > ctx->Const.FragmentProgram.MaxAluInstructions)
-      program_error(&p, "Exceeded max ALU instructions");
+   p.instructions = &main_sig->body;
+   if (key->num_draw_buffers)
+      emit_instructions(&p);
 
-   ASSERT(p.program->Base.NumInstructions <= MAX_INSTRUCTIONS);
+   validate_ir_tree(p.shader->ir);
 
-   /* Notify driver the fragment program has (actually) changed.
+   while (do_common_optimization(p.shader->ir, false, 32))
+      ;
+   reparent_ir(p.shader->ir, p.shader->ir);
+
+   p.shader->CompileStatus = true;
+   p.shader->Version = state->language_version;
+   p.shader->num_builtins_to_link = state->num_builtins_to_link;
+   p.shader_program->Shaders =
+      (gl_shader **)malloc(sizeof(*p.shader_program->Shaders));
+   p.shader_program->Shaders[0] = p.shader;
+   p.shader_program->NumShaders = 1;
+
+   _mesa_glsl_link_shader(ctx, p.shader_program);
+
+   /* Set the sampler uniforms, and relink to get them into the linked
+    * program.
     */
-   if (ctx->Driver.ProgramStringNotify) {
-      GLboolean ok = ctx->Driver.ProgramStringNotify(ctx,
-                                                     GL_FRAGMENT_PROGRAM_ARB, 
-                                                     &p.program->Base);
-      /* Driver should be able to handle any texenv programs as long as
-       * the driver correctly reported max number of texture units correctly,
-       * etc.
-       */
-      ASSERT(ok);
-      (void) ok; /* silence unused var warning */
-   }
+   struct gl_program *fp;
+   fp = p.shader_program->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program;
+
+   for (unsigned int i = 0; i < MAX_TEXTURE_UNITS; i++) {
+      char *name = ralloc_asprintf(p.mem_ctx, "sampler_%d", i);
+      int loc = _mesa_get_uniform_location(ctx, p.shader_program, name);
+      if (loc != -1) {
+	 /* Avoid using _mesa_uniform() because it flags state
+	  * updates, so if we're generating this shader_program in a
+	  * state update, we end up recursing.  Instead, just set the
+	  * value, which is picked up at re-link.
+	  */
+	 loc = (loc & 0xffff) + (loc >> 16);
+	 int sampler = fp->Parameters->ParameterValues[loc][0].f;
 
-   if (DISASSEM) {
-      _mesa_print_program(&p.program->Base);
-      printf("\n");
+	 fp->SamplerUnits[sampler] = i;
+      }
    }
+   _mesa_update_shader_textures_used(fp);
+   (void) ctx->Driver.ProgramStringNotify(ctx, fp->Target, fp);
+
+   if (!p.shader_program->LinkStatus)
+      _mesa_problem(ctx, "Failed to link fixed function fragment shader: %s\n",
+		    p.shader_program->InfoLog);
+
+   ralloc_free(p.mem_ctx);
+   return p.shader_program;
 }
 
 extern "C" {
@@ -1589,30 +1516,27 @@ extern "C" {
  * Return a fragment program which implements the current
  * fixed-function texture, fog and color-sum operations.
  */
-struct gl_fragment_program *
+struct gl_shader_program *
 _mesa_get_fixed_func_fragment_program(struct gl_context *ctx)
 {
-   struct gl_fragment_program *prog;
+   struct gl_shader_program *shader_program;
    struct state_key key;
    GLuint keySize;
-	
+
    keySize = make_state_key(ctx, &key);
-      
-   prog = (struct gl_fragment_program *)
+
+   shader_program = (struct gl_shader_program *)
       _mesa_search_program_cache(ctx->FragmentProgram.Cache,
                                  &key, keySize);
 
-   if (!prog) {
-      prog = (struct gl_fragment_program *) 
-         ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
-
-      create_new_program(ctx, &key, prog);
+   if (!shader_program) {
+      shader_program = create_new_program(ctx, &key);
 
-      _mesa_program_cache_insert(ctx, ctx->FragmentProgram.Cache,
-                                 &key, keySize, &prog->Base);
+      _mesa_shader_cache_insert(ctx, ctx->FragmentProgram.Cache,
+				&key, keySize, shader_program);
    }
 
-   return prog;
+   return shader_program;
 }
 
 }
diff --git a/mesalib/src/mesa/main/framebuffer.c b/mesalib/src/mesa/main/framebuffer.c
index 42da17678..8d0763db3 100644
--- a/mesalib/src/mesa/main/framebuffer.c
+++ b/mesalib/src/mesa/main/framebuffer.c
@@ -608,19 +608,12 @@ _mesa_update_framebuffer_visual(struct gl_context *ctx,
  * create and install a depth wrapper/adaptor.
  *
  * \param fb  the framebuffer whose _DepthBuffer field to update
- * \param attIndex  indicates the renderbuffer to possibly wrap
  */
-void
-_mesa_update_depth_buffer(struct gl_context *ctx,
-                          struct gl_framebuffer *fb,
-                          GLuint attIndex)
+static void
+update_depth_buffer(struct gl_context *ctx, struct gl_framebuffer *fb)
 {
-   struct gl_renderbuffer *depthRb;
-
-   /* only one possiblity for now */
-   ASSERT(attIndex == BUFFER_DEPTH);
-
-   depthRb = fb->Attachment[attIndex].Renderbuffer;
+   struct gl_renderbuffer *depthRb =
+      fb->Attachment[BUFFER_DEPTH].Renderbuffer;
 
    if (depthRb && _mesa_is_format_packed_depth_stencil(depthRb->Format)) {
       /* The attached depth buffer is a GL_DEPTH_STENCIL renderbuffer */
@@ -655,19 +648,12 @@ _mesa_update_depth_buffer(struct gl_context *ctx,
  * create and install a stencil wrapper/adaptor.
  *
  * \param fb  the framebuffer whose _StencilBuffer field to update
- * \param attIndex  indicates the renderbuffer to possibly wrap
  */
-void
-_mesa_update_stencil_buffer(struct gl_context *ctx,
-                            struct gl_framebuffer *fb,
-                            GLuint attIndex)
+static void
+update_stencil_buffer(struct gl_context *ctx, struct gl_framebuffer *fb)
 {
-   struct gl_renderbuffer *stencilRb;
-
-   ASSERT(attIndex == BUFFER_DEPTH ||
-          attIndex == BUFFER_STENCIL);
-
-   stencilRb = fb->Attachment[attIndex].Renderbuffer;
+   struct gl_renderbuffer *stencilRb =
+      fb->Attachment[BUFFER_STENCIL].Renderbuffer;
 
    if (stencilRb && _mesa_is_format_packed_depth_stencil(stencilRb->Format)) {
       /* The attached stencil buffer is a GL_DEPTH_STENCIL renderbuffer */
@@ -826,8 +812,8 @@ update_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
     */
    update_color_draw_buffers(ctx, fb);
    update_color_read_buffer(ctx, fb);
-   _mesa_update_depth_buffer(ctx, fb, BUFFER_DEPTH);
-   _mesa_update_stencil_buffer(ctx, fb, BUFFER_STENCIL);
+   update_depth_buffer(ctx, fb);
+   update_stencil_buffer(ctx, fb);
 
    compute_depth_max(fb);
 }
@@ -853,23 +839,27 @@ _mesa_update_framebuffer(struct gl_context *ctx)
 
 
 /**
- * Check if the renderbuffer for a read operation (glReadPixels, glCopyPixels,
- * glCopyTex[Sub]Image, etc) exists.
+ * Check if the renderbuffer for a read/draw operation exists.
  * \param format  a basic image format such as GL_RGB, GL_RGBA, GL_ALPHA,
  *                GL_DEPTH_COMPONENT, etc. or GL_COLOR, GL_DEPTH, GL_STENCIL.
+ * \param reading  if TRUE, we're going to read from the buffer,
+                   if FALSE, we're going to write to the buffer.
  * \return GL_TRUE if buffer exists, GL_FALSE otherwise
  */
-GLboolean
-_mesa_source_buffer_exists(struct gl_context *ctx, GLenum format)
+static GLboolean
+renderbuffer_exists(struct gl_context *ctx,
+                    struct gl_framebuffer *fb,
+                    GLenum format,
+                    GLboolean reading)
 {
-   const struct gl_renderbuffer_attachment *att = ctx->ReadBuffer->Attachment;
+   const struct gl_renderbuffer_attachment *att = fb->Attachment;
 
    /* If we don't know the framebuffer status, update it now */
-   if (ctx->ReadBuffer->_Status == 0) {
-      _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);
+   if (fb->_Status == 0) {
+      _mesa_test_framebuffer_completeness(ctx, fb);
    }
 
-   if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+   if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
       return GL_FALSE;
    }
 
@@ -898,42 +888,44 @@ _mesa_source_buffer_exists(struct gl_context *ctx, GLenum format)
    case GL_BGRA_INTEGER_EXT:
    case GL_LUMINANCE_INTEGER_EXT:
    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-      if (ctx->ReadBuffer->_ColorReadBuffer == NULL) {
-         return GL_FALSE;
+      if (reading) {
+         /* about to read from a color buffer */
+         const struct gl_renderbuffer *readBuf = fb->_ColorReadBuffer;
+         if (!readBuf) {
+            return GL_FALSE;
+         }
+         ASSERT(_mesa_get_format_bits(readBuf->Format, GL_RED_BITS) > 0 ||
+                _mesa_get_format_bits(readBuf->Format, GL_ALPHA_BITS) > 0 ||
+                _mesa_get_format_bits(readBuf->Format, GL_TEXTURE_LUMINANCE_SIZE) > 0 ||
+                _mesa_get_format_bits(readBuf->Format, GL_TEXTURE_INTENSITY_SIZE) > 0 ||
+                _mesa_get_format_bits(readBuf->Format, GL_INDEX_BITS) > 0);
+      }
+      else {
+         /* about to draw to zero or more color buffers (none is OK) */
+         return GL_TRUE;
       }
-      ASSERT(_mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_RED_BITS) > 0 ||
-             _mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_ALPHA_BITS) > 0 ||
-             _mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_TEXTURE_LUMINANCE_SIZE) > 0 ||
-             _mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_TEXTURE_INTENSITY_SIZE) > 0 ||
-             _mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_INDEX_BITS) > 0);
       break;
    case GL_DEPTH:
    case GL_DEPTH_COMPONENT:
-      if (!att[BUFFER_DEPTH].Renderbuffer) {
+      if (att[BUFFER_DEPTH].Type == GL_NONE) {
          return GL_FALSE;
       }
-      /*ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);*/
       break;
    case GL_STENCIL:
    case GL_STENCIL_INDEX:
-      if (!att[BUFFER_STENCIL].Renderbuffer) {
+      if (att[BUFFER_STENCIL].Type == GL_NONE) {
          return GL_FALSE;
       }
-      /*ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);*/
       break;
    case GL_DEPTH_STENCIL_EXT:
-      if (!att[BUFFER_DEPTH].Renderbuffer ||
-          !att[BUFFER_STENCIL].Renderbuffer) {
+      if (att[BUFFER_DEPTH].Type == GL_NONE ||
+          att[BUFFER_STENCIL].Type == GL_NONE) {
          return GL_FALSE;
       }
-      /*
-      ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);
-      ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);
-      */
       break;
    default:
       _mesa_problem(ctx,
-                    "Unexpected format 0x%x in _mesa_source_buffer_exists",
+                    "Unexpected format 0x%x in renderbuffer_exists",
                     format);
       return GL_FALSE;
    }
@@ -944,83 +936,27 @@ _mesa_source_buffer_exists(struct gl_context *ctx, GLenum format)
 
 
 /**
+ * Check if the renderbuffer for a read operation (glReadPixels, glCopyPixels,
+ * glCopyTex[Sub]Image, etc) exists.
+ * \param format  a basic image format such as GL_RGB, GL_RGBA, GL_ALPHA,
+ *                GL_DEPTH_COMPONENT, etc. or GL_COLOR, GL_DEPTH, GL_STENCIL.
+ * \return GL_TRUE if buffer exists, GL_FALSE otherwise
+ */
+GLboolean
+_mesa_source_buffer_exists(struct gl_context *ctx, GLenum format)
+{
+   return renderbuffer_exists(ctx, ctx->ReadBuffer, format, GL_TRUE);
+}
+
+
+/**
  * As above, but for drawing operations.
  * XXX could do some code merging w/ above function.
  */
 GLboolean
 _mesa_dest_buffer_exists(struct gl_context *ctx, GLenum format)
 {
-   const struct gl_renderbuffer_attachment *att = ctx->DrawBuffer->Attachment;
-
-   /* If we don't know the framebuffer status, update it now */
-   if (ctx->DrawBuffer->_Status == 0) {
-      _mesa_test_framebuffer_completeness(ctx, ctx->DrawBuffer);
-   }
-
-   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      return GL_FALSE;
-   }
-
-   switch (format) {
-   case GL_COLOR:
-   case GL_RED:
-   case GL_GREEN:
-   case GL_BLUE:
-   case GL_ALPHA:
-   case GL_LUMINANCE:
-   case GL_LUMINANCE_ALPHA:
-   case GL_INTENSITY:
-   case GL_RGB:
-   case GL_BGR:
-   case GL_RGBA:
-   case GL_BGRA:
-   case GL_ABGR_EXT:
-   case GL_RED_INTEGER_EXT:
-   case GL_GREEN_INTEGER_EXT:
-   case GL_BLUE_INTEGER_EXT:
-   case GL_ALPHA_INTEGER_EXT:
-   case GL_RGB_INTEGER_EXT:
-   case GL_RGBA_INTEGER_EXT:
-   case GL_BGR_INTEGER_EXT:
-   case GL_BGRA_INTEGER_EXT:
-   case GL_LUMINANCE_INTEGER_EXT:
-   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-      /* Nothing special since GL_DRAW_BUFFER could be GL_NONE. */
-      /* Could assert that colorbuffer has RedBits > 0 */
-      break;
-   case GL_DEPTH:
-   case GL_DEPTH_COMPONENT:
-      if (!att[BUFFER_DEPTH].Renderbuffer) {
-         return GL_FALSE;
-      }
-      /*ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);*/
-      break;
-   case GL_STENCIL:
-   case GL_STENCIL_INDEX:
-      if (!att[BUFFER_STENCIL].Renderbuffer) {
-         return GL_FALSE;
-      }
-      /*ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);*/
-      break;
-   case GL_DEPTH_STENCIL_EXT:
-      if (!att[BUFFER_DEPTH].Renderbuffer ||
-          !att[BUFFER_STENCIL].Renderbuffer) {
-         return GL_FALSE;
-      }
-      /*
-      ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);
-      ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);
-      */
-      break;
-   default:
-      _mesa_problem(ctx,
-                    "Unexpected format 0x%x in _mesa_dest_buffer_exists",
-                    format);
-      return GL_FALSE;
-   }
-
-   /* OK */
-   return GL_TRUE;
+   return renderbuffer_exists(ctx, ctx->DrawBuffer, format, GL_FALSE);
 }
 
 
diff --git a/mesalib/src/mesa/main/framebuffer.h b/mesalib/src/mesa/main/framebuffer.h
index 7aef3e02b..ad53d8cbe 100644
--- a/mesalib/src/mesa/main/framebuffer.h
+++ b/mesalib/src/mesa/main/framebuffer.h
@@ -82,14 +82,6 @@ _mesa_update_framebuffer_visual(struct gl_context *ctx,
 				struct gl_framebuffer *fb);
 
 extern void
-_mesa_update_depth_buffer(struct gl_context *ctx, struct gl_framebuffer *fb,
-                            GLuint attIndex);
-
-extern void
-_mesa_update_stencil_buffer(struct gl_context *ctx, struct gl_framebuffer *fb,
-                            GLuint attIndex);
-
-extern void
 _mesa_update_framebuffer(struct gl_context *ctx);
 
 extern GLboolean
diff --git a/mesalib/src/mesa/main/get.c b/mesalib/src/mesa/main/get.c
index 160a4f218..3c388e56e 100644
--- a/mesalib/src/mesa/main/get.c
+++ b/mesalib/src/mesa/main/get.c
@@ -138,6 +138,7 @@ enum value_extra {
    EXTRA_VALID_TEXTURE_UNIT,
    EXTRA_VALID_CLIP_DISTANCE,
    EXTRA_FLUSH_CURRENT,
+   EXTRA_GLSL_130,
 };
 
 #define NO_EXTRA NULL
@@ -277,8 +278,8 @@ static const int extra_EXT_texture_integer[] = {
    EXTRA_END
 };
 
-static const int extra_EXT_gpu_shader4[] = {
-   EXT(EXT_gpu_shader4),
+static const int extra_GLSL_130[] = {
+   EXTRA_GLSL_130,
    EXTRA_END
 };
 
@@ -1234,13 +1235,13 @@ static const struct value_desc values[] = {
    /* GL_ARB_color_buffer_float */
    { GL_RGBA_FLOAT_MODE_ARB, BUFFER_FIELD(Visual.floatMode, TYPE_BOOLEAN), 0 },
 
-   /* GL_EXT_gpu_shader4 / GL 3.0 */
+   /* GL_EXT_gpu_shader4 / GLSL 1.30 */
    { GL_MIN_PROGRAM_TEXEL_OFFSET,
      CONTEXT_INT(Const.MinProgramTexelOffset),
-     extra_EXT_gpu_shader4 },
+     extra_GLSL_130 },
    { GL_MAX_PROGRAM_TEXEL_OFFSET,
      CONTEXT_INT(Const.MaxProgramTexelOffset),
-     extra_EXT_gpu_shader4 },
+     extra_GLSL_130 },
 
    /* GL_ARB_texture_buffer_object */
    { GL_MAX_TEXTURE_BUFFER_SIZE_ARB, CONTEXT_INT(Const.MaxTextureBufferSize),
@@ -1817,6 +1818,12 @@ check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d
 	    return GL_FALSE;
 	 }
 	 break;
+      case EXTRA_GLSL_130:
+	 if (ctx->Const.GLSLVersion >= 130) {
+	    total++;
+	    enabled++;
+	 }
+	 break;
       case EXTRA_END:
 	 break;
       default: /* *e is a offset into the extension struct */
diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h
index 749324d76..17c645a7e 100644
--- a/mesalib/src/mesa/main/mtypes.h
+++ b/mesalib/src/mesa/main/mtypes.h
@@ -1311,9 +1311,6 @@ struct gl_sampler_object
 
    /* deprecated sampler state */
    GLenum DepthMode;		/**< GL_ARB_depth_texture */
-
-   /** Is the texture object complete with respect to this sampler? */
-   GLboolean _CompleteTexture;
 };
 
 
@@ -2138,6 +2135,17 @@ struct gl_shader_program
    GLint RefCount;  /**< Reference count */
    GLboolean DeletePending;
 
+   /**
+    * Flags that the linker should not reject the program if it lacks
+    * a vertex or fragment shader.  GLES2 doesn't allow separate
+    * shader objects, and would reject them.  However, we internally
+    * build separate shader objects for fixed function programs, which
+    * we use for drivers/common/meta.c and for handling
+    * _mesa_update_state with no program bound (for example in
+    * glClear()).
+    */
+   GLboolean InternalSeparateShader;
+
    GLuint NumShaders;          /**< number of attached shaders */
    struct gl_shader **Shaders; /**< List of attached the shaders */
 
diff --git a/mesalib/src/mesa/main/pbo.c b/mesalib/src/mesa/main/pbo.c
index 4e7e6f925..41ff2ff44 100644
--- a/mesalib/src/mesa/main/pbo.c
+++ b/mesalib/src/mesa/main/pbo.c
@@ -82,6 +82,19 @@ _mesa_validate_pbo_access(GLuint dimensions,
    } else {
       offset = ptr;
       sizeAddr = ((const GLubyte *) 0) + pack->BufferObj->Size;
+      /* The ARB_pixel_buffer_object spec says:
+       *    "INVALID_OPERATION is generated by ColorTable, ColorSubTable,
+       *    ConvolutionFilter2D, ConvolutionFilter1D, SeparableFilter2D,
+       *    TexImage1D, TexImage2D, TexImage3D, TexSubImage1D,
+       *    TexSubImage2D, TexSubImage3D, and DrawPixels if the current
+       *    PIXEL_UNPACK_BUFFER_BINDING_ARB value is non-zero and the data
+       *    parameter is not evenly divisible into the number of basic machine
+       *    units needed to store in memory a datum indicated by the type
+       *    parameter."
+       */
+      if (type != GL_BITMAP &&
+          ((GLintptr)offset % _mesa_sizeof_packed_type(type)))
+         return GL_FALSE;
    }
 
    if (sizeAddr == 0)
diff --git a/mesalib/src/mesa/main/shaderapi.c b/mesalib/src/mesa/main/shaderapi.c
index c3aabe43f..6868dfab0 100644
--- a/mesalib/src/mesa/main/shaderapi.c
+++ b/mesalib/src/mesa/main/shaderapi.c
@@ -390,10 +390,12 @@ delete_shader_program(struct gl_context *ctx, GLuint name)
    if (!shProg)
       return;
 
-   shProg->DeletePending = GL_TRUE;
+   if (!shProg->DeletePending) {
+      shProg->DeletePending = GL_TRUE;
 
-   /* effectively, decr shProg's refcount */
-   _mesa_reference_shader_program(ctx, &shProg, NULL);
+      /* effectively, decr shProg's refcount */
+      _mesa_reference_shader_program(ctx, &shProg, NULL);
+   }
 }
 
 
diff --git a/mesalib/src/mesa/main/state.c b/mesalib/src/mesa/main/state.c
index bbe90a32e..98ca733c0 100644
--- a/mesalib/src/mesa/main/state.c
+++ b/mesalib/src/mesa/main/state.c
@@ -260,10 +260,11 @@ update_program(struct gl_context *ctx)
    }
    else if (ctx->FragmentProgram._MaintainTexEnvProgram) {
       /* Use fragment program generated from fixed-function state */
+      struct gl_shader_program *f = _mesa_get_fixed_func_fragment_program(ctx);
+
       _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
-                               _mesa_get_fixed_func_fragment_program(ctx));
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram,
-                               ctx->FragmentProgram._Current);
+			       (struct gl_fragment_program *)
+                               f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program);
    }
    else {
       /* No fragment program */
diff --git a/mesalib/src/mesa/main/texenvprogram.h b/mesalib/src/mesa/main/texenvprogram.h
index 0895ebacb..3d9cb8546 100644
--- a/mesalib/src/mesa/main/texenvprogram.h
+++ b/mesalib/src/mesa/main/texenvprogram.h
@@ -1,35 +1,35 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.1

- *

- * Copyright (C) 1999-2007  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.

- */

-

-

-#ifndef TEXENVPROGRAM_H

-#define TEXENVPROGRAM_H

-

-

-struct gl_context;

-

-extern struct gl_fragment_program *

-_mesa_get_fixed_func_fragment_program(struct gl_context *ctx);

-

-#endif

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.1
+ *
+ * Copyright (C) 1999-2007  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.
+ */
+
+
+#ifndef TEXENVPROGRAM_H
+#define TEXENVPROGRAM_H
+
+
+struct gl_context;
+
+extern struct gl_shader_program *
+_mesa_get_fixed_func_fragment_program(struct gl_context *ctx);
+
+#endif
diff --git a/mesalib/src/mesa/main/texgetimage.c b/mesalib/src/mesa/main/texgetimage.c
index f9118860b..06e032396 100644
--- a/mesalib/src/mesa/main/texgetimage.c
+++ b/mesalib/src/mesa/main/texgetimage.c
@@ -884,7 +884,7 @@ _mesa_GetnCompressedTexImageARB(GLenum target, GLint level, GLsizei bufSize,
       return;
    }
 
-   if (_mesa_is_bufferobj(ctx->Pack.BufferObj) && !img) {
+   if (!_mesa_is_bufferobj(ctx->Pack.BufferObj) && !img) {
       /* not an error, do nothing */
       return;
    }
diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c
index 8efe715fe..2d06f84bf 100644
--- a/mesalib/src/mesa/main/teximage.c
+++ b/mesalib/src/mesa/main/teximage.c
@@ -1893,7 +1893,7 @@ copytexture_error_check( struct gl_context *ctx, GLuint dimensions,
    const GLenum proxyTarget = get_proxy_target(target);
    const GLenum type = GL_FLOAT;
    GLboolean sizeOK;
-   GLint format;
+   GLint baseFormat;
 
    /* check target */
    if (!legal_texsubimage_target(ctx, dimensions, target)) {
@@ -1928,14 +1928,14 @@ copytexture_error_check( struct gl_context *ctx, GLuint dimensions,
       return GL_TRUE;
    }
 
-   format = _mesa_base_tex_format(ctx, internalFormat);
-   if (format < 0) {
+   baseFormat = _mesa_base_tex_format(ctx, internalFormat);
+   if (baseFormat < 0) {
       _mesa_error(ctx, GL_INVALID_VALUE,
                   "glCopyTexImage%dD(internalFormat)", dimensions);
       return GL_TRUE;
    }
 
-   if (!_mesa_source_buffer_exists(ctx, format)) {
+   if (!_mesa_source_buffer_exists(ctx, baseFormat)) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glCopyTexImage%dD(missing readbuffer)", dimensions);
       return GL_TRUE;
@@ -1946,7 +1946,7 @@ copytexture_error_check( struct gl_context *ctx, GLuint dimensions,
       ? (width == height) : 1;
 
    sizeOK = sizeOK && ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,
-                                                    internalFormat, format,
+                                                    internalFormat, baseFormat,
                                                     type, width, height,
                                                     1, border);
 
@@ -1975,22 +1975,6 @@ copytexture_error_check( struct gl_context *ctx, GLuint dimensions,
          return GL_TRUE;
       }
    }
-   else if (_mesa_is_depth_format(internalFormat)) {
-      /* make sure we have depth/stencil buffers */
-      if (!ctx->ReadBuffer->_DepthBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexImage%dD(no depth)", dimensions);
-         return GL_TRUE;
-      }
-   }
-   else if (_mesa_is_depthstencil_format(internalFormat)) {
-      /* make sure we have depth/stencil buffers */
-      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexImage%dD(no depth/stencil buffer)", dimensions);
-         return GL_TRUE;
-      }
-   }
 
    /* if we get here, the parameters are OK */
    return GL_FALSE;
@@ -2149,23 +2133,6 @@ copytexsubimage_error_check2( struct gl_context *ctx, GLuint dimensions,
       return GL_TRUE;
    }
 
-   if (teximage->_BaseFormat == GL_DEPTH_COMPONENT) {
-      if (!ctx->ReadBuffer->_DepthBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexSubImage%dD(no depth buffer)",
-                     dimensions);
-         return GL_TRUE;
-      }
-   }
-   else if (teximage->_BaseFormat == GL_DEPTH_STENCIL_EXT) {
-      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexSubImage%dD(no depth/stencil buffer)",
-                     dimensions);
-         return GL_TRUE;
-      }
-   }
-
    /* If copying into an integer texture, the source buffer must also be
     * integer-valued.
     */
diff --git a/mesalib/src/mesa/main/uniform_query.cpp b/mesalib/src/mesa/main/uniform_query.cpp
new file mode 100644
index 000000000..ba7d7591f
--- /dev/null
+++ b/mesalib/src/mesa/main/uniform_query.cpp
@@ -0,0 +1,80 @@
+/*
+ * Mesa 3-D graphics library
+ *
+ * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.
+ * Copyright © 2010, 2011 Intel Corporation
+ *
+ * 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.
+ */
+#include "main/core.h"
+#include "ir.h"
+#include "../glsl/program.h"
+
+extern "C" {
+#include "main/shaderapi.h"
+#include "main/shaderobj.h"
+#include "uniforms.h"
+}
+
+extern "C" void GLAPIENTRY
+_mesa_GetActiveUniformARB(GLhandleARB program, GLuint index,
+                          GLsizei maxLength, GLsizei *length, GLint *size,
+                          GLenum *type, GLcharARB *nameOut)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_shader_program *shProg =
+      _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");
+   const struct gl_program_parameter *param;
+
+   if (!shProg)
+      return;
+
+   if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
+      return;
+   }
+
+   param = get_uniform_parameter(shProg, index);
+   if (!param)
+      return;
+
+   const struct gl_uniform *const uni = &shProg->Uniforms->Uniforms[index];
+
+   if (nameOut) {
+      _mesa_copy_string(nameOut, maxLength, length, param->Name);
+   }
+
+   if (size) {
+      GLint typeSize = _mesa_sizeof_glsl_type(uni->Type->gl_type);
+      if ((GLint) param->Size > typeSize) {
+         /* This is an array.
+          * Array elements are placed on vector[4] boundaries so they're
+          * a multiple of four floats.  We round typeSize up to next multiple
+          * of four to get the right size below.
+          */
+         typeSize = (typeSize + 3) & ~3;
+      }
+      /* Note that the returned size is in units of the <type>, not bytes */
+      *size = param->Size / typeSize;
+   }
+
+   if (type) {
+      *type = uni->Type->gl_type;
+   }
+}
diff --git a/mesalib/src/mesa/main/uniforms.c b/mesalib/src/mesa/main/uniforms.c
index 7252c099a..ccaedf9f1 100644
--- a/mesalib/src/mesa/main/uniforms.c
+++ b/mesalib/src/mesa/main/uniforms.c
@@ -211,7 +211,7 @@ find_uniform_parameter_pos(struct gl_shader_program *shProg, GLint index,
  * \param index  the uniform index in [0, NumUniforms-1]
  * \return gl_program_parameter point or NULL if index is invalid
  */
-static const struct gl_program_parameter *
+const struct gl_program_parameter *
 get_uniform_parameter(struct gl_shader_program *shProg, GLint index)
 {
    struct gl_program *prog;
@@ -224,54 +224,6 @@ get_uniform_parameter(struct gl_shader_program *shProg, GLint index)
 }
 
 
-/**
- * Called by glGetActiveUniform().
- */
-static void
-_mesa_get_active_uniform(struct gl_context *ctx, GLuint program, GLuint index,
-                         GLsizei maxLength, GLsizei *length, GLint *size,
-                         GLenum *type, GLchar *nameOut)
-{
-   struct gl_shader_program *shProg =
-      _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");
-   const struct gl_program_parameter *param;
-
-   if (!shProg)
-      return;
-
-   if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
-      return;
-   }
-
-   param = get_uniform_parameter(shProg, index);
-   if (!param)
-      return;
-
-   if (nameOut) {
-      _mesa_copy_string(nameOut, maxLength, length, param->Name);
-   }
-
-   if (size) {
-      GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
-      if ((GLint) param->Size > typeSize) {
-         /* This is an array.
-          * Array elements are placed on vector[4] boundaries so they're
-          * a multiple of four floats.  We round typeSize up to next multiple
-          * of four to get the right size below.
-          */
-         typeSize = (typeSize + 3) & ~3;
-      }
-      /* Note that the returned size is in units of the <type>, not bytes */
-      *size = param->Size / typeSize;
-   }
-
-   if (type) {
-      *type = param->DataType;
-   }
-}
-
-
 static unsigned
 get_vector_elements(GLenum type)
 {
@@ -1479,17 +1431,6 @@ _mesa_GetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name)
 }
 
 
-void GLAPIENTRY
-_mesa_GetActiveUniformARB(GLhandleARB program, GLuint index,
-                          GLsizei maxLength, GLsizei * length, GLint * size,
-                          GLenum * type, GLcharARB * name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_get_active_uniform(ctx, program, index, maxLength, length, size,
-                            type, name);
-}
-
-
 /**
  * Plug in shader uniform-related functions into API dispatch table.
  */
diff --git a/mesalib/src/mesa/main/uniforms.h b/mesalib/src/mesa/main/uniforms.h
index b024cb30b..77f55d47d 100644
--- a/mesalib/src/mesa/main/uniforms.h
+++ b/mesalib/src/mesa/main/uniforms.h
@@ -191,6 +191,9 @@ _mesa_update_shader_textures_used(struct gl_program *prog);
 extern void
 _mesa_init_shader_uniform_dispatch(struct _glapi_table *exec);
 
+extern const struct gl_program_parameter *
+get_uniform_parameter(struct gl_shader_program *shProg, GLint index);
+
 struct gl_builtin_uniform_element {
    const char *field;
    int tokens[STATE_LENGTH];
diff --git a/mesalib/src/mesa/program/hash_table.h b/mesalib/src/mesa/program/hash_table.h
index bfe221b24..941d28a4c 100644
--- a/mesalib/src/mesa/program/hash_table.h
+++ b/mesalib/src/mesa/program/hash_table.h
@@ -32,6 +32,7 @@
 #define HASH_TABLE_H
 
 #include <string.h>
+#include <stdlib.h>
 #include <stdint.h>
 #include <limits.h>
 #include <assert.h>
@@ -100,6 +101,10 @@ extern void *hash_table_find(struct hash_table *ht, const void *key);
  * calls to \c hash_table_find and \c hash_table_remove will return or remove,
  * repsectively, the most recently added instance of \c key.
  *
+ * \warning
+ * The value passed by \c key is kept in the hash table and is used by later
+ * calls to \c hash_table_find.
+ *
  * \sa hash_table_replace
  */
 extern void hash_table_insert(struct hash_table *ht, void *data,
@@ -204,6 +209,7 @@ public:
 
    ~string_to_uint_map()
    {
+      hash_table_call_foreach(this->ht, delete_key, NULL);
       hash_table_dtor(this->ht);
    }
 
@@ -243,10 +249,20 @@ public:
        * because UINT_MAX+1 = 0.
        */
       assert(value != UINT_MAX);
-      hash_table_replace(ht, (void *) (intptr_t) (value + 1), key);
+      hash_table_replace(this->ht,
+			 (void *) (intptr_t) (value + 1),
+			 strdup(key));
    }
 
 private:
+   static void delete_key(const void *key, void *data, void *closure)
+   {
+      (void) data;
+      (void) closure;
+
+      free((char *)key);
+   }
+
    struct hash_table *ht;
 };
 
diff --git a/mesalib/src/mesa/program/ir_to_mesa.cpp b/mesalib/src/mesa/program/ir_to_mesa.cpp
index 5be44bc51..fecab50f7 100644
--- a/mesalib/src/mesa/program/ir_to_mesa.cpp
+++ b/mesalib/src/mesa/program/ir_to_mesa.cpp
@@ -41,12 +41,13 @@
 #include "ir_optimization.h"
 #include "ast.h"
 
-extern "C" {
 #include "main/mtypes.h"
-#include "main/shaderapi.h"
 #include "main/shaderobj.h"
-#include "main/uniforms.h"
 #include "program/hash_table.h"
+
+extern "C" {
+#include "main/shaderapi.h"
+#include "main/uniforms.h"
 #include "program/prog_instruction.h"
 #include "program/prog_optimize.h"
 #include "program/prog_print.h"
@@ -2587,121 +2588,83 @@ check_resources(const struct gl_context *ctx,
 }
 
 
-
-struct uniform_sort {
-   struct gl_uniform *u;
-   int pos;
-};
-
-/* The shader_program->Uniforms list is almost sorted in increasing
- * uniform->{Frag,Vert}Pos locations, but not quite when there are
- * uniforms shared between targets.  We need to add parameters in
- * increasing order for the targets.
- */
 static int
-sort_uniforms(const void *a, const void *b)
+add_uniform_to_shader(ir_variable *var,
+		      struct gl_program_parameter_list *params,
+		      unsigned int &next_sampler)
 {
-   struct uniform_sort *u1 = (struct uniform_sort *)a;
-   struct uniform_sort *u2 = (struct uniform_sort *)b;
-
-   return u1->pos - u2->pos;
-}
+   const glsl_type *type = var->type;
+   unsigned int size;
 
-/* Add the uniforms to the parameters.  The linker chose locations
- * in our parameters lists (which weren't created yet), which the
- * uniforms code will use to poke values into our parameters list
- * when uniforms are updated.
- */
-static void
-add_uniforms_to_parameters_list(struct gl_shader_program *shader_program,
-				struct gl_shader *shader,
-				struct gl_program *prog)
-{
-   unsigned int i;
-   unsigned int next_sampler = 0, num_uniforms = 0;
-   struct uniform_sort *sorted_uniforms;
+   if (type->is_vector() || type->is_scalar()) {
+      size = type->vector_elements;
+   } else {
+      size = type_size(type) * 4;
+   }
 
-   sorted_uniforms = ralloc_array(NULL, struct uniform_sort,
-				  shader_program->Uniforms->NumUniforms);
+   gl_register_file file;
+   if (type->is_sampler() ||
+       (type->is_array() && type->fields.array->is_sampler())) {
+      file = PROGRAM_SAMPLER;
+   } else {
+      file = PROGRAM_UNIFORM;
+   }
 
-   for (i = 0; i < shader_program->Uniforms->NumUniforms; i++) {
-      struct gl_uniform *uniform = shader_program->Uniforms->Uniforms + i;
-      int parameter_index = -1;
+   int index = _mesa_lookup_parameter_index(params, -1, var->name);
+   if (index < 0) {
+      index = _mesa_add_parameter(params, file,
+				  var->name, size, type->gl_type,
+				  NULL, NULL, 0x0);
 
-      switch (shader->Type) {
-      case GL_VERTEX_SHADER:
-	 parameter_index = uniform->VertPos;
-	 break;
-      case GL_FRAGMENT_SHADER:
-	 parameter_index = uniform->FragPos;
-	 break;
-      case GL_GEOMETRY_SHADER:
-	 parameter_index = uniform->GeomPos;
-	 break;
-      }
-
-      /* Only add uniforms used in our target. */
-      if (parameter_index != -1) {
-	 sorted_uniforms[num_uniforms].pos = parameter_index;
-	 sorted_uniforms[num_uniforms].u = uniform;
-	 num_uniforms++;
+      /* Sampler uniform values are stored in prog->SamplerUnits,
+       * and the entry in that array is selected by this index we
+       * store in ParameterValues[].
+       */
+      if (file == PROGRAM_SAMPLER) {
+	 for (unsigned int j = 0; j < size / 4; j++)
+	    params->ParameterValues[index + j][0].f = next_sampler++;
       }
    }
 
-   qsort(sorted_uniforms, num_uniforms, sizeof(struct uniform_sort),
-	 sort_uniforms);
-
-   for (i = 0; i < num_uniforms; i++) {
-      struct gl_uniform *uniform = sorted_uniforms[i].u;
-      int parameter_index = sorted_uniforms[i].pos;
-      const glsl_type *type = uniform->Type;
-      unsigned int size;
-
-      if (type->is_vector() ||
-	  type->is_scalar()) {
-	 size = type->vector_elements;
-      } else {
-	 size = type_size(type) * 4;
-      }
+   return index;
+}
 
-      gl_register_file file;
-      if (type->is_sampler() ||
-	  (type->is_array() && type->fields.array->is_sampler())) {
-	 file = PROGRAM_SAMPLER;
-      } else {
-	 file = PROGRAM_UNIFORM;
-      }
+/**
+ * Generate the program parameters list for the user uniforms in a shader
+ *
+ * \param shader_program Linked shader program.  This is only used to
+ *                       emit possible link errors to the info log.
+ * \param sh             Shader whose uniforms are to be processed.
+ * \param params         Parameter list to be filled in.
+ */
+void
+_mesa_generate_parameters_list_for_uniforms(struct gl_shader_program
+					    *shader_program,
+					    struct gl_shader *sh,
+					    struct gl_program_parameter_list
+					    *params)
+{
+   unsigned int next_sampler = 0;
 
-      GLint index = _mesa_lookup_parameter_index(prog->Parameters, -1,
-						 uniform->Name);
+   foreach_list(node, sh->ir) {
+      ir_variable *var = ((ir_instruction *) node)->as_variable();
 
-      if (index < 0) {
-	 index = _mesa_add_parameter(prog->Parameters, file,
-				     uniform->Name, size, type->gl_type,
-				     NULL, NULL, 0x0);
+      if ((var == NULL) || (var->mode != ir_var_uniform)
+	  || (strncmp(var->name, "gl_", 3) == 0))
+	 continue;
 
-	 /* Sampler uniform values are stored in prog->SamplerUnits,
-	  * and the entry in that array is selected by this index we
-	  * store in ParameterValues[].
-	  */
-	 if (file == PROGRAM_SAMPLER) {
-	    for (unsigned int j = 0; j < size / 4; j++)
-	       prog->Parameters->ParameterValues[index + j][0].f = next_sampler++;
-	 }
+      int loc = add_uniform_to_shader(var, params, next_sampler);
 
-	 /* The location chosen in the Parameters list here (returned
-	  * from _mesa_add_uniform) has to match what the linker chose.
-	  */
-	 if (index != parameter_index) {
-	    linker_error(shader_program,
-			 "Allocation of uniform `%s' to target failed "
-			 "(%d vs %d)\n",
-			 uniform->Name, index, parameter_index);
-	 }
+      /* The location chosen in the Parameters list here (returned from
+       * _mesa_add_parameter) has to match what the linker chose.
+       */
+      if (var->location != loc) {
+	 linker_error(shader_program,
+		      "Allocation of uniform `%s' to target failed "
+		      "(%d vs %d)\n",
+		      var->name, loc, var->location);
       }
    }
-
-   ralloc_free(sorted_uniforms);
 }
 
 static void
@@ -3045,7 +3008,8 @@ get_mesa_program(struct gl_context *ctx,
    v.shader_program = shader_program;
    v.options = options;
 
-   add_uniforms_to_parameters_list(shader_program, shader, prog);
+   _mesa_generate_parameters_list_for_uniforms(shader_program, shader,
+					       prog->Parameters);
 
    /* Emit Mesa IR for main(). */
    visit_exec_list(shader->ir, &v);
diff --git a/mesalib/src/mesa/program/ir_to_mesa.h b/mesalib/src/mesa/program/ir_to_mesa.h
index e708bb769..d046b0fcf 100644
--- a/mesalib/src/mesa/program/ir_to_mesa.h
+++ b/mesalib/src/mesa/program/ir_to_mesa.h
@@ -1,41 +1,48 @@
-/*

- * Copyright © 2010 Intel Corporation

- *

- * 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.

- */

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-#include "main/glheader.h"

-

-struct gl_context;

-struct gl_shader;

-struct gl_shader_program;

-

-void _mesa_glsl_compile_shader(struct gl_context *ctx, struct gl_shader *sh);

-void _mesa_glsl_link_shader(struct gl_context *ctx, struct gl_shader_program *prog);

-GLboolean _mesa_ir_compile_shader(struct gl_context *ctx, struct gl_shader *shader);

-GLboolean _mesa_ir_link_shader(struct gl_context *ctx, struct gl_shader_program *prog);

-

-#ifdef __cplusplus

-}

-#endif

+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * 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.
+ */
+
+#include "main/glheader.h"
+
+struct gl_context;
+struct gl_shader;
+struct gl_shader_program;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void _mesa_glsl_compile_shader(struct gl_context *ctx, struct gl_shader *sh);
+void _mesa_glsl_link_shader(struct gl_context *ctx, struct gl_shader_program *prog);
+GLboolean _mesa_ir_compile_shader(struct gl_context *ctx, struct gl_shader *shader);
+GLboolean _mesa_ir_link_shader(struct gl_context *ctx, struct gl_shader_program *prog);
+
+#ifdef __cplusplus
+}
+
+void
+_mesa_generate_parameters_list_for_uniforms(struct gl_shader_program
+					    *shader_program,
+					    struct gl_shader *sh,
+					    struct gl_program_parameter_list
+					    *params);
+#endif
diff --git a/mesalib/src/mesa/program/prog_print.c b/mesalib/src/mesa/program/prog_print.c
index 70412b1fa..dfccc60f6 100644
--- a/mesalib/src/mesa/program/prog_print.c
+++ b/mesalib/src/mesa/program/prog_print.c
@@ -1068,9 +1068,9 @@ _mesa_write_shader_to_file(const struct gl_shader *shader)
  * _mesa_write_shader_to_file function.
  */
 void
-_mesa_append_uniforms_to_file(const struct gl_shader *shader,
-                              const struct gl_program *prog)
+_mesa_append_uniforms_to_file(const struct gl_shader *shader)
 {
+   const struct gl_program *const prog = shader->Program;
    const char *type;
    char filename[100];
    FILE *f;
diff --git a/mesalib/src/mesa/program/prog_print.h b/mesalib/src/mesa/program/prog_print.h
index caeedb779..b95ec2be5 100644
--- a/mesalib/src/mesa/program/prog_print.h
+++ b/mesalib/src/mesa/program/prog_print.h
@@ -1,120 +1,119 @@
-/*

- * Mesa 3-D graphics library

- * Version:  6.5.3

- *

- * Copyright (C) 1999-2007  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.

- */

-

-

-#ifndef PROG_PRINT_H

-#define PROG_PRINT_H

-

-#include <stdio.h>

-

-#include "main/glheader.h"

-#include "main/mtypes.h"

-

-struct gl_program;

-struct gl_program_parameter_list;

-struct gl_shader;

-struct prog_instruction;

-

-

-/**

- * The output style to use when printing programs.

- */

-typedef enum {

-   PROG_PRINT_ARB,

-   PROG_PRINT_NV,

-   PROG_PRINT_DEBUG

-} gl_prog_print_mode;

-

-

-extern const char *

-_mesa_register_file_name(gl_register_file f);

-

-extern void

-_mesa_print_vp_inputs(GLbitfield inputs);

-

-extern void

-_mesa_print_fp_inputs(GLbitfield inputs);

-

-extern const char *

-_mesa_condcode_string(GLuint condcode);

-

-extern const char *

-_mesa_swizzle_string(GLuint swizzle, GLuint negateBase, GLboolean extended);

-

-const char *

-_mesa_writemask_string(GLuint writeMask);

-

-extern void

-_mesa_print_swizzle(GLuint swizzle);

-

-extern void

-_mesa_fprint_alu_instruction(FILE *f,

-			     const struct prog_instruction *inst,

-			     const char *opcode_string, GLuint numRegs,

-			     gl_prog_print_mode mode,

-			     const struct gl_program *prog);

-

-extern void

-_mesa_print_alu_instruction(const struct prog_instruction *inst,

-                            const char *opcode_string, GLuint numRegs);

-

-extern void

-_mesa_print_instruction(const struct prog_instruction *inst);

-

-extern GLint

-_mesa_fprint_instruction_opt(FILE *f,

-                            const struct prog_instruction *inst,

-                            GLint indent,

-                            gl_prog_print_mode mode,

-                            const struct gl_program *prog);

-

-extern GLint

-_mesa_print_instruction_opt(const struct prog_instruction *inst, GLint indent,

-                            gl_prog_print_mode mode,

-                            const struct gl_program *prog);

-

-extern void

-_mesa_print_program(const struct gl_program *prog);

-

-extern void

-_mesa_fprint_program_opt(FILE *f,

-                         const struct gl_program *prog, gl_prog_print_mode mode,

-                         GLboolean lineNumbers);

-

-extern void

-_mesa_print_program_parameters(struct gl_context *ctx, const struct gl_program *prog);

-

-extern void

-_mesa_print_parameter_list(const struct gl_program_parameter_list *list);

-

-

-extern void

-_mesa_write_shader_to_file(const struct gl_shader *shader);

-

-extern void

-_mesa_append_uniforms_to_file(const struct gl_shader *shader,

-                              const struct gl_program *prog);

-

-

-#endif /* PROG_PRINT_H */

+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5.3
+ *
+ * Copyright (C) 1999-2007  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.
+ */
+
+
+#ifndef PROG_PRINT_H
+#define PROG_PRINT_H
+
+#include <stdio.h>
+
+#include "main/glheader.h"
+#include "main/mtypes.h"
+
+struct gl_program;
+struct gl_program_parameter_list;
+struct gl_shader;
+struct prog_instruction;
+
+
+/**
+ * The output style to use when printing programs.
+ */
+typedef enum {
+   PROG_PRINT_ARB,
+   PROG_PRINT_NV,
+   PROG_PRINT_DEBUG
+} gl_prog_print_mode;
+
+
+extern const char *
+_mesa_register_file_name(gl_register_file f);
+
+extern void
+_mesa_print_vp_inputs(GLbitfield inputs);
+
+extern void
+_mesa_print_fp_inputs(GLbitfield inputs);
+
+extern const char *
+_mesa_condcode_string(GLuint condcode);
+
+extern const char *
+_mesa_swizzle_string(GLuint swizzle, GLuint negateBase, GLboolean extended);
+
+const char *
+_mesa_writemask_string(GLuint writeMask);
+
+extern void
+_mesa_print_swizzle(GLuint swizzle);
+
+extern void
+_mesa_fprint_alu_instruction(FILE *f,
+			     const struct prog_instruction *inst,
+			     const char *opcode_string, GLuint numRegs,
+			     gl_prog_print_mode mode,
+			     const struct gl_program *prog);
+
+extern void
+_mesa_print_alu_instruction(const struct prog_instruction *inst,
+                            const char *opcode_string, GLuint numRegs);
+
+extern void
+_mesa_print_instruction(const struct prog_instruction *inst);
+
+extern GLint
+_mesa_fprint_instruction_opt(FILE *f,
+                            const struct prog_instruction *inst,
+                            GLint indent,
+                            gl_prog_print_mode mode,
+                            const struct gl_program *prog);
+
+extern GLint
+_mesa_print_instruction_opt(const struct prog_instruction *inst, GLint indent,
+                            gl_prog_print_mode mode,
+                            const struct gl_program *prog);
+
+extern void
+_mesa_print_program(const struct gl_program *prog);
+
+extern void
+_mesa_fprint_program_opt(FILE *f,
+                         const struct gl_program *prog, gl_prog_print_mode mode,
+                         GLboolean lineNumbers);
+
+extern void
+_mesa_print_program_parameters(struct gl_context *ctx, const struct gl_program *prog);
+
+extern void
+_mesa_print_parameter_list(const struct gl_program_parameter_list *list);
+
+
+extern void
+_mesa_write_shader_to_file(const struct gl_shader *shader);
+
+extern void
+_mesa_append_uniforms_to_file(const struct gl_shader *shader);
+
+
+#endif /* PROG_PRINT_H */
diff --git a/mesalib/src/mesa/program/program.c b/mesalib/src/mesa/program/program.c
index 4d6c60b9d..736652529 100644
--- a/mesalib/src/mesa/program/program.c
+++ b/mesalib/src/mesa/program/program.c
@@ -140,7 +140,7 @@ _mesa_free_program_data(struct gl_context *ctx)
 #endif
 #if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program
    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
-   _mesa_delete_program_cache(ctx, ctx->FragmentProgram.Cache);
+   _mesa_delete_shader_cache(ctx, ctx->FragmentProgram.Cache);
 #endif
 #if FEATURE_ARB_geometry_shader4
    _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current, NULL);
diff --git a/mesalib/src/mesa/sources.mak b/mesalib/src/mesa/sources.mak
index f29213ec0..aedee3d1c 100644
--- a/mesalib/src/mesa/sources.mak
+++ b/mesalib/src/mesa/sources.mak
@@ -105,7 +105,8 @@ MAIN_SOURCES = \
 
 MAIN_CXX_SOURCES = \
 	main/ff_fragment_shader.cpp \
-	main/shader_query.cpp
+	main/shader_query.cpp \
+	main/uniform_query.cpp
 
 MATH_SOURCES = \
 	math/m_debug_clip.c \
diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
index 74e87f0e4..89e0a73f1 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -871,7 +871,7 @@ draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
 
          if (format == GL_DEPTH_STENCIL) {
             GLenum ztype =
-               pt->resource->format == PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED ?
+               pt->resource->format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT ?
                GL_FLOAT : GL_UNSIGNED_INT;
 
             _mesa_unpack_depth_span(ctx, spanWidth, ztype, zValues,
@@ -896,14 +896,14 @@ draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
 
             /* now pack the stencil (and Z) values in the dest format */
             switch (pt->resource->format) {
-            case PIPE_FORMAT_S8_USCALED:
+            case PIPE_FORMAT_S8_UINT:
                {
                   ubyte *dest = stmap + spanY * pt->stride + spanX;
                   assert(usage == PIPE_TRANSFER_WRITE);
                   memcpy(dest, sValues, spanWidth);
                }
                break;
-            case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+            case PIPE_FORMAT_Z24_UNORM_S8_UINT:
                if (format == GL_DEPTH_STENCIL) {
                   uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
                   GLint k;
@@ -921,7 +921,7 @@ draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
                   }
                }
                break;
-            case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+            case PIPE_FORMAT_S8_UINT_Z24_UNORM:
                if (format == GL_DEPTH_STENCIL) {
                   uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
                   GLint k;
@@ -939,7 +939,7 @@ draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
                   }
                }
                break;
-            case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+            case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
                if (format == GL_DEPTH_STENCIL) {
                   uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
                   GLfloat *destf = (GLfloat*)dest;
@@ -1112,20 +1112,20 @@ st_DrawPixels(struct gl_context *ctx, GLint x, GLint y,
                enum pipe_format stencil_format = PIPE_FORMAT_NONE;
 
                switch (pt->format) {
-               case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-               case PIPE_FORMAT_X24S8_USCALED:
-                  stencil_format = PIPE_FORMAT_X24S8_USCALED;
+               case PIPE_FORMAT_Z24_UNORM_S8_UINT:
+               case PIPE_FORMAT_X24S8_UINT:
+                  stencil_format = PIPE_FORMAT_X24S8_UINT;
                   break;
-               case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-               case PIPE_FORMAT_S8X24_USCALED:
-                  stencil_format = PIPE_FORMAT_S8X24_USCALED;
+               case PIPE_FORMAT_S8_UINT_Z24_UNORM:
+               case PIPE_FORMAT_S8X24_UINT:
+                  stencil_format = PIPE_FORMAT_S8X24_UINT;
                   break;
-               case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
-               case PIPE_FORMAT_X32_S8X24_USCALED:
-                  stencil_format = PIPE_FORMAT_X32_S8X24_USCALED;
+               case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
+               case PIPE_FORMAT_X32_S8X24_UINT:
+                  stencil_format = PIPE_FORMAT_X32_S8X24_UINT;
                   break;
-               case PIPE_FORMAT_S8_USCALED:
-                  stencil_format = PIPE_FORMAT_S8_USCALED;
+               case PIPE_FORMAT_S8_UINT:
+                  stencil_format = PIPE_FORMAT_S8_UINT;
                   break;
                default:
                   assert(0);
@@ -1241,7 +1241,7 @@ copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
       src = buffer + i * width;
 
       switch (ptDraw->resource->format) {
-      case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+      case PIPE_FORMAT_Z24_UNORM_S8_UINT:
          {
             uint *dst4 = (uint *) dst;
             int j;
@@ -1252,7 +1252,7 @@ copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
             }
          }
          break;
-      case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+      case PIPE_FORMAT_S8_UINT_Z24_UNORM:
          {
             uint *dst4 = (uint *) dst;
             int j;
@@ -1263,11 +1263,11 @@ copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
             }
          }
          break;
-      case PIPE_FORMAT_S8_USCALED:
+      case PIPE_FORMAT_S8_UINT:
          assert(usage == PIPE_TRANSFER_WRITE);
          memcpy(dst, src, width);
          break;
-      case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+      case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
          {
             uint *dst4 = (uint *) dst;
             int j;
diff --git a/mesalib/src/mesa/state_tracker/st_cb_eglimage.c b/mesalib/src/mesa/state_tracker/st_cb_eglimage.c
index 531296fb3..37c20ebe3 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_eglimage.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_eglimage.c
@@ -53,7 +53,7 @@ st_pipe_format_to_base_format(enum pipe_format format)
          base_format = GL_DEPTH_STENCIL;
       }
       else {
-         if (format == PIPE_FORMAT_S8_USCALED)
+         if (format == PIPE_FORMAT_S8_UINT)
             base_format = GL_STENCIL_INDEX;
          else
             base_format = GL_DEPTH_COMPONENT;
diff --git a/mesalib/src/mesa/state_tracker/st_cb_fbo.c b/mesalib/src/mesa/state_tracker/st_cb_fbo.c
index 4d321587f..6da65d7b9 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_fbo.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_fbo.c
@@ -259,13 +259,13 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)
    case PIPE_FORMAT_Z32_UNORM:
       strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;
       break;
-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
+   case PIPE_FORMAT_S8_UINT_Z24_UNORM:
    case PIPE_FORMAT_Z24X8_UNORM:
    case PIPE_FORMAT_X8Z24_UNORM:
       strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;
       break;
-   case PIPE_FORMAT_S8_USCALED:
+   case PIPE_FORMAT_S8_UINT:
       strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;
       break;
    case PIPE_FORMAT_R16G16B16A16_SNORM:
diff --git a/mesalib/src/mesa/state_tracker/st_cb_readpixels.c b/mesalib/src/mesa/state_tracker/st_cb_readpixels.c
index 7fa1672fd..bd73f3bf0 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_readpixels.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_readpixels.c
@@ -109,13 +109,13 @@ st_read_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
 
       /* get stencil (and Z) values */
       switch (pt->resource->format) {
-      case PIPE_FORMAT_S8_USCALED:
+      case PIPE_FORMAT_S8_UINT:
          {
             const ubyte *src = stmap + srcY * pt->stride;
             memcpy(sValues, src, width);
          }
          break;
-      case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+      case PIPE_FORMAT_Z24_UNORM_S8_UINT:
          if (format == GL_DEPTH_STENCIL) {
             const uint *src = (uint *) (stmap + srcY * pt->stride);
             const GLfloat scale = 1.0f / (0xffffff);
@@ -133,7 +133,7 @@ st_read_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
             }
          }
          break;
-      case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+      case PIPE_FORMAT_S8_UINT_Z24_UNORM:
          if (format == GL_DEPTH_STENCIL) {
             const uint *src = (uint *) (stmap + srcY * pt->stride);
             const GLfloat scale = 1.0f / (0xffffff);
@@ -151,7 +151,7 @@ st_read_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
             }
          }
          break;
-      case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+      case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
          if (format == GL_DEPTH_STENCIL) {
             const uint *src = (uint *) (stmap + srcY * pt->stride);
             const GLfloat *srcf = (const GLfloat*)src;
@@ -502,7 +502,7 @@ st_readpixels(struct gl_context *ctx, GLint x, GLint y, GLsizei width, GLsizei h
       const GLint dstStride = _mesa_image_row_stride(&clippedPacking, width,
                                                      format, type);
 
-      if (pformat == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
+      if (pformat == PIPE_FORMAT_Z24_UNORM_S8_UINT ||
           pformat == PIPE_FORMAT_Z24X8_UNORM) {
          if (format == GL_DEPTH_COMPONENT) {
             for (i = 0; i < height; i++) {
@@ -534,7 +534,7 @@ st_readpixels(struct gl_context *ctx, GLint x, GLint y, GLsizei width, GLsizei h
             }
          }
       }
-      else if (pformat == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
+      else if (pformat == PIPE_FORMAT_S8_UINT_Z24_UNORM ||
                pformat == PIPE_FORMAT_X8Z24_UNORM) {
          if (format == GL_DEPTH_COMPONENT) {
             for (i = 0; i < height; i++) {
@@ -601,7 +601,7 @@ st_readpixels(struct gl_context *ctx, GLint x, GLint y, GLsizei width, GLsizei h
             dst += dstStride;
          }
       }
-      else if (pformat == PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED) {
+      else if (pformat == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT) {
          assert(format == GL_DEPTH_COMPONENT);
          for (i = 0; i < height; i++) {
             GLfloat zfloat[MAX_WIDTH];    /* Z32 */
diff --git a/mesalib/src/mesa/state_tracker/st_extensions.c b/mesalib/src/mesa/state_tracker/st_extensions.c
index 6707fcae1..a1f029089 100644
--- a/mesalib/src/mesa/state_tracker/st_extensions.c
+++ b/mesalib/src/mesa/state_tracker/st_extensions.c
@@ -368,18 +368,18 @@ void st_init_extensions(struct st_context *st)
    /* GL_EXT_packed_depth_stencil requires both the ability to render to
     * a depth/stencil buffer and texture from depth/stencil source.
     */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
+   if (screen->is_format_supported(screen, PIPE_FORMAT_S8_UINT_Z24_UNORM,
                                    PIPE_TEXTURE_2D, 0,
                                    PIPE_BIND_DEPTH_STENCIL) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
+       screen->is_format_supported(screen, PIPE_FORMAT_S8_UINT_Z24_UNORM,
                                    PIPE_TEXTURE_2D, 0,
                                    PIPE_BIND_SAMPLER_VIEW)) {
       ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
    }
-   else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
+   else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_UINT,
                                         PIPE_TEXTURE_2D, 0,
                                         PIPE_BIND_DEPTH_STENCIL) &&
-            screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
+            screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_UINT,
                                         PIPE_TEXTURE_2D, 0,
                                         PIPE_BIND_SAMPLER_VIEW)) {
       ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
@@ -650,7 +650,7 @@ void st_init_extensions(struct st_context *st)
                                    PIPE_TEXTURE_2D, 0,
                                    PIPE_BIND_DEPTH_STENCIL |
                                    PIPE_BIND_SAMPLER_VIEW) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED,
+       screen->is_format_supported(screen, PIPE_FORMAT_Z32_FLOAT_S8X24_UINT,
                                    PIPE_TEXTURE_2D, 0,
                                    PIPE_BIND_DEPTH_STENCIL |
                                    PIPE_BIND_SAMPLER_VIEW)) {
diff --git a/mesalib/src/mesa/state_tracker/st_format.c b/mesalib/src/mesa/state_tracker/st_format.c
index 6e8ab94f4..196433d5e 100644
--- a/mesalib/src/mesa/state_tracker/st_format.c
+++ b/mesalib/src/mesa/state_tracker/st_format.c
@@ -89,13 +89,13 @@ st_format_datatype(enum pipe_format format)
                format == PIPE_FORMAT_R9G9B9E5_FLOAT) {
          return GL_FLOAT;
       }
-      else if (format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
-               format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
+      else if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT ||
+               format == PIPE_FORMAT_S8_UINT_Z24_UNORM ||
                format == PIPE_FORMAT_Z24X8_UNORM ||
                format == PIPE_FORMAT_X8Z24_UNORM) {
          return GL_UNSIGNED_INT_24_8;
       }
-      else if (format == PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED) {
+      else if (format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT) {
          return GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
       }
       else {
@@ -199,19 +199,19 @@ st_mesa_format_to_pipe_format(gl_format mesaFormat)
    case MESA_FORMAT_Z32:
       return PIPE_FORMAT_Z32_UNORM;
    case MESA_FORMAT_Z24_S8:
-      return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
+      return PIPE_FORMAT_S8_UINT_Z24_UNORM;
    case MESA_FORMAT_S8_Z24:
-      return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
+      return PIPE_FORMAT_Z24_UNORM_S8_UINT;
    case MESA_FORMAT_Z24_X8:
       return PIPE_FORMAT_X8Z24_UNORM;
    case MESA_FORMAT_X8_Z24:
       return PIPE_FORMAT_Z24X8_UNORM;
    case MESA_FORMAT_S8:
-      return PIPE_FORMAT_S8_USCALED;
+      return PIPE_FORMAT_S8_UINT;
    case MESA_FORMAT_Z32_FLOAT:
       return PIPE_FORMAT_Z32_FLOAT;
    case MESA_FORMAT_Z32_FLOAT_X24S8:
-      return PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED;
+      return PIPE_FORMAT_Z32_FLOAT_S8X24_UINT;
    case MESA_FORMAT_YCBCR:
       return PIPE_FORMAT_UYVY;
 #if FEATURE_texture_s3tc
@@ -508,7 +508,7 @@ st_pipe_format_to_mesa_format(enum pipe_format format)
       return MESA_FORMAT_I8;
    case PIPE_FORMAT_I16_UNORM:
       return MESA_FORMAT_I16;
-   case PIPE_FORMAT_S8_USCALED:
+   case PIPE_FORMAT_S8_UINT:
       return MESA_FORMAT_S8;
 
    case PIPE_FORMAT_R16G16B16A16_UNORM:
@@ -518,17 +518,17 @@ st_pipe_format_to_mesa_format(enum pipe_format format)
       return MESA_FORMAT_Z16;
    case PIPE_FORMAT_Z32_UNORM:
       return MESA_FORMAT_Z32;
-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+   case PIPE_FORMAT_S8_UINT_Z24_UNORM:
       return MESA_FORMAT_Z24_S8;
    case PIPE_FORMAT_X8Z24_UNORM:
       return MESA_FORMAT_Z24_X8;
    case PIPE_FORMAT_Z24X8_UNORM:
       return MESA_FORMAT_X8_Z24;
-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
       return MESA_FORMAT_S8_Z24;
    case PIPE_FORMAT_Z32_FLOAT:
       return MESA_FORMAT_Z32_FLOAT;
-   case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED:
+   case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
       return MESA_FORMAT_Z32_FLOAT_X24S8;
 
    case PIPE_FORMAT_UYVY:
@@ -818,8 +818,8 @@ struct format_mapping
       PIPE_FORMAT_Z24X8_UNORM, \
       PIPE_FORMAT_X8Z24_UNORM, \
       PIPE_FORMAT_Z16_UNORM, \
-      PIPE_FORMAT_Z24_UNORM_S8_USCALED, \
-      PIPE_FORMAT_S8_USCALED_Z24_UNORM, \
+      PIPE_FORMAT_Z24_UNORM_S8_UINT, \
+      PIPE_FORMAT_S8_UINT_Z24_UNORM, \
       0
 
 /**
@@ -988,19 +988,19 @@ static const struct format_mapping format_map[] = {
       { GL_STENCIL_INDEX, GL_STENCIL_INDEX1_EXT, GL_STENCIL_INDEX4_EXT,
         GL_STENCIL_INDEX8_EXT, GL_STENCIL_INDEX16_EXT, 0 },
       {
-         PIPE_FORMAT_S8_USCALED, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-         PIPE_FORMAT_S8_USCALED_Z24_UNORM, 0
+         PIPE_FORMAT_S8_UINT, PIPE_FORMAT_Z24_UNORM_S8_UINT,
+         PIPE_FORMAT_S8_UINT_Z24_UNORM, 0
       }
    },
 
    /* Depth / Stencil formats */
    {
       { GL_DEPTH_STENCIL_EXT, GL_DEPTH24_STENCIL8_EXT, 0 },
-      { PIPE_FORMAT_Z24_UNORM_S8_USCALED, PIPE_FORMAT_S8_USCALED_Z24_UNORM, 0 }
+      { PIPE_FORMAT_Z24_UNORM_S8_UINT, PIPE_FORMAT_S8_UINT_Z24_UNORM, 0 }
    },
    {
       { GL_DEPTH32F_STENCIL8, 0 },
-      { PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED, 0 }
+      { PIPE_FORMAT_Z32_FLOAT_S8X24_UINT, 0 }
    },
 
    /* sRGB formats */
diff --git a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
index fe65ae539..18e8a1db4 100644
--- a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
+++ b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
@@ -42,12 +42,13 @@
 #include "ir_optimization.h"
 #include "ast.h"
 
-extern "C" {
 #include "main/mtypes.h"
-#include "main/shaderapi.h"
 #include "main/shaderobj.h"
-#include "main/uniforms.h"
 #include "program/hash_table.h"
+
+extern "C" {
+#include "main/shaderapi.h"
+#include "main/uniforms.h"
 #include "program/prog_instruction.h"
 #include "program/prog_optimize.h"
 #include "program/prog_print.h"
@@ -2913,122 +2914,6 @@ check_resources(const struct gl_context *ctx,
 }
 
 
-
-struct uniform_sort {
-   struct gl_uniform *u;
-   int pos;
-};
-
-/* The shader_program->Uniforms list is almost sorted in increasing
- * uniform->{Frag,Vert}Pos locations, but not quite when there are
- * uniforms shared between targets.  We need to add parameters in
- * increasing order for the targets.
- */
-static int
-sort_uniforms(const void *a, const void *b)
-{
-   struct uniform_sort *u1 = (struct uniform_sort *)a;
-   struct uniform_sort *u2 = (struct uniform_sort *)b;
-
-   return u1->pos - u2->pos;
-}
-
-/* Add the uniforms to the parameters.  The linker chose locations
- * in our parameters lists (which weren't created yet), which the
- * uniforms code will use to poke values into our parameters list
- * when uniforms are updated.
- */
-static void
-add_uniforms_to_parameters_list(struct gl_shader_program *shader_program,
-        			struct gl_shader *shader,
-        			struct gl_program *prog)
-{
-   unsigned int i;
-   unsigned int next_sampler = 0, num_uniforms = 0;
-   struct uniform_sort *sorted_uniforms;
-
-   sorted_uniforms = ralloc_array(NULL, struct uniform_sort,
-        			  shader_program->Uniforms->NumUniforms);
-
-   for (i = 0; i < shader_program->Uniforms->NumUniforms; i++) {
-      struct gl_uniform *uniform = shader_program->Uniforms->Uniforms + i;
-      int parameter_index = -1;
-
-      switch (shader->Type) {
-      case GL_VERTEX_SHADER:
-         parameter_index = uniform->VertPos;
-         break;
-      case GL_FRAGMENT_SHADER:
-         parameter_index = uniform->FragPos;
-         break;
-      case GL_GEOMETRY_SHADER:
-         parameter_index = uniform->GeomPos;
-         break;
-      }
-
-      /* Only add uniforms used in our target. */
-      if (parameter_index != -1) {
-         sorted_uniforms[num_uniforms].pos = parameter_index;
-         sorted_uniforms[num_uniforms].u = uniform;
-         num_uniforms++;
-      }
-   }
-
-   qsort(sorted_uniforms, num_uniforms, sizeof(struct uniform_sort),
-         sort_uniforms);
-
-   for (i = 0; i < num_uniforms; i++) {
-      struct gl_uniform *uniform = sorted_uniforms[i].u;
-      int parameter_index = sorted_uniforms[i].pos;
-      const glsl_type *type = uniform->Type;
-      unsigned int size;
-
-      if (type->is_vector() ||
-          type->is_scalar()) {
-         size = type->vector_elements;
-      } else {
-         size = type_size(type) * 4;
-      }
-
-      gl_register_file file;
-      if (type->is_sampler() ||
-          (type->is_array() && type->fields.array->is_sampler())) {
-         file = PROGRAM_SAMPLER;
-      } else {
-         file = PROGRAM_UNIFORM;
-      }
-
-      GLint index = _mesa_lookup_parameter_index(prog->Parameters, -1,
-        					 uniform->Name);
-
-      if (index < 0) {
-         index = _mesa_add_parameter(prog->Parameters, file,
-        			     uniform->Name, size, type->gl_type,
-        			     NULL, NULL, 0x0);
-
-         /* Sampler uniform values are stored in prog->SamplerUnits,
-          * and the entry in that array is selected by this index we
-          * store in ParameterValues[].
-          */
-         if (file == PROGRAM_SAMPLER) {
-            for (unsigned int j = 0; j < size / 4; j++)
-               prog->Parameters->ParameterValues[index + j][0].f = next_sampler++;
-         }
-
-         /* The location chosen in the Parameters list here (returned
-          * from _mesa_add_uniform) has to match what the linker chose.
-          */
-         if (index != parameter_index) {
-            fail_link(shader_program, "Allocation of uniform `%s' to target "
-        	      "failed (%d vs %d)\n",
-        	      uniform->Name, index, parameter_index);
-         }
-      }
-   }
-
-   ralloc_free(sorted_uniforms);
-}
-
 static void
 set_uniform_initializer(struct gl_context *ctx, void *mem_ctx,
         		struct gl_shader_program *shader_program,
@@ -3772,7 +3657,7 @@ glsl_to_tgsi_visitor::eliminate_dead_code_advanced(void)
       
       if (!inst->dead_mask || !inst->dst.writemask)
          continue;
-      else if (inst->dead_mask == inst->dst.writemask) {
+      else if ((inst->dst.writemask & ~inst->dead_mask) == 0) {
          iter.remove();
          delete inst;
          removed++;
@@ -4964,7 +4849,8 @@ get_mesa_program(struct gl_context *ctx,
    v->glsl_version = ctx->Const.GLSLVersion;
    v->native_integers = ctx->Const.NativeIntegers;
 
-   add_uniforms_to_parameters_list(shader_program, shader, prog);
+   _mesa_generate_parameters_list_for_uniforms(shader_program, shader,
+					       prog->Parameters);
 
    /* Emit intermediate IR for main(). */
    visit_exec_list(shader->ir, v);
diff --git a/mesalib/src/mesa/state_tracker/st_program.c b/mesalib/src/mesa/state_tracker/st_program.c
index acd3b56b9..c419c4066 100644
--- a/mesalib/src/mesa/state_tracker/st_program.c
+++ b/mesalib/src/mesa/state_tracker/st_program.c
@@ -1154,7 +1154,8 @@ destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
          }
 
 	 for (i = 0; i < Elements(shProg->_LinkedShaders); i++) {
-	    destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
+	    if (shProg->_LinkedShaders[i])
+               destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
 	 }
       }
       break;
diff --git a/mesalib/src/mesa/swrast/s_drawpix.c b/mesalib/src/mesa/swrast/s_drawpix.c
index 63bfa79b5..20bf4d626 100644
--- a/mesalib/src/mesa/swrast/s_drawpix.c
+++ b/mesalib/src/mesa/swrast/s_drawpix.c
@@ -590,8 +590,11 @@ draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
    ASSERT(stencilRb);
 
    if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
+       depthRb->Format == MESA_FORMAT_Z24_S8 &&
+       type == GL_UNSIGNED_INT_24_8 &&
        depthRb == stencilRb &&
+       depthRb->GetRow &&  /* May be null if depthRb is a wrapper around
+			    * separate depth and stencil buffers. */
        !scaleOrBias &&
        !zoom &&
        ctx->Depth.Mask &&
diff --git a/mesalib/src/mesa/swrast/s_readpix.c b/mesalib/src/mesa/swrast/s_readpix.c
index 6eec2fc78..0d2e63f72 100644
--- a/mesalib/src/mesa/swrast/s_readpix.c
+++ b/mesalib/src/mesa/swrast/s_readpix.c
@@ -391,8 +391,11 @@ read_depth_stencil_pixels(struct gl_context *ctx,
    stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
 
    if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
+       depthRb->Format == MESA_FORMAT_Z24_S8 &&
+       type == GL_UNSIGNED_INT_24_8 &&
        depthRb == stencilRb &&
+       depthRb->GetRow &&  /* May be null if depthRb is a wrapper around
+			    * separate depth and stencil buffers. */
        !scaleOrBias &&
        !stencilTransfer) {
       /* This is the ideal case.
diff --git a/mesalib/src/mesa/swrast/s_span.c b/mesalib/src/mesa/swrast/s_span.c
index 1aa20f9d7..e517c9ae1 100644
--- a/mesalib/src/mesa/swrast/s_span.c
+++ b/mesalib/src/mesa/swrast/s_span.c
@@ -707,11 +707,13 @@ clip_span( struct gl_context *ctx, SWspan *span )
       const GLint n = span->end;
       GLubyte *mask = span->array->mask;
       GLint i;
+      GLuint passed = 0;
       if (span->arrayMask & SPAN_MASK) {
          /* note: using & intead of && to reduce branches */
          for (i = 0; i < n; i++) {
             mask[i] &= (x[i] >= xmin) & (x[i] < xmax)
                      & (y[i] >= ymin) & (y[i] < ymax);
+            passed += mask[i];
          }
       }
       else {
@@ -719,9 +721,10 @@ clip_span( struct gl_context *ctx, SWspan *span )
          for (i = 0; i < n; i++) {
             mask[i] = (x[i] >= xmin) & (x[i] < xmax)
                     & (y[i] >= ymin) & (y[i] < ymax);
+            passed += mask[i];
          }
       }
-      return GL_TRUE;  /* some pixels visible */
+      return passed > 0;
    }
    else {
       /* horizontal span of pixels */
diff --git a/mesalib/src/mesa/vbo/vbo.h b/mesalib/src/mesa/vbo/vbo.h
index 26c3d4e0a..9fbb07f3d 100644
--- a/mesalib/src/mesa/vbo/vbo.h
+++ b/mesalib/src/mesa/vbo/vbo.h
@@ -133,6 +133,7 @@ void vbo_set_draw_func(struct gl_context *ctx, vbo_draw_func func);
 
 void vbo_check_buffers_are_unmapped(struct gl_context *ctx);
 
+void vbo_bind_arrays(struct gl_context *ctx);
 
 void GLAPIENTRY
 _es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a);
diff --git a/mesalib/src/mesa/vbo/vbo_exec_api.c b/mesalib/src/mesa/vbo/vbo_exec_api.c
index 150589bec..5f3ed9d5d 100644
--- a/mesalib/src/mesa/vbo/vbo_exec_api.c
+++ b/mesalib/src/mesa/vbo/vbo_exec_api.c
@@ -570,6 +570,9 @@ static void GLAPIENTRY vbo_exec_Begin( GLenum mode )
          return;
       }
 
+      if (ctx->Driver.PrepareExecBegin)
+	 ctx->Driver.PrepareExecBegin(ctx);
+
       if (ctx->NewState) {
 	 _mesa_update_state( ctx );
 
diff --git a/mesalib/src/mesa/vbo/vbo_exec_array.c b/mesalib/src/mesa/vbo/vbo_exec_array.c
index 18719d5f5..4e4f2c947 100644
--- a/mesalib/src/mesa/vbo/vbo_exec_array.c
+++ b/mesalib/src/mesa/vbo/vbo_exec_array.c
@@ -538,7 +538,7 @@ recalculate_input_bindings(struct gl_context *ctx)
          }
       }
 
-      for (i = 0; i < MAX_VERTEX_GENERIC_ATTRIBS; i++) {
+      for (i = 1; i < MAX_VERTEX_GENERIC_ATTRIBS; i++) {
 	 if (exec->array.generic_array[i]->Enabled)
 	    inputs[VERT_ATTRIB_GENERIC0 + i] = exec->array.generic_array[i];
 	 else {
@@ -547,6 +547,7 @@ recalculate_input_bindings(struct gl_context *ctx)
          }
       }
 
+      inputs[VERT_ATTRIB_GENERIC0] = inputs[0];
       ctx->NewState |= _NEW_ARRAY;
       break;
    }
@@ -562,8 +563,8 @@ recalculate_input_bindings(struct gl_context *ctx)
  * Note that this might set the _NEW_ARRAY dirty flag so state validation
  * must be done after this call.
  */
-static void
-bind_arrays(struct gl_context *ctx)
+void
+vbo_bind_arrays(struct gl_context *ctx)
 {
    if (!ctx->Array.RebindArrays) {
       return;
@@ -589,7 +590,7 @@ vbo_draw_arrays(struct gl_context *ctx, GLenum mode, GLint start,
    struct vbo_exec_context *exec = &vbo->exec;
    struct _mesa_prim prim[2];
 
-   bind_arrays(ctx);
+   vbo_bind_arrays(ctx);
 
    /* Again... because we may have changed the bitmask of per-vertex varying
     * attributes.  If we regenerate the fixed-function vertex program now
@@ -803,7 +804,7 @@ vbo_validated_drawrangeelements(struct gl_context *ctx, GLenum mode,
       return;
    }
 
-   bind_arrays( ctx );
+   vbo_bind_arrays( ctx );
 
    /* check for dirty state again */
    if (ctx->NewState)
@@ -1128,7 +1129,7 @@ vbo_validated_multidrawelements(struct gl_context *ctx, GLenum mode,
     * same index buffer, or if we have to reset the index pointer per
     * primitive.
     */
-   bind_arrays( ctx );
+   vbo_bind_arrays( ctx );
 
    /* check for dirty state again */
    if (ctx->NewState)