Merge remote-tracking branch 'origin/released'

* origin/released:
  git update fontconfig mesa libXau pixman xkeyboard-config 30 Sep 2013

27 files changed, 936 insertions, 39 deletions

diff --git a/mesalib/src/glsl/ast_to_hir.cpp b/mesalib/src/glsl/ast_to_hir.cpp
index 2316cf8e5..0859d9e00 100644
--- a/mesalib/src/glsl/ast_to_hir.cpp
+++ b/mesalib/src/glsl/ast_to_hir.cpp
@@ -2842,7 +2842,7 @@ ast_declarator_list::hir(exec_list *instructions,
        * any extension that adds the 'layout' keyword.
        */
       if (!state->is_version(130, 300)
-	  && !state->ARB_explicit_attrib_location_enable
+	  && !state->has_explicit_attrib_location()
 	  && !state->ARB_fragment_coord_conventions_enable) {
 	 if (this->type->qualifier.flags.q.out) {
 	    _mesa_glsl_error(& loc, state,
diff --git a/mesalib/src/glsl/glsl_parser.yy b/mesalib/src/glsl/glsl_parser.yy
index fa6e2053a..912931a47 100644
--- a/mesalib/src/glsl/glsl_parser.yy
+++ b/mesalib/src/glsl/glsl_parser.yy
@@ -1200,7 +1200,7 @@ layout_qualifier_id:
       }
 
       /* See also interface_block_layout_qualifier. */
-      if (!$$.flags.i && state->ARB_uniform_buffer_object_enable) {
+      if (!$$.flags.i && state->has_uniform_buffer_objects()) {
          if (strcmp($1, "std140") == 0) {
             $$.flags.q.std140 = 1;
          } else if (strcmp($1, "shared") == 0) {
@@ -1262,7 +1262,7 @@ layout_qualifier_id:
    {
       memset(& $$, 0, sizeof($$));
 
-      if (state->ARB_explicit_attrib_location_enable) {
+      if (state->has_explicit_attrib_location()) {
          if (strcmp("location", $1) == 0) {
             $$.flags.q.explicit_location = 1;
 
@@ -1328,7 +1328,7 @@ layout_qualifier_id:
    {
       $$ = $1;
       /* Layout qualifiers for ARB_uniform_buffer_object. */
-      if ($$.flags.q.uniform && !state->ARB_uniform_buffer_object_enable) {
+      if ($$.flags.q.uniform && !state->has_uniform_buffer_objects()) {
          _mesa_glsl_error(& @1, state,
                           "#version 140 / GL_ARB_uniform_buffer_object "
                           "layout qualifier `%s' is used", $1);
@@ -2138,7 +2138,7 @@ basic_interface_block:
       block->declarations.push_degenerate_list_at_head(& $4->link);
 
       if ($1.flags.q.uniform) {
-         if (!state->ARB_uniform_buffer_object_enable) {
+         if (!state->has_uniform_buffer_objects()) {
             _mesa_glsl_error(& @1, state,
                              "#version 140 / GL_ARB_uniform_buffer_object "
                              "required for defining uniform blocks");
diff --git a/mesalib/src/glsl/glsl_parser_extras.cpp b/mesalib/src/glsl/glsl_parser_extras.cpp
index cac5a18e4..e9922fc14 100644
--- a/mesalib/src/glsl/glsl_parser_extras.cpp
+++ b/mesalib/src/glsl/glsl_parser_extras.cpp
@@ -299,14 +299,6 @@ _mesa_glsl_parse_state::process_version_directive(YYLTYPE *locp, int version,
 	 break;
       }
    }
-
-   if (this->language_version >= 140) {
-      this->ARB_uniform_buffer_object_enable = true;
-   }
-
-   if (this->language_version == 300 && this->es_shader) {
-      this->ARB_explicit_attrib_location_enable = true;
-   }
 }
 
 extern "C" {
diff --git a/mesalib/src/glsl/glsl_parser_extras.h b/mesalib/src/glsl/glsl_parser_extras.h
index 597e5427b..3a228fde7 100755
--- a/mesalib/src/glsl/glsl_parser_extras.h
+++ b/mesalib/src/glsl/glsl_parser_extras.h
@@ -125,6 +125,16 @@ struct _mesa_glsl_parse_state {
       return check_version(130, 300, locp, "bit-wise operations are forbidden");
    }
 
+   bool has_explicit_attrib_location() const
+   {
+      return ARB_explicit_attrib_location_enable || is_version(330, 300);
+   }
+
+   bool has_uniform_buffer_objects() const
+   {
+      return ARB_uniform_buffer_object_enable || is_version(140, 300);
+   }
+
    void process_version_directive(YYLTYPE *locp, int version,
                                   const char *ident);
 
diff --git a/mesalib/src/mapi/glapi/gen/AMD_performance_monitor.xml b/mesalib/src/mapi/glapi/gen/AMD_performance_monitor.xml
new file mode 100644
index 000000000..b96b263db
--- /dev/null
+++ b/mesalib/src/mapi/glapi/gen/AMD_performance_monitor.xml
@@ -0,0 +1,87 @@
+<?xml version="1.0"?>
+<!DOCTYPE OpenGLAPI SYSTEM "gl_API.dtd">
+
+<OpenGLAPI>
+
+<category name="GL_AMD_performance_monitor" number="360">
+
+    <function name="GetPerfMonitorGroupsAMD" offset="assign">
+        <param name="numGroups" type="GLint *"/>
+        <param name="groupsSize" type="GLsizei"/>
+        <param name="groups" type="GLuint *"/>
+    </function>
+
+    <function name="GetPerfMonitorCountersAMD" offset="assign">
+        <param name="group" type="GLuint"/>
+        <param name="numCounters" type="GLint *"/>
+        <param name="maxActiveCounters" type="GLint *"/>
+        <param name="countersSize" type="GLsizei"/>
+        <param name="counters" type="GLuint *"/>
+    </function>
+
+    <function name="GetPerfMonitorGroupStringAMD" offset="assign">
+        <param name="group" type="GLuint"/>
+        <param name="bufSize" type="GLsizei"/>
+        <param name="length" type="GLsizei *"/>
+        <param name="groupString" type="GLchar *"/>
+    </function>
+
+    <function name="GetPerfMonitorCounterStringAMD" offset="assign">
+        <param name="group" type="GLuint"/>
+        <param name="counter" type="GLuint"/>
+        <param name="bufSize" type="GLsizei"/>
+        <param name="length" type="GLsizei *"/>
+        <param name="counterString" type="GLchar *"/>
+    </function>
+
+    <function name="GetPerfMonitorCounterInfoAMD" offset="assign">
+        <param name="group" type="GLuint"/>
+        <param name="counter" type="GLuint"/>
+        <param name="pname" type="GLenum"/>
+        <param name="data" type="GLvoid *"/>
+    </function>
+
+    <function name="GenPerfMonitorsAMD" offset="assign">
+        <param name="n" type="GLsizei"/>
+        <param name="monitors" type="GLuint *"/>
+    </function>
+
+    <function name="DeletePerfMonitorsAMD" offset="assign">
+        <param name="n" type="GLsizei"/>
+        <param name="monitors" type="GLuint *"/>
+    </function>
+
+    <function name="SelectPerfMonitorCountersAMD" offset="assign">
+        <param name="monitor" type="GLuint"/>
+        <param name="enable" type="GLboolean"/>
+        <param name="group" type="GLuint"/>
+        <param name="numCounters" type="GLint"/>
+        <param name="counterList" type="GLuint *"/>
+    </function>
+
+    <function name="BeginPerfMonitorAMD" offset="assign">
+        <param name="monitor" type="GLuint"/>
+    </function>
+
+    <function name="EndPerfMonitorAMD" offset="assign">
+        <param name="monitor" type="GLuint"/>
+    </function>
+
+    <function name="GetPerfMonitorCounterDataAMD" offset="assign">
+        <param name="monitor" type="GLuint"/>
+        <param name="pname" type="GLenum"/>
+        <param name="dataSize" type="GLsizei"/>
+        <param name="data" type="GLuint *"/>
+        <param name="bytesWritten" type="GLint *"/>
+    </function>
+
+    <enum name="COUNTER_TYPE_AMD" value="0x8BC0"/>
+    <enum name="COUNTER_RANGE_AMD" value="0x8BC1"/>
+    <enum name="UNSIGNED_INT64_AMD" value="0x8BC2"/>
+    <enum name="PECENTAGE_AMD" value="0x8BC3"/>
+    <enum name="PERFMON_RESULT_AVAILABLE_AMD" value="0x8BC4"/>
+    <enum name="PERFMON_RESULT_SIZE_AMD" value="0x8BC5"/>
+    <enum name="PERFMON_RESULT_AMD" value="0x8BC6"/>
+</category>
+
+</OpenGLAPI>
diff --git a/mesalib/src/mapi/glapi/gen/Makefile.am b/mesalib/src/mapi/glapi/gen/Makefile.am
index d4fbd3511..9b9b99505 100644
--- a/mesalib/src/mapi/glapi/gen/Makefile.am
+++ b/mesalib/src/mapi/glapi/gen/Makefile.am
@@ -115,6 +115,7 @@ API_XML = \
 	ARB_texture_storage.xml \
 	ARB_vertex_array_object.xml \
 	AMD_draw_buffers_blend.xml \
+	AMD_performance_monitor.xml \
 	ARB_vertex_type_2_10_10_10_rev.xml \
 	APPLE_object_purgeable.xml \
 	APPLE_vertex_array_object.xml \
diff --git a/mesalib/src/mapi/glapi/gen/gl_API.xml b/mesalib/src/mapi/glapi/gen/gl_API.xml
index dad30dc16..c65dd3cef 100755
--- a/mesalib/src/mapi/glapi/gen/gl_API.xml
+++ b/mesalib/src/mapi/glapi/gen/gl_API.xml
@@ -12890,6 +12890,8 @@
     <enum name="FRAMEBUFFER_SRGB_CAPABLE_EXT"      value="0x8DBA"/>
 </category>
 
+<xi:include href="AMD_performance_monitor.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+
 <category name="GL_APPLE_texture_range" number="367">
     <enum name="TEXTURE_STORAGE_HINT_APPLE" count="1" value="0x85BC">
         <size name="TexParameteriv" mode="get"/>
diff --git a/mesalib/src/mapi/glapi/gen/gl_genexec.py b/mesalib/src/mapi/glapi/gen/gl_genexec.py
index be82f9089..a074c2348 100644
--- a/mesalib/src/mapi/glapi/gen/gl_genexec.py
+++ b/mesalib/src/mapi/glapi/gen/gl_genexec.py
@@ -82,6 +82,7 @@ header = """/**
 #include "main/matrix.h"
 #include "main/multisample.h"
 #include "main/objectlabel.h"
+#include "main/performance_monitor.h"
 #include "main/pixel.h"
 #include "main/pixelstore.h"
 #include "main/points.h"
diff --git a/mesalib/src/mesa/Android.libmesa_dricore.mk b/mesalib/src/mesa/Android.libmesa_dricore.mk
index 00c06943c..3679b50ba 100644
--- a/mesalib/src/mesa/Android.libmesa_dricore.mk
+++ b/mesalib/src/mesa/Android.libmesa_dricore.mk
@@ -49,9 +49,6 @@ ifeq ($(TARGET_ARCH),x86)
 endif # x86
 endif # MESA_ENABLE_ASM
 
-LOCAL_CFLAGS := \
-   $(patsubst %,-DFEATURE_%=1,$(MESA_ENABLED_APIS))
-
 LOCAL_C_INCLUDES := \
 	$(call intermediates-dir-for STATIC_LIBRARIES,libmesa_program,,) \
 	$(MESA_TOP)/src/mapi \
diff --git a/mesalib/src/mesa/Makefile.sources b/mesalib/src/mesa/Makefile.sources
index 122ea8e3a..ff242b4ab 100644
--- a/mesalib/src/mesa/Makefile.sources
+++ b/mesalib/src/mesa/Makefile.sources
@@ -65,6 +65,7 @@ MAIN_FILES = \
         $(SRCDIR)main/objectlabel.c \
 	$(SRCDIR)main/pack.c \
 	$(SRCDIR)main/pbo.c \
+	$(SRCDIR)main/performance_monitor.c \
 	$(SRCDIR)main/pixel.c \
 	$(SRCDIR)main/pixelstore.c \
 	$(SRCDIR)main/pixeltransfer.c \
diff --git a/mesalib/src/mesa/SConscript b/mesalib/src/mesa/SConscript
index 2cdb79c46..9b7712faf 100644
--- a/mesalib/src/mesa/SConscript
+++ b/mesalib/src/mesa/SConscript
@@ -97,6 +97,7 @@ main_sources = [
     'main/objectlabel.c',
     'main/pack.c',
     'main/pbo.c',
+    'main/performance_monitor.c',
     'main/pixel.c',
     'main/pixelstore.c',
     'main/pixeltransfer.c',
diff --git a/mesalib/src/mesa/drivers/dri/Android.mk b/mesalib/src/mesa/drivers/dri/Android.mk
index 88629531a..9adf0b386 100644
--- a/mesalib/src/mesa/drivers/dri/Android.mk
+++ b/mesalib/src/mesa/drivers/dri/Android.mk
@@ -32,9 +32,6 @@ MESA_DRI_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/dri
 MESA_DRI_MODULE_UNSTRIPPED_PATH := $(TARGET_OUT_SHARED_LIBRARIES_UNSTRIPPED)/dri
 
 MESA_DRI_CFLAGS := \
-	-DFEATURE_GL=1 \
-	-DFEATURE_ES1=1 \
-	-DFEATURE_ES2=1 \
 	-DHAVE_ANDROID_PLATFORM
 
 MESA_DRI_C_INCLUDES := \
diff --git a/mesalib/src/mesa/main/context.c b/mesalib/src/mesa/main/context.c
index 58f42cc5b..310518c92 100644
--- a/mesalib/src/mesa/main/context.c
+++ b/mesalib/src/mesa/main/context.c
@@ -105,6 +105,7 @@
 #include "macros.h"
 #include "matrix.h"
 #include "multisample.h"
+#include "performance_monitor.h"
 #include "pixel.h"
 #include "pixelstore.h"
 #include "points.h"
@@ -764,6 +765,7 @@ init_attrib_groups(struct gl_context *ctx)
    _mesa_init_lighting( ctx );
    _mesa_init_matrix( ctx );
    _mesa_init_multisample( ctx );
+   _mesa_init_performance_monitors( ctx );
    _mesa_init_pixel( ctx );
    _mesa_init_pixelstore( ctx );
    _mesa_init_point( ctx );
diff --git a/mesalib/src/mesa/main/core.h b/mesalib/src/mesa/main/core.h
index 0ba0db8a3..73ed01c25 100644
--- a/mesalib/src/mesa/main/core.h
+++ b/mesalib/src/mesa/main/core.h
@@ -31,8 +31,7 @@
  * The public header of core mesa.
  *
  * This file is the (only) public header of core mesa.  It is supposed to be
- * used by GLX, WGL, and GLSL.  It is important that headers directly or
- * indirectly included here do not perform feature tests (#if FEATURE_xxx).
+ * used by GLX, WGL, and GLSL.
  */
 
 
diff --git a/mesalib/src/mesa/main/dd.h b/mesalib/src/mesa/main/dd.h
index c1d9b2c95..0806e41a0 100644
--- a/mesalib/src/mesa/main/dd.h
+++ b/mesalib/src/mesa/main/dd.h
@@ -645,6 +645,30 @@ struct dd_function_table {
    void (*WaitQuery)(struct gl_context *ctx, struct gl_query_object *q);
    /*@}*/
 
+   /**
+    * \name Performance monitors
+    */
+   /*@{*/
+   struct gl_perf_monitor_object * (*NewPerfMonitor)(struct gl_context *ctx);
+   void (*DeletePerfMonitor)(struct gl_context *ctx,
+                             struct gl_perf_monitor_object *m);
+   GLboolean (*BeginPerfMonitor)(struct gl_context *ctx,
+                                 struct gl_perf_monitor_object *m);
+
+   /** Stop an active performance monitor, discarding results. */
+   void (*ResetPerfMonitor)(struct gl_context *ctx,
+                            struct gl_perf_monitor_object *m);
+   void (*EndPerfMonitor)(struct gl_context *ctx,
+                          struct gl_perf_monitor_object *m);
+   GLboolean (*IsPerfMonitorResultAvailable)(struct gl_context *ctx,
+                                             struct gl_perf_monitor_object *m);
+   void (*GetPerfMonitorResult)(struct gl_context *ctx,
+                                struct gl_perf_monitor_object *m,
+                                GLsizei dataSize,
+                                GLuint *data,
+                                GLint *bytesWritten);
+   /*@}*/
+
 
    /**
     * \name Vertex Array objects
diff --git a/mesalib/src/mesa/main/extensions.c b/mesalib/src/mesa/main/extensions.c
index 34615e3e0..eb9362059 100644
--- a/mesalib/src/mesa/main/extensions.c
+++ b/mesalib/src/mesa/main/extensions.c
@@ -291,6 +291,7 @@ static const struct extension extension_table[] = {
    { "GL_3DFX_texture_compression_FXT1",           o(TDFX_texture_compression_FXT1),           GL,             1999 },
    { "GL_AMD_conservative_depth",                  o(ARB_conservative_depth),                  GL,             2009 },
    { "GL_AMD_draw_buffers_blend",                  o(ARB_draw_buffers_blend),                  GL,             2009 },
+   { "GL_AMD_performance_monitor",                 o(AMD_performance_monitor),                 GL,             2007 },
    { "GL_AMD_seamless_cubemap_per_texture",        o(AMD_seamless_cubemap_per_texture),        GL,             2009 },
    { "GL_AMD_shader_stencil_export",               o(ARB_shader_stencil_export),               GL,             2009 },
    { "GL_AMD_vertex_shader_layer",                 o(AMD_vertex_shader_layer),                 GL,             2012 },
diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h
index 448946c03..d82672dc9 100644
--- a/mesalib/src/mesa/main/mtypes.h
+++ b/mesalib/src/mesa/main/mtypes.h
@@ -34,6 +34,8 @@
 #define MTYPES_H
 
 
+#include <stdint.h>             /* uint32_t */
+
 #include "main/glheader.h"
 #include "main/config.h"
 #include "glapi/glapi.h"
@@ -1778,6 +1780,89 @@ struct gl_transform_feedback_state
 
 
 /**
+ * A "performance monitor" as described in AMD_performance_monitor.
+ */
+struct gl_perf_monitor_object
+{
+   GLboolean Active;
+
+   /**
+    * A list of groups with currently active counters.
+    *
+    * ActiveGroups[g] == n if there are n counters active from group 'g'.
+    */
+   unsigned *ActiveGroups;
+
+   /**
+    * An array of bitsets, subscripted by group ID, then indexed by counter ID.
+    *
+    * Checking whether counter 'c' in group 'g' is active can be done via:
+    *
+    *    BITSET_TEST(ActiveCounters[g], c)
+    */
+   GLuint **ActiveCounters;
+};
+
+
+union gl_perf_monitor_counter_value
+{
+   float f;
+   uint64_t u64;
+   uint32_t u32;
+};
+
+
+struct gl_perf_monitor_counter
+{
+   /** Human readable name for the counter. */
+   const char *Name;
+
+   /**
+    * Data type of the counter.  Valid values are FLOAT, UNSIGNED_INT,
+    * UNSIGNED_INT64_AMD, and PERCENTAGE_AMD.
+    */
+   GLenum Type;
+
+   /** Minimum counter value. */
+   union gl_perf_monitor_counter_value Minimum;
+
+   /** Maximum counter value. */
+   union gl_perf_monitor_counter_value Maximum;
+};
+
+
+struct gl_perf_monitor_group
+{
+   /** Human readable name for the group. */
+   const char *Name;
+
+   /**
+    * Maximum number of counters in this group which can be active at the
+    * same time.
+    */
+   GLuint MaxActiveCounters;
+
+   /** Array of counters within this group. */
+   const struct gl_perf_monitor_counter *Counters;
+   GLuint NumCounters;
+};
+
+
+/**
+ * Context state for AMD_performance_monitor.
+ */
+struct gl_perf_monitor_state
+{
+   /** Array of performance monitor groups (indexed by group ID) */
+   const struct gl_perf_monitor_group *Groups;
+   GLuint NumGroups;
+
+   /** The table of all performance monitors. */
+   struct _mesa_HashTable *Monitors;
+};
+
+
+/**
  * Names of the various vertex/fragment program register files, etc.
  *
  * NOTE: first four tokens must fit into 2 bits (see t_vb_arbprogram.c)
@@ -3176,6 +3261,7 @@ struct gl_extensions
    GLboolean EXT_vertex_array_bgra;
    GLboolean OES_standard_derivatives;
    /* vendor extensions */
+   GLboolean AMD_performance_monitor;
    GLboolean AMD_seamless_cubemap_per_texture;
    GLboolean AMD_vertex_shader_layer;
    GLboolean APPLE_object_purgeable;
@@ -3639,6 +3725,8 @@ struct gl_context
 
    struct gl_transform_feedback_state TransformFeedback;
 
+   struct gl_perf_monitor_state PerfMonitor;
+
    struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */
    struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */
 
diff --git a/mesalib/src/mesa/main/performance_monitor.c b/mesalib/src/mesa/main/performance_monitor.c
new file mode 100644
index 000000000..8dfa8261e
--- /dev/null
+++ b/mesalib/src/mesa/main/performance_monitor.c
@@ -0,0 +1,609 @@
+/*
+ * Copyright © 2012 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.
+ */
+
+/**
+ * \file performance_monitor.c
+ * Core Mesa support for the AMD_performance_monitor extension.
+ *
+ * In order to implement this extension, start by defining two enums:
+ * one for Groups, and one for Counters.  These will be used as indexes into
+ * arrays, so they should start at 0 and increment from there.
+ *
+ * Counter IDs need to be globally unique.  That is, you can't have counter 7
+ * in group A and counter 7 in group B.  A global enum of all available
+ * counters is a convenient way to guarantee this.
+ */
+
+#include <stdbool.h>
+#include "glheader.h"
+#include "context.h"
+#include "enums.h"
+#include "hash.h"
+#include "macros.h"
+#include "mtypes.h"
+#include "performance_monitor.h"
+#include "bitset.h"
+#include "ralloc.h"
+
+void
+_mesa_init_performance_monitors(struct gl_context *ctx)
+{
+   ctx->PerfMonitor.Monitors = _mesa_NewHashTable();
+   ctx->PerfMonitor.NumGroups = 0;
+   ctx->PerfMonitor.Groups = NULL;
+}
+
+static struct gl_perf_monitor_object *
+new_performance_monitor(struct gl_context *ctx, GLuint index)
+{
+   unsigned i;
+   struct gl_perf_monitor_object *m = ctx->Driver.NewPerfMonitor(ctx);
+
+   if (m == NULL)
+      return NULL;
+
+   m->ActiveGroups =
+      rzalloc_array(NULL, unsigned, ctx->PerfMonitor.NumGroups);
+
+   m->ActiveCounters =
+      ralloc_array(NULL, BITSET_WORD *, ctx->PerfMonitor.NumGroups);
+
+   if (m->ActiveGroups == NULL || m->ActiveCounters == NULL)
+      goto fail;
+
+   for (i = 0; i < ctx->PerfMonitor.NumGroups; i++) {
+      const struct gl_perf_monitor_group *g = &ctx->PerfMonitor.Groups[i];
+
+      m->ActiveCounters[i] = rzalloc_array(m->ActiveCounters, BITSET_WORD,
+                                           BITSET_WORDS(g->NumCounters));
+      if (m->ActiveCounters[i] == NULL)
+         goto fail;
+   }
+
+   return m;
+
+fail:
+   ralloc_free(m->ActiveGroups);
+   ralloc_free(m->ActiveCounters);
+   ctx->Driver.DeletePerfMonitor(ctx, m);
+   return NULL;
+}
+
+static inline struct gl_perf_monitor_object *
+lookup_monitor(struct gl_context *ctx, GLuint id)
+{
+   return (struct gl_perf_monitor_object *)
+      _mesa_HashLookup(ctx->PerfMonitor.Monitors, id);
+}
+
+static inline const struct gl_perf_monitor_group *
+get_group(const struct gl_context *ctx, GLuint id)
+{
+   if (id >= ctx->PerfMonitor.NumGroups)
+      return NULL;
+
+   return &ctx->PerfMonitor.Groups[id];
+}
+
+static inline const struct gl_perf_monitor_counter *
+get_counter(const struct gl_perf_monitor_group *group_obj, GLuint id)
+{
+   if (id >= group_obj->NumCounters)
+      return NULL;
+
+   return &group_obj->Counters[id];
+}
+
+/*****************************************************************************/
+
+void GLAPIENTRY
+_mesa_GetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize,
+                              GLuint *groups)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (numGroups != NULL)
+      *numGroups = ctx->PerfMonitor.NumGroups;
+
+   if (groupsSize > 0 && groups != NULL) {
+      unsigned i;
+      unsigned n = MIN2(groupsSize, ctx->PerfMonitor.NumGroups);
+
+      /* We just use the index in the Groups array as the ID. */
+      for (i = 0; i < n; i++)
+         groups[i] = i;
+   }
+}
+
+void GLAPIENTRY
+_mesa_GetPerfMonitorCountersAMD(GLuint group, GLint *numCounters,
+                                GLint *maxActiveCounters,
+                                GLsizei countersSize, GLuint *counters)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const struct gl_perf_monitor_group *group_obj = get_group(ctx, group);
+   if (group_obj == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glGetPerfMonitorCountersAMD(invalid group)");
+      return;
+   }
+
+   if (maxActiveCounters != NULL)
+      *maxActiveCounters = group_obj->MaxActiveCounters;
+
+   if (numCounters != NULL)
+      *numCounters = group_obj->NumCounters;
+
+   if (counters != NULL) {
+      unsigned i;
+      unsigned n = MIN2(group_obj->NumCounters, countersSize);
+      for (i = 0; i < n; i++) {
+         /* We just use the index in the Counters array as the ID. */
+         counters[i] = i;
+      }
+   }
+}
+
+void GLAPIENTRY
+_mesa_GetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize,
+                                   GLsizei *length, GLchar *groupString)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   const struct gl_perf_monitor_group *group_obj = get_group(ctx, group);
+
+   if (group_obj == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetPerfMonitorGroupStringAMD");
+      return;
+   }
+
+   if (bufSize == 0) {
+      /* Return the number of characters that would be required to hold the
+       * group string, excluding the null terminator.
+       */
+      if (length != NULL)
+         *length = strlen(group_obj->Name);
+   } else {
+      if (length != NULL)
+         *length = MIN2(strlen(group_obj->Name), bufSize);
+      if (groupString != NULL)
+         strncpy(groupString, group_obj->Name, bufSize);
+   }
+}
+
+void GLAPIENTRY
+_mesa_GetPerfMonitorCounterStringAMD(GLuint group, GLuint counter,
+                                     GLsizei bufSize, GLsizei *length,
+                                     GLchar *counterString)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   const struct gl_perf_monitor_group *group_obj;
+   const struct gl_perf_monitor_counter *counter_obj;
+
+   group_obj = get_group(ctx, group);
+
+   if (group_obj == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glGetPerfMonitorCounterStringAMD(invalid group)");
+      return;
+   }
+
+   counter_obj = get_counter(group_obj, counter);
+
+   if (counter_obj == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glGetPerfMonitorCounterStringAMD(invalid counter)");
+      return;
+   }
+
+   if (bufSize == 0) {
+      /* Return the number of characters that would be required to hold the
+       * counter string, excluding the null terminator.
+       */
+      if (length != NULL)
+         *length = strlen(counter_obj->Name);
+   } else {
+      if (length != NULL)
+         *length = MIN2(strlen(counter_obj->Name), bufSize);
+      if (counterString != NULL)
+         strncpy(counterString, counter_obj->Name, bufSize);
+   }
+}
+
+void GLAPIENTRY
+_mesa_GetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname,
+                                   GLvoid *data)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   const struct gl_perf_monitor_group *group_obj;
+   const struct gl_perf_monitor_counter *counter_obj;
+
+   group_obj = get_group(ctx, group);
+
+   if (group_obj == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glGetPerfMonitorCounterInfoAMD(invalid group)");
+      return;
+   }
+
+   counter_obj = get_counter(group_obj, counter);
+
+   if (counter_obj == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glGetPerfMonitorCounterInfoAMD(invalid counter)");
+      return;
+   }
+
+   switch (pname) {
+   case GL_COUNTER_TYPE_AMD:
+      *((GLenum *) data) = counter_obj->Type;
+      break;
+
+   case GL_COUNTER_RANGE_AMD:
+      switch (counter_obj->Type) {
+      case GL_FLOAT:
+      case GL_PERCENTAGE_AMD: {
+         float *f_data = data;
+         f_data[0] = counter_obj->Minimum.f;
+         f_data[1] = counter_obj->Maximum.f;
+         break;
+      }
+      case GL_UNSIGNED_INT: {
+         uint32_t *u32_data = data;
+         u32_data[0] = counter_obj->Minimum.u32;
+         u32_data[1] = counter_obj->Maximum.u32;
+         break;
+      }
+      case GL_UNSIGNED_INT64_AMD: {
+         uint64_t *u64_data = data;
+         u64_data[0] = counter_obj->Minimum.u64;
+         u64_data[1] = counter_obj->Maximum.u64;
+         break;
+      }
+      default:
+         assert(!"Should not get here: invalid counter type");
+      }
+      break;
+
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glGetPerfMonitorCounterInfoAMD(pname)");
+      return;
+   }
+}
+
+void GLAPIENTRY
+_mesa_GenPerfMonitorsAMD(GLsizei n, GLuint *monitors)
+{
+   GLuint first;
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glGenPerfMonitorsAMD(%d)\n", n);
+
+   if (n < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGenPerfMonitorsAMD(n < 0)");
+      return;
+   }
+
+   if (monitors == NULL)
+      return;
+
+   /* We don't actually need them to be contiguous, but this is what
+    * the rest of Mesa does, so we may as well.
+    */
+   first = _mesa_HashFindFreeKeyBlock(ctx->PerfMonitor.Monitors, n);
+   if (first) {
+      GLsizei i;
+      for (i = 0; i < n; i++) {
+         struct gl_perf_monitor_object *m =
+            new_performance_monitor(ctx, first + i);
+         if (!m) {
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenPerfMonitorsAMD");
+            return;
+         }
+         monitors[i] = first + i;
+         _mesa_HashInsert(ctx->PerfMonitor.Monitors, first + i, m);
+      }
+   } else {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenPerfMonitorsAMD");
+      return;
+   }
+}
+
+void GLAPIENTRY
+_mesa_DeletePerfMonitorsAMD(GLsizei n, GLuint *monitors)
+{
+   GLint i;
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glDeletePerfMonitorsAMD(%d)\n", n);
+
+   if (n < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glDeletePerfMonitorsAMD(n < 0)");
+      return;
+   }
+
+   if (monitors == NULL)
+      return;
+
+   for (i = 0; i < n; i++) {
+      struct gl_perf_monitor_object *m = lookup_monitor(ctx, monitors[i]);
+
+      if (m) {
+         /* Give the driver a chance to stop the monitor if it's active. */
+         if (m->Active)
+            ctx->Driver.ResetPerfMonitor(ctx, m);
+
+         _mesa_HashRemove(ctx->PerfMonitor.Monitors, monitors[i]);
+         ralloc_free(m->ActiveGroups);
+         ralloc_free(m->ActiveCounters);
+         ctx->Driver.DeletePerfMonitor(ctx, m);
+      } else {
+         /* "INVALID_VALUE error will be generated if any of the monitor IDs
+          *  in the <monitors> parameter to DeletePerfMonitorsAMD do not
+          *  reference a valid generated monitor ID."
+          */
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glDeletePerfMonitorsAMD(invalid monitor)");
+      }
+   }
+}
+
+void GLAPIENTRY
+_mesa_SelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable,
+                                   GLuint group, GLint numCounters,
+                                   GLuint *counterList)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   unsigned i;
+   struct gl_perf_monitor_object *m;
+   const struct gl_perf_monitor_group *group_obj;
+
+   m = lookup_monitor(ctx, monitor);
+
+   /* "INVALID_VALUE error will be generated if the <monitor> parameter to
+    *  SelectPerfMonitorCountersAMD does not reference a monitor created by
+    *  GenPerfMonitorsAMD."
+    */
+   if (m == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glSelectPerfMonitorCountersAMD(invalid monitor)");
+      return;
+   }
+
+   group_obj = get_group(ctx, group);
+
+   /* "INVALID_VALUE error will be generated if the <group> parameter to
+    *  GetPerfMonitorCountersAMD, GetPerfMonitorCounterStringAMD,
+    *  GetPerfMonitorCounterStringAMD, GetPerfMonitorCounterInfoAMD, or
+    *  SelectPerfMonitorCountersAMD does not reference a valid group ID."
+    */
+   if (group_obj == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glSelectPerfMonitorCountersAMD(invalid group)");
+      return;
+   }
+
+   /* "INVALID_VALUE error will be generated if the <numCounters> parameter to
+    *  SelectPerfMonitorCountersAMD is less than 0."
+    */
+   if (numCounters < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glSelectPerfMonitorCountersAMD(numCounters < 0)");
+      return;
+   }
+
+   /* "When SelectPerfMonitorCountersAMD is called on a monitor, any outstanding
+    *  results for that monitor become invalidated and the result queries
+    *  PERFMON_RESULT_SIZE_AMD and PERFMON_RESULT_AVAILABLE_AMD are reset to 0."
+    */
+   ctx->Driver.ResetPerfMonitor(ctx, m);
+
+   /* Sanity check the counter ID list. */
+   for (i = 0; i < numCounters; i++) {
+      if (counterList[i] >= group_obj->NumCounters) {
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glSelectPerfMonitorCountersAMD(invalid counter ID)");
+         return;
+      }
+   }
+
+   if (enable) {
+      /* Enable the counters */
+      for (i = 0; i < numCounters; i++) {
+         ++m->ActiveGroups[group];
+         BITSET_SET(m->ActiveCounters[group], counterList[i]);
+      }
+   } else {
+      /* Disable the counters */
+      for (i = 0; i < numCounters; i++) {
+         --m->ActiveGroups[group];
+         BITSET_CLEAR(m->ActiveCounters[group], counterList[i]);
+      }
+   }
+}
+
+void GLAPIENTRY
+_mesa_BeginPerfMonitorAMD(GLuint monitor)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   struct gl_perf_monitor_object *m = lookup_monitor(ctx, monitor);
+
+   if (m == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glBeginPerfMonitorAMD(invalid monitor)");
+      return;
+   }
+
+   /* "INVALID_OPERATION error will be generated if BeginPerfMonitorAMD is
+    *  called when a performance monitor is already active."
+    */
+   if (m->Active) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glBeginPerfMonitor(already active)");
+      return;
+   }
+
+   /* The driver is free to return false if it can't begin monitoring for
+    * any reason.  This translates into an INVALID_OPERATION error.
+    */
+   if (ctx->Driver.BeginPerfMonitor(ctx, m)) {
+      m->Active = true;
+   } else {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glBeginPerfMonitor(driver unable to begin monitoring)");
+   }
+}
+
+void GLAPIENTRY
+_mesa_EndPerfMonitorAMD(GLuint monitor)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   struct gl_perf_monitor_object *m = lookup_monitor(ctx, monitor);
+
+   if (m == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glEndPerfMonitorAMD(invalid monitor)");
+      return;
+   }
+
+   /* "INVALID_OPERATION error will be generated if EndPerfMonitorAMD is called
+    *  when a performance monitor is not currently started."
+    */
+   if (!m->Active) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glBeginPerfMonitor(not active)");
+      return;
+   }
+
+   ctx->Driver.EndPerfMonitor(ctx, m);
+
+   m->Active = false;
+}
+
+/**
+ * Return the number of bytes needed to store a monitor's result.
+ */
+static unsigned
+perf_monitor_result_size(const struct gl_context *ctx,
+                         const struct gl_perf_monitor_object *m)
+{
+   unsigned group, counter;
+   unsigned size = 0;
+
+   for (group = 0; group < ctx->PerfMonitor.NumGroups; group++) {
+      const struct gl_perf_monitor_group *g = &ctx->PerfMonitor.Groups[group];
+      for (counter = 0; counter < g->NumCounters; counter++) {
+         const struct gl_perf_monitor_counter *c = &g->Counters[counter];
+
+         if (!BITSET_TEST(m->ActiveCounters[group], counter))
+            continue;
+
+         size += sizeof(uint32_t); /* Group ID */
+         size += sizeof(uint32_t); /* Counter ID */
+         size += _mesa_perf_monitor_counter_size(c);
+      }
+   }
+   return size;
+}
+
+void GLAPIENTRY
+_mesa_GetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname,
+                                   GLsizei dataSize, GLuint *data,
+                                   GLint *bytesWritten)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   struct gl_perf_monitor_object *m = lookup_monitor(ctx, monitor);
+
+   if (m == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glGetPerfMonitorCounterDataAMD(invalid monitor)");
+      return;
+   }
+
+   /* "It is an INVALID_OPERATION error for <data> to be NULL." */
+   if (data == NULL) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glGetPerfMonitorCounterDataAMD(data == NULL)");
+      return;
+   }
+
+   /* We need at least enough room for a single value. */
+   if (dataSize < sizeof(GLuint)) {
+      if (bytesWritten != NULL)
+         *bytesWritten = 0;
+      return;
+   }
+
+   /* AMD appears to return 0 for all queries unless a result is available. */
+   if (!ctx->Driver.IsPerfMonitorResultAvailable(ctx, m)) {
+      *data = 0;
+      if (bytesWritten != NULL)
+         *bytesWritten = sizeof(GLuint);
+      return;
+   }
+
+   switch (pname) {
+   case GL_PERFMON_RESULT_AVAILABLE_AMD:
+      *data = 1;
+      if (bytesWritten != NULL)
+         *bytesWritten = sizeof(GLuint);
+      break;
+   case GL_PERFMON_RESULT_SIZE_AMD:
+      *data = perf_monitor_result_size(ctx, m);
+      if (bytesWritten != NULL)
+         *bytesWritten = sizeof(GLuint);
+      break;
+   case GL_PERFMON_RESULT_AMD:
+      ctx->Driver.GetPerfMonitorResult(ctx, m, dataSize, data, bytesWritten);
+      break;
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glGetPerfMonitorCounterDataAMD(pname)");
+   }
+}
+
+/**
+ * Returns how many bytes a counter's value takes up.
+ */
+unsigned
+_mesa_perf_monitor_counter_size(const struct gl_perf_monitor_counter *c)
+{
+   switch (c->Type) {
+   case GL_FLOAT:
+   case GL_PERCENTAGE_AMD:
+      return sizeof(GLfloat);
+   case GL_UNSIGNED_INT:
+      return sizeof(GLuint);
+   case GL_UNSIGNED_INT64_AMD:
+      return sizeof(uint64_t);
+   default:
+      assert(!"Should not get here: invalid counter type");
+      return 0;
+   }
+}
diff --git a/mesalib/src/mesa/main/performance_monitor.h b/mesalib/src/mesa/main/performance_monitor.h
new file mode 100644
index 000000000..a852a4184
--- /dev/null
+++ b/mesalib/src/mesa/main/performance_monitor.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2012 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.
+ */
+
+/**
+ * \file performance_monitor.h
+ * Core Mesa support for the AMD_performance_monitor extension.
+ */
+
+#pragma once
+#ifndef PERFORMANCE_MONITOR_H
+#define PERFORMANCE_MONITOR_H
+
+#include "glheader.h"
+
+extern void
+_mesa_init_performance_monitors(struct gl_context *ctx);
+
+extern void GLAPIENTRY
+_mesa_GetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize,
+                              GLuint *groups);
+
+extern void GLAPIENTRY
+_mesa_GetPerfMonitorCountersAMD(GLuint group, GLint *numCounters,
+                                GLint *maxActiveCounters,
+                                GLsizei countersSize, GLuint *counters);
+
+extern void GLAPIENTRY
+_mesa_GetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize,
+                                   GLsizei *length, GLchar *groupString);
+
+extern void GLAPIENTRY
+_mesa_GetPerfMonitorCounterStringAMD(GLuint group, GLuint counter,
+                                     GLsizei bufSize, GLsizei *length,
+                                     GLchar *counterString);
+
+extern void GLAPIENTRY
+_mesa_GetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname,
+                                   GLvoid *data);
+
+extern void GLAPIENTRY
+_mesa_GenPerfMonitorsAMD(GLsizei n, GLuint *monitors);
+
+extern void GLAPIENTRY
+_mesa_DeletePerfMonitorsAMD(GLsizei n, GLuint *monitors);
+
+extern void GLAPIENTRY
+_mesa_SelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable,
+                                   GLuint group, GLint numCounters,
+                                   GLuint *counterList);
+
+extern void GLAPIENTRY
+_mesa_BeginPerfMonitorAMD(GLuint monitor);
+
+extern void GLAPIENTRY
+_mesa_EndPerfMonitorAMD(GLuint monitor);
+
+extern void GLAPIENTRY
+_mesa_GetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname,
+                                   GLsizei dataSize, GLuint *data,
+                                   GLint *bytesWritten);
+
+unsigned
+_mesa_perf_monitor_counter_size(const struct gl_perf_monitor_counter *);
+
+#endif
diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c
index c1261138d..e6cae0034 100644
--- a/mesalib/src/mesa/main/teximage.c
+++ b/mesalib/src/mesa/main/teximage.c
@@ -3179,7 +3179,7 @@ teximage(struct gl_context *ctx, GLboolean compressed, GLuint dims,
 
             _mesa_update_fbo_texture(ctx, texObj, face, level);
 
-            _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
+            _mesa_dirty_texobj(ctx, texObj);
          }
       }
       _mesa_unlock_texture(ctx, texObj);
@@ -3298,7 +3298,7 @@ _mesa_EGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image)
       ctx->Driver.EGLImageTargetTexture2D(ctx, target,
 					  texObj, texImage, image);
 
-      _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
+      _mesa_dirty_texobj(ctx, texObj);
    }
    _mesa_unlock_texture(ctx, texObj);
 
@@ -3569,7 +3569,7 @@ copyteximage(struct gl_context *ctx, GLuint dims,
 
          _mesa_update_fbo_texture(ctx, texObj, face, level);
 
-         _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
+         _mesa_dirty_texobj(ctx, texObj);
       }
    }
    _mesa_unlock_texture(ctx, texObj);
diff --git a/mesalib/src/mesa/main/texobj.c b/mesalib/src/mesa/main/texobj.c
index cc2c786bb..abd30c563 100644
--- a/mesalib/src/mesa/main/texobj.c
+++ b/mesalib/src/mesa/main/texobj.c
@@ -715,20 +715,17 @@ _mesa_cube_complete(const struct gl_texture_object *texObj)
 
 /**
  * Mark a texture object dirty.  It forces the object to be incomplete
- * and optionally forces the context to re-validate its state.
+ * and forces the context to re-validate its state.
  *
  * \param ctx GL context.
  * \param texObj texture object.
- * \param invalidate_state also invalidate context state.
  */
 void
-_mesa_dirty_texobj(struct gl_context *ctx, struct gl_texture_object *texObj,
-                   GLboolean invalidate_state)
+_mesa_dirty_texobj(struct gl_context *ctx, struct gl_texture_object *texObj)
 {
    texObj->_BaseComplete = GL_FALSE;
    texObj->_MipmapComplete = GL_FALSE;
-   if (invalidate_state)
-      ctx->NewState |= _NEW_TEXTURE;
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
diff --git a/mesalib/src/mesa/main/texobj.h b/mesalib/src/mesa/main/texobj.h
index 0df088ce4..55091a642 100644
--- a/mesalib/src/mesa/main/texobj.h
+++ b/mesalib/src/mesa/main/texobj.h
@@ -126,8 +126,7 @@ extern GLboolean
 _mesa_cube_complete(const struct gl_texture_object *texObj);
 
 extern void
-_mesa_dirty_texobj(struct gl_context *ctx, struct gl_texture_object *texObj,
-                   GLboolean invalidate_state);
+_mesa_dirty_texobj(struct gl_context *ctx, struct gl_texture_object *texObj);
 
 extern struct gl_texture_object *
 _mesa_get_fallback_texture(struct gl_context *ctx, gl_texture_index tex);
diff --git a/mesalib/src/mesa/main/texparam.c b/mesalib/src/mesa/main/texparam.c
index 757ae80ec..31723c377 100644
--- a/mesalib/src/mesa/main/texparam.c
+++ b/mesalib/src/mesa/main/texparam.c
@@ -256,7 +256,7 @@ static inline void
 incomplete(struct gl_context *ctx, struct gl_texture_object *texObj)
 {
    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
+   _mesa_dirty_texobj(ctx, texObj);
 }
 
 
diff --git a/mesalib/src/mesa/program/Android.mk b/mesalib/src/mesa/program/Android.mk
index 3f974ea27..29a1b6a63 100644
--- a/mesalib/src/mesa/program/Android.mk
+++ b/mesalib/src/mesa/program/Android.mk
@@ -71,9 +71,6 @@ $(intermediates)/program/program_parse.tab.h: $(intermediates)/program/program_p
 $(intermediates)/program/lex.yy.c: $(LOCAL_PATH)/program_lexer.l
 	$(local-l-to-c)
 
-LOCAL_CFLAGS := \
-	$(patsubst %,-DFEATURE_%=1,$(MESA_ENABLED_APIS))
-
 LOCAL_C_INCLUDES := \
 	$(intermediates) \
 	$(MESA_TOP)/src/mapi \
diff --git a/mesalib/src/mesa/state_tracker/st_cb_eglimage.c b/mesalib/src/mesa/state_tracker/st_cb_eglimage.c
index b871cdd19..7484cb4f1 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_eglimage.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_eglimage.c
@@ -132,7 +132,7 @@ st_bind_surface(struct gl_context *ctx, GLenum target,
    stObj->depth0 = 1;
    stObj->surface_format = ps->format;
 
-   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
+   _mesa_dirty_texobj(ctx, texObj);
 }
 
 static void
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 271cf0523..53838b391 100644
--- a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
+++ b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
@@ -1944,6 +1944,14 @@ glsl_to_tgsi_visitor::visit(ir_expression *ir)
       /* note: we have to reorder the three args here */
       emit(ir, TGSI_OPCODE_LRP, result_dst, op[2], op[1], op[0]);
       break;
+   case ir_triop_csel:
+      if (this->ctx->Const.NativeIntegers)
+         emit(ir, TGSI_OPCODE_UCMP, result_dst, op[0], op[1], op[2]);
+      else {
+         op[0].negate = ~op[0].negate;
+         emit(ir, TGSI_OPCODE_CMP, result_dst, op[0], op[1], op[2]);
+      }
+      break;
    case ir_unop_pack_snorm_2x16:
    case ir_unop_pack_unorm_2x16:
    case ir_unop_pack_half_2x16:
@@ -1970,7 +1978,6 @@ glsl_to_tgsi_visitor::visit(ir_expression *ir)
    case ir_binop_vector_extract:
    case ir_triop_vector_insert:
    case ir_binop_ldexp:
-   case ir_triop_csel:
       /* This operation is not supported, or should have already been handled.
        */
       assert(!"Invalid ir opcode in glsl_to_tgsi_visitor::visit()");
diff --git a/mesalib/src/mesa/state_tracker/st_manager.c b/mesalib/src/mesa/state_tracker/st_manager.c
index b1fd91a0e..8158450dc 100644
--- a/mesalib/src/mesa/state_tracker/st_manager.c
+++ b/mesalib/src/mesa/state_tracker/st_manager.c
@@ -545,7 +545,7 @@ st_context_teximage(struct st_context_iface *stctxi,
    stObj->depth0 = depth;
    stObj->surface_format = pipe_format;
 
-   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
+   _mesa_dirty_texobj(ctx, texObj);
    _mesa_unlock_texture(ctx, texObj);
    
    return TRUE;