X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Ftrace%2Ftr_context.c;h=551c3facb6492a42d2c65904af2761c2406cbc47;hb=9dd596c99f009258b964704f53ab97458a1ef733;hp=4db7619c4248b0eeb7bb9f2789ebaca1171ea181;hpb=7e02303497237cde958c28608477d0c355a8038b;p=mesa.git

diff --git a/src/gallium/drivers/trace/tr_context.c b/src/gallium/drivers/trace/tr_context.c
index 4db7619c424..551c3facb64 100644
--- a/src/gallium/drivers/trace/tr_context.c
+++ b/src/gallium/drivers/trace/tr_context.c
@@ -1,6 +1,6 @@
 /**************************************************************************
  *
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * Copyright 2008 VMware, Inc.
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -18,7 +18,7 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -33,6 +33,7 @@
 #include "pipe/p_screen.h"
 
 #include "tr_dump.h"
+#include "tr_dump_defines.h"
 #include "tr_dump_state.h"
 #include "tr_public.h"
 #include "tr_screen.h"
@@ -40,22 +41,44 @@
 #include "tr_context.h"
 
 
+struct trace_query
+{
+   unsigned type;
+
+   struct pipe_query *query;
+};
 
 
+static INLINE struct trace_query *
+trace_query(struct pipe_query *query) {
+   return (struct trace_query *)query;
+}
+
+
+static INLINE struct pipe_query *
+trace_query_unwrap(struct pipe_query *query)
+{
+   if (query) {
+      return trace_query(query)->query;
+   } else {
+      return NULL;
+   }
+}
+
 
 static INLINE struct pipe_resource *
 trace_resource_unwrap(struct trace_context *tr_ctx,
                      struct pipe_resource *resource)
 {
-   struct trace_resource *tr_tex;
+   struct trace_resource *tr_res;
 
    if(!resource)
       return NULL;
 
-   tr_tex = trace_resource(resource);
+   tr_res = trace_resource(resource);
 
-   assert(tr_tex->resource);
-   return tr_tex->resource;
+   assert(tr_res->resource);
+   return tr_res->resource;
 }
 
 
@@ -94,6 +117,8 @@ trace_context_draw_vbo(struct pipe_context *_pipe,
    trace_dump_arg(ptr,  pipe);
    trace_dump_arg(draw_info, info);
 
+   trace_dump_trace_flush();
+
    pipe->draw_vbo(pipe, info);
 
    trace_dump_call_end();
@@ -102,33 +127,52 @@ trace_context_draw_vbo(struct pipe_context *_pipe,
 
 static INLINE struct pipe_query *
 trace_context_create_query(struct pipe_context *_pipe,
-                           unsigned query_type)
+                           unsigned query_type,
+                           unsigned index)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_query *result;
+   struct pipe_query *query;
 
    trace_dump_call_begin("pipe_context", "create_query");
 
    trace_dump_arg(ptr, pipe);
-   trace_dump_arg(uint, query_type);
+   trace_dump_arg(query_type, query_type);
+   trace_dump_arg(int, index);
 
-   result = pipe->create_query(pipe, query_type);
+   query = pipe->create_query(pipe, query_type, index);
 
-   trace_dump_ret(ptr, result);
+   trace_dump_ret(ptr, query);
 
    trace_dump_call_end();
 
-   return result;
+   /* Wrap query object. */
+   if (query) {
+      struct trace_query *tr_query = CALLOC_STRUCT(trace_query);
+      if (tr_query) {
+         tr_query->type = query_type;
+         tr_query->query = query;
+         query = (struct pipe_query *)tr_query;
+      } else {
+         pipe->destroy_query(pipe, query);
+         query = NULL;
+      }
+   }
+
+   return query;
 }
 
 
 static INLINE void
 trace_context_destroy_query(struct pipe_context *_pipe,
-                            struct pipe_query *query)
+                            struct pipe_query *_query)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
+   struct trace_query *tr_query = trace_query(_query);
+   struct pipe_query *query = tr_query->query;
+
+   FREE(tr_query);
 
    trace_dump_call_begin("pipe_context", "destroy_query");
 
@@ -148,6 +192,8 @@ trace_context_begin_query(struct pipe_context *_pipe,
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
 
+   query = trace_query_unwrap(query);
+
    trace_dump_call_begin("pipe_context", "begin_query");
 
    trace_dump_arg(ptr, pipe);
@@ -166,6 +212,8 @@ trace_context_end_query(struct pipe_context *_pipe,
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
 
+   query = trace_query_unwrap(query);
+
    trace_dump_call_begin("pipe_context", "end_query");
 
    trace_dump_arg(ptr, pipe);
@@ -179,28 +227,36 @@ trace_context_end_query(struct pipe_context *_pipe,
 
 static INLINE boolean
 trace_context_get_query_result(struct pipe_context *_pipe,
-                               struct pipe_query *query,
+                               struct pipe_query *_query,
                                boolean wait,
-                               void *presult)
+                               union pipe_query_result *result)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
-   uint64_t result;
-   boolean _result;
+   struct trace_query *tr_query = trace_query(_query);
+   struct pipe_query *query = tr_query->query;
+   boolean ret;
 
    trace_dump_call_begin("pipe_context", "get_query_result");
 
    trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, query);
+
+   ret = pipe->get_query_result(pipe, query, wait, result);
 
-   _result = pipe->get_query_result(pipe, query, wait, presult);
-   result = *((uint64_t*)presult);
+   trace_dump_arg_begin("result");
+   if (ret) {
+      trace_dump_query_result(tr_query->type, result);
+   } else {
+      trace_dump_null();
+   }
+   trace_dump_arg_end();
 
-   trace_dump_arg(uint, result);
-   trace_dump_ret(bool, _result);
+   trace_dump_ret(bool, ret);
 
    trace_dump_call_end();
 
-   return _result;
+   return ret;
 }
 
 
@@ -287,43 +343,27 @@ trace_context_create_sampler_state(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe,
-                                           unsigned num_states,
-                                           void **states)
-{
-   struct trace_context *tr_ctx = trace_context(_pipe);
-   struct pipe_context *pipe = tr_ctx->pipe;
-
-   trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states");
-
-   trace_dump_arg(ptr, pipe);
-   trace_dump_arg(uint, num_states);
-   trace_dump_arg_array(ptr, states, num_states);
-
-   pipe->bind_fragment_sampler_states(pipe, num_states, states);
-
-   trace_dump_call_end();
-}
-
-
-static INLINE void
-trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe,
-                                         unsigned num_states,
-                                         void **states)
+trace_context_bind_sampler_states(struct pipe_context *_pipe,
+                                  unsigned shader,
+                                  unsigned start,
+                                  unsigned num_states,
+                                  void **states)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   if (!pipe->bind_vertex_sampler_states)
-      return;
+   /* remove this when we have pipe->bind_sampler_states(..., start, ...) */
+   assert(start == 0);
 
-   trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
+   trace_dump_call_begin("pipe_context", "bind_sampler_states");
 
    trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, shader);
+   trace_dump_arg(uint, start);
    trace_dump_arg(uint, num_states);
    trace_dump_arg_array(ptr, states, num_states);
 
-   pipe->bind_vertex_sampler_states(pipe, num_states, states);
+   pipe->bind_sampler_states(pipe, shader, start, num_states, states);
 
    trace_dump_call_end();
 }
@@ -465,122 +505,54 @@ trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
 }
 
 
-static INLINE void *
-trace_context_create_fs_state(struct pipe_context *_pipe,
-                              const struct pipe_shader_state *state)
-{
-   struct trace_context *tr_ctx = trace_context(_pipe);
-   struct pipe_context *pipe = tr_ctx->pipe;
-   void * result;
-
-   trace_dump_call_begin("pipe_context", "create_fs_state");
-
-   trace_dump_arg(ptr, pipe);
-   trace_dump_arg(shader_state, state);
-
-   result = pipe->create_fs_state(pipe, state);
-
-   trace_dump_ret(ptr, result);
-
-   trace_dump_call_end();
-
-   return result;
-}
-
-
-static INLINE void
-trace_context_bind_fs_state(struct pipe_context *_pipe,
-                            void *state)
-{
-   struct trace_context *tr_ctx = trace_context(_pipe);
-   struct pipe_context *pipe = tr_ctx->pipe;
-
-   trace_dump_call_begin("pipe_context", "bind_fs_state");
-
-   trace_dump_arg(ptr, pipe);
-   trace_dump_arg(ptr, state);
-
-   pipe->bind_fs_state(pipe, state);
-
-   trace_dump_call_end();
-}
-
-
-static INLINE void
-trace_context_delete_fs_state(struct pipe_context *_pipe,
-                              void *state)
-{
-   struct trace_context *tr_ctx = trace_context(_pipe);
-   struct pipe_context *pipe = tr_ctx->pipe;
-
-   trace_dump_call_begin("pipe_context", "delete_fs_state");
-
-   trace_dump_arg(ptr, pipe);
-   trace_dump_arg(ptr, state);
-
-   pipe->delete_fs_state(pipe, state);
-
-   trace_dump_call_end();
-}
-
-
-static INLINE void *
-trace_context_create_vs_state(struct pipe_context *_pipe,
-                              const struct pipe_shader_state *state)
-{
-   struct trace_context *tr_ctx = trace_context(_pipe);
-   struct pipe_context *pipe = tr_ctx->pipe;
-   void * result;
-
-   trace_dump_call_begin("pipe_context", "create_vs_state");
-
-   trace_dump_arg(ptr, pipe);
-   trace_dump_arg(shader_state, state);
-
-   result = pipe->create_vs_state(pipe, state);
-
-   trace_dump_ret(ptr, result);
-
-   trace_dump_call_end();
-
-   return result;
-}
-
-
-static INLINE void
-trace_context_bind_vs_state(struct pipe_context *_pipe,
-                            void *state)
-{
-   struct trace_context *tr_ctx = trace_context(_pipe);
-   struct pipe_context *pipe = tr_ctx->pipe;
-
-   trace_dump_call_begin("pipe_context", "bind_vs_state");
-
-   trace_dump_arg(ptr, pipe);
-   trace_dump_arg(ptr, state);
-
-   pipe->bind_vs_state(pipe, state);
-
-   trace_dump_call_end();
-}
-
-
-static INLINE void
-trace_context_delete_vs_state(struct pipe_context *_pipe,
-                              void *state)
-{
-   struct trace_context *tr_ctx = trace_context(_pipe);
-   struct pipe_context *pipe = tr_ctx->pipe;
-
-   trace_dump_call_begin("pipe_context", "delete_vs_state");
-
-   trace_dump_arg(ptr, pipe);
-   trace_dump_arg(ptr, state);
+#define TRACE_SHADER_STATE(shader_type) \
+   static INLINE void * \
+   trace_context_create_##shader_type##_state(struct pipe_context *_pipe, \
+                                 const struct pipe_shader_state *state) \
+   { \
+      struct trace_context *tr_ctx = trace_context(_pipe); \
+      struct pipe_context *pipe = tr_ctx->pipe; \
+      void * result; \
+      trace_dump_call_begin("pipe_context", "create_" #shader_type "_state"); \
+      trace_dump_arg(ptr, pipe); \
+      trace_dump_arg(shader_state, state); \
+      result = pipe->create_##shader_type##_state(pipe, state); \
+      trace_dump_ret(ptr, result); \
+      trace_dump_call_end(); \
+      return result; \
+   } \
+    \
+   static INLINE void \
+   trace_context_bind_##shader_type##_state(struct pipe_context *_pipe, \
+                               void *state) \
+   { \
+      struct trace_context *tr_ctx = trace_context(_pipe); \
+      struct pipe_context *pipe = tr_ctx->pipe; \
+      trace_dump_call_begin("pipe_context", "bind_" #shader_type "_state"); \
+      trace_dump_arg(ptr, pipe); \
+      trace_dump_arg(ptr, state); \
+      pipe->bind_##shader_type##_state(pipe, state); \
+      trace_dump_call_end(); \
+   } \
+    \
+   static INLINE void \
+   trace_context_delete_##shader_type##_state(struct pipe_context *_pipe, \
+                                 void *state) \
+   { \
+      struct trace_context *tr_ctx = trace_context(_pipe); \
+      struct pipe_context *pipe = tr_ctx->pipe; \
+      trace_dump_call_begin("pipe_context", "delete_" #shader_type "_state"); \
+      trace_dump_arg(ptr, pipe); \
+      trace_dump_arg(ptr, state); \
+      pipe->delete_##shader_type##_state(pipe, state); \
+      trace_dump_call_end(); \
+   }
 
-   pipe->delete_vs_state(pipe, state);
+TRACE_SHADER_STATE(fs)
+TRACE_SHADER_STATE(vs)
+TRACE_SHADER_STATE(gs)
 
-   trace_dump_call_end();
-}
+#undef TRACE_SHADER_STATE
 
 
 static INLINE void *
@@ -720,13 +692,16 @@ trace_context_set_sample_mask(struct pipe_context *_pipe,
 static INLINE void
 trace_context_set_constant_buffer(struct pipe_context *_pipe,
                                   uint shader, uint index,
-                                  struct pipe_resource *buffer)
+                                  struct pipe_constant_buffer *constant_buffer)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
+   struct pipe_constant_buffer cb;
 
-   if (buffer) {
-      buffer = trace_resource_unwrap(tr_ctx, buffer);
+   if (constant_buffer) {
+      cb = *constant_buffer;
+      cb.buffer = trace_resource_unwrap(tr_ctx, constant_buffer->buffer);
+      constant_buffer = &cb;
    }
 
    trace_dump_call_begin("pipe_context", "set_constant_buffer");
@@ -734,9 +709,9 @@ trace_context_set_constant_buffer(struct pipe_context *_pipe,
    trace_dump_arg(ptr, pipe);
    trace_dump_arg(uint, shader);
    trace_dump_arg(uint, index);
-   trace_dump_arg(ptr, buffer);
+   trace_dump_arg(constant_buffer, constant_buffer);
 
-   pipe->set_constant_buffer(pipe, shader, index, buffer);
+   pipe->set_constant_buffer(pipe, shader, index, constant_buffer);
 
    trace_dump_call_end();
 }
@@ -791,60 +766,71 @@ trace_context_set_polygon_stipple(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_set_scissor_state(struct pipe_context *_pipe,
-                                const struct pipe_scissor_state *state)
+trace_context_set_scissor_states(struct pipe_context *_pipe,
+                                 unsigned start_slot,
+                                 unsigned num_scissors,
+                                 const struct pipe_scissor_state *states)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin("pipe_context", "set_scissor_state");
+   trace_dump_call_begin("pipe_context", "set_scissor_states");
 
    trace_dump_arg(ptr, pipe);
-   trace_dump_arg(scissor_state, state);
+   trace_dump_arg(uint, start_slot);
+   trace_dump_arg(uint, num_scissors);
+   trace_dump_arg(scissor_state, states);
 
-   pipe->set_scissor_state(pipe, state);
+   pipe->set_scissor_states(pipe, start_slot, num_scissors, states);
 
    trace_dump_call_end();
 }
 
 
 static INLINE void
-trace_context_set_viewport_state(struct pipe_context *_pipe,
-                                 const struct pipe_viewport_state *state)
+trace_context_set_viewport_states(struct pipe_context *_pipe,
+                                  unsigned start_slot,
+                                  unsigned num_viewports,
+                                  const struct pipe_viewport_state *states)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_dump_call_begin("pipe_context", "set_viewport_state");
+   trace_dump_call_begin("pipe_context", "set_viewport_states");
 
    trace_dump_arg(ptr, pipe);
-   trace_dump_arg(viewport_state, state);
+   trace_dump_arg(uint, start_slot);
+   trace_dump_arg(uint, num_viewports);
+   trace_dump_arg(viewport_state, states);
 
-   pipe->set_viewport_state(pipe, state);
+   pipe->set_viewport_states(pipe, start_slot, num_viewports, states);
 
    trace_dump_call_end();
 }
 
 
 static struct pipe_sampler_view *
-trace_create_sampler_view(struct pipe_context *_pipe,
+trace_context_create_sampler_view(struct pipe_context *_pipe,
                           struct pipe_resource *_resource,
                           const struct pipe_sampler_view *templ)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_resource *tr_tex = trace_resource(_resource);
+   struct trace_resource *tr_res = trace_resource(_resource);
    struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_resource *texture = tr_tex->resource;
+   struct pipe_resource *resource = tr_res->resource;
    struct pipe_sampler_view *result;
    struct trace_sampler_view *tr_view;
 
    trace_dump_call_begin("pipe_context", "create_sampler_view");
 
    trace_dump_arg(ptr, pipe);
-   trace_dump_arg(ptr, texture);
-   trace_dump_arg(sampler_view_template, templ);
+   trace_dump_arg(ptr, resource);
 
-   result = pipe->create_sampler_view(pipe, texture, templ);
+   trace_dump_arg_begin("templ");
+   trace_dump_sampler_view_template(templ, resource->target);
+   trace_dump_arg_end();
+
+   result = pipe->create_sampler_view(pipe, resource, templ);
 
    trace_dump_ret(ptr, result);
 
@@ -867,7 +853,7 @@ trace_create_sampler_view(struct pipe_context *_pipe,
 
 
 static void
-trace_sampler_view_destroy(struct pipe_context *_pipe,
+trace_context_sampler_view_destroy(struct pipe_context *_pipe,
                            struct pipe_sampler_view *_view)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -875,6 +861,8 @@ trace_sampler_view_destroy(struct pipe_context *_pipe,
    struct pipe_context *pipe = tr_ctx->pipe;
    struct pipe_sampler_view *view = tr_view->sampler_view;
 
+   assert(_view->context == _pipe);
+
    trace_dump_call_begin("pipe_context", "sampler_view_destroy");
 
    trace_dump_arg(ptr, pipe);
@@ -894,38 +882,41 @@ trace_sampler_view_destroy(struct pipe_context *_pipe,
 
 
 static struct pipe_surface *
-trace_create_surface(struct pipe_context *_pipe,
-                     struct pipe_resource *_texture,
-                     const struct pipe_surface *surf_tmpl)
+trace_context_create_surface(struct pipe_context *_pipe,
+                             struct pipe_resource *_resource,
+                             const struct pipe_surface *surf_tmpl)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_resource *tr_tex = trace_resource(_texture);
+   struct trace_resource *tr_res = trace_resource(_resource);
    struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_resource *texture = tr_tex->resource;
+   struct pipe_resource *resource = tr_res->resource;
    struct pipe_surface *result = NULL;
 
    trace_dump_call_begin("pipe_context", "create_surface");
 
    trace_dump_arg(ptr, pipe);
-   trace_dump_arg(ptr, texture);
-   /* hmm some values unitialized there */
-   trace_dump_arg(surface, surf_tmpl);
+   trace_dump_arg(ptr, resource);
+   
+   trace_dump_arg_begin("surf_tmpl");
+   trace_dump_surface_template(surf_tmpl, resource->target);
+   trace_dump_arg_end();
 
-   result = pipe->create_surface(pipe, texture, surf_tmpl);
+
+   result = pipe->create_surface(pipe, resource, surf_tmpl);
 
    trace_dump_ret(ptr, result);
 
    trace_dump_call_end();
 
-   result = trace_surf_create(tr_tex, result);
+   result = trace_surf_create(tr_ctx, tr_res, result);
 
    return result;
 }
 
 
 static void
-trace_surface_destroy(struct pipe_context *_pipe,
-                      struct pipe_surface *_surface)
+trace_context_surface_destroy(struct pipe_context *_pipe,
+                              struct pipe_surface *_surface)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
@@ -944,47 +935,20 @@ trace_surface_destroy(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_set_fragment_sampler_views(struct pipe_context *_pipe,
-                                         unsigned num,
-                                         struct pipe_sampler_view **views)
-{
-   struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_sampler_view *tr_view;
-   struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
-   unsigned i;
-
-   for(i = 0; i < num; ++i) {
-      tr_view = trace_sampler_view(views[i]);
-      unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
-   }
-   views = unwrapped_views;
-
-   trace_dump_call_begin("pipe_context", "set_fragment_sampler_views");
-
-   trace_dump_arg(ptr, pipe);
-   trace_dump_arg(uint, num);
-   trace_dump_arg_array(ptr, views, num);
-
-   pipe->set_fragment_sampler_views(pipe, num, views);
-
-   trace_dump_call_end();
-}
-
-
-static INLINE void
-trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
-                                       unsigned num,
-                                       struct pipe_sampler_view **views)
+trace_context_set_sampler_views(struct pipe_context *_pipe,
+                                unsigned shader,
+                                unsigned start,
+                                unsigned num,
+                                struct pipe_sampler_view **views)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct trace_sampler_view *tr_view;
    struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
+   struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SHADER_SAMPLER_VIEWS];
    unsigned i;
 
-   if (!pipe->set_vertex_sampler_views)
-      return;
+   /* remove this when we have pipe->set_sampler_views(..., start, ...) */
+   assert(start == 0);
 
    for(i = 0; i < num; ++i) {
       tr_view = trace_sampler_view(views[i]);
@@ -992,13 +956,15 @@ trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
    }
    views = unwrapped_views;
 
-   trace_dump_call_begin("pipe_context", "set_vertex_sampler_views");
+   trace_dump_call_begin("pipe_context", "set_sampler_views");
 
    trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, shader);
+   trace_dump_arg(uint, start);
    trace_dump_arg(uint, num);
    trace_dump_arg_array(ptr, views, num);
 
-   pipe->set_vertex_sampler_views(pipe, num, views);
+   pipe->set_sampler_views(pipe, shader, start, num, views);
 
    trace_dump_call_end();
 }
@@ -1006,7 +972,7 @@ trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
 
 static INLINE void
 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
-                                 unsigned num_buffers,
+                                 unsigned start_slot, unsigned num_buffers,
                                  const struct pipe_vertex_buffer *buffers)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -1016,21 +982,22 @@ trace_context_set_vertex_buffers(struct pipe_context *_pipe,
    trace_dump_call_begin("pipe_context", "set_vertex_buffers");
 
    trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, start_slot);
    trace_dump_arg(uint, num_buffers);
 
    trace_dump_arg_begin("buffers");
    trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
    trace_dump_arg_end();
 
-   if (num_buffers) {
+   if (buffers) {
       struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers));
       memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
       for (i = 0; i < num_buffers; i++)
          _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer);
-      pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
+      pipe->set_vertex_buffers(pipe, start_slot, num_buffers, _buffers);
       FREE(_buffers);
    } else {
-      pipe->set_vertex_buffers(pipe, num_buffers, NULL);
+      pipe->set_vertex_buffers(pipe, start_slot, num_buffers, NULL);
    }
 
    trace_dump_call_end();
@@ -1061,6 +1028,78 @@ trace_context_set_index_buffer(struct pipe_context *_pipe,
    trace_dump_call_end();
 }
 
+
+static INLINE struct pipe_stream_output_target *
+trace_context_create_stream_output_target(struct pipe_context *_pipe,
+                                          struct pipe_resource *res,
+                                          unsigned buffer_offset,
+                                          unsigned buffer_size)
+{
+   struct trace_context *tr_ctx = trace_context(_pipe);
+   struct pipe_context *pipe = tr_ctx->pipe;
+   struct pipe_stream_output_target *result;
+
+   res = trace_resource_unwrap(tr_ctx, res);
+
+   trace_dump_call_begin("pipe_context", "create_stream_output_target");
+
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, res);
+   trace_dump_arg(uint, buffer_offset);
+   trace_dump_arg(uint, buffer_size);
+
+   result = pipe->create_stream_output_target(pipe,
+                                              res, buffer_offset, buffer_size);
+
+   trace_dump_ret(ptr, result);
+
+   trace_dump_call_end();
+
+   return result;
+}
+
+
+static INLINE void
+trace_context_stream_output_target_destroy(
+   struct pipe_context *_pipe,
+   struct pipe_stream_output_target *target)
+{
+   struct trace_context *tr_ctx = trace_context(_pipe);
+   struct pipe_context *pipe = tr_ctx->pipe;
+
+   trace_dump_call_begin("pipe_context", "stream_output_target_destroy");
+
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, target);
+
+   pipe->stream_output_target_destroy(pipe, target);
+
+   trace_dump_call_end();
+}
+
+
+static INLINE void
+trace_context_set_stream_output_targets(struct pipe_context *_pipe,
+                                        unsigned num_targets,
+                                        struct pipe_stream_output_target **tgs,
+                                        const unsigned *offsets)
+{
+   struct trace_context *tr_ctx = trace_context(_pipe);
+   struct pipe_context *pipe = tr_ctx->pipe;
+
+   trace_dump_call_begin("pipe_context", "set_stream_output_targets");
+
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, num_targets);
+   trace_dump_arg_array(ptr, tgs, num_targets);
+   trace_dump_arg_array(uint, offsets, num_targets);
+
+   pipe->set_stream_output_targets(pipe, num_targets, tgs, offsets);
+
+   trace_dump_call_end();
+}
+
+
 static INLINE void
 trace_context_resource_copy_region(struct pipe_context *_pipe,
                                    struct pipe_resource *dst,
@@ -1096,10 +1135,52 @@ trace_context_resource_copy_region(struct pipe_context *_pipe,
 }
 
 
+static INLINE void
+trace_context_blit(struct pipe_context *_pipe,
+                   const struct pipe_blit_info *_info)
+{
+   struct trace_context *tr_ctx = trace_context(_pipe);
+   struct pipe_context *pipe = tr_ctx->pipe;
+   struct pipe_blit_info info = *_info;
+
+   info.dst.resource = trace_resource_unwrap(tr_ctx, info.dst.resource);
+   info.src.resource = trace_resource_unwrap(tr_ctx, info.src.resource);
+
+   trace_dump_call_begin("pipe_context", "blit");
+
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(blit_info, _info);
+
+   pipe->blit(pipe, &info);
+
+   trace_dump_call_end();
+}
+
+
+static void
+trace_context_flush_resource(struct pipe_context *_pipe,
+                             struct pipe_resource *resource)
+{
+   struct trace_context *tr_ctx = trace_context(_pipe);
+   struct pipe_context *pipe = tr_ctx->pipe;
+
+   resource = trace_resource_unwrap(tr_ctx, resource);
+
+   trace_dump_call_begin("pipe_context", "flush_resource");
+
+   trace_dump_arg(ptr, pipe);
+   trace_dump_arg(ptr, resource);
+
+   pipe->flush_resource(pipe, resource);
+
+   trace_dump_call_end();
+}
+
+
 static INLINE void
 trace_context_clear(struct pipe_context *_pipe,
                     unsigned buffers,
-                    const float *rgba,
+                    const union pipe_color_union *color,
                     double depth,
                     unsigned stencil)
 {
@@ -1110,14 +1191,16 @@ trace_context_clear(struct pipe_context *_pipe,
 
    trace_dump_arg(ptr, pipe);
    trace_dump_arg(uint, buffers);
-   if (rgba)
-      trace_dump_arg_array(float, rgba, 4);
+   trace_dump_arg_begin("color");
+   if (color)
+      trace_dump_array(float, color->f, 4);
    else
       trace_dump_null();
+   trace_dump_arg_end();
    trace_dump_arg(float, depth);
    trace_dump_arg(uint, stencil);
 
-   pipe->clear(pipe, buffers, rgba, depth, stencil);
+   pipe->clear(pipe, buffers, color, depth, stencil);
 
    trace_dump_call_end();
 }
@@ -1126,7 +1209,7 @@ trace_context_clear(struct pipe_context *_pipe,
 static INLINE void
 trace_context_clear_render_target(struct pipe_context *_pipe,
                                   struct pipe_surface *dst,
-                                  const float *rgba,
+                                  const union pipe_color_union *color,
                                   unsigned dstx, unsigned dsty,
                                   unsigned width, unsigned height)
 {
@@ -1139,13 +1222,13 @@ trace_context_clear_render_target(struct pipe_context *_pipe,
 
    trace_dump_arg(ptr, pipe);
    trace_dump_arg(ptr, dst);
-   trace_dump_arg_array(float, rgba, 4);
+   trace_dump_arg_array(float, color->f, 4);
    trace_dump_arg(uint, dstx);
    trace_dump_arg(uint, dsty);
    trace_dump_arg(uint, width);
    trace_dump_arg(uint, height);
 
-   pipe->clear_render_target(pipe, dst, rgba, dstx, dsty, width, height);
+   pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height);
 
    trace_dump_call_end();
 }
@@ -1184,7 +1267,8 @@ trace_context_clear_depth_stencil(struct pipe_context *_pipe,
 
 static INLINE void
 trace_context_flush(struct pipe_context *_pipe,
-                    struct pipe_fence_handle **fence)
+                    struct pipe_fence_handle **fence,
+                    unsigned flags)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
@@ -1192,8 +1276,9 @@ trace_context_flush(struct pipe_context *_pipe,
    trace_dump_call_begin("pipe_context", "flush");
 
    trace_dump_arg(ptr, pipe);
+   trace_dump_arg(uint, flags);
 
-   pipe->flush(pipe, fence);
+   pipe->flush(pipe, fence, flags);
 
    if(fence)
       trace_dump_ret(ptr, *fence);
@@ -1223,18 +1308,20 @@ trace_context_destroy(struct pipe_context *_pipe)
  */
 
 
-static struct pipe_transfer *
-trace_context_get_transfer(struct pipe_context *_context,
+static void *
+trace_context_transfer_map(struct pipe_context *_context,
                            struct pipe_resource *_resource,
                            unsigned level,
                            unsigned usage,
-                           const struct pipe_box *box)
+                           const struct pipe_box *box,
+                           struct pipe_transfer **transfer)
 {
    struct trace_context *tr_context = trace_context(_context);
-   struct trace_resource *tr_tex = trace_resource(_resource);
+   struct trace_resource *tr_res = trace_resource(_resource);
    struct pipe_context *context = tr_context->pipe;
-   struct pipe_resource *texture = tr_tex->resource;
+   struct pipe_resource *texture = tr_res->resource;
    struct pipe_transfer *result = NULL;
+   void *map;
 
    assert(texture->screen == context->screen);
 
@@ -1243,48 +1330,21 @@ trace_context_get_transfer(struct pipe_context *_context,
     * to transfer_inline_write and ignore read transfers.
     */
 
-   result = context->get_transfer(context, texture, level, usage, box);
-
-   if (result)
-      result = trace_transfer_create(tr_context, tr_tex, result);
-
-   return result;
-}
-
-
-static void
-trace_context_transfer_destroy(struct pipe_context *_context,
-                               struct pipe_transfer *_transfer)
-{
-   struct trace_context *tr_context = trace_context(_context);
-   struct trace_transfer *tr_trans = trace_transfer(_transfer);
-
-   trace_transfer_destroy(tr_context, tr_trans);
-}
-
+   map = context->transfer_map(context, texture, level, usage, box, &result);
+   if (!map)
+      return NULL;
 
-static void *
-trace_context_transfer_map(struct pipe_context *_context,
-                          struct pipe_transfer *_transfer)
-{
-   struct trace_context *tr_context = trace_context(_context);
-   struct trace_transfer *tr_trans = trace_transfer(_transfer);
-   struct pipe_context *context = tr_context->pipe;
-   struct pipe_transfer *transfer = tr_trans->transfer;
-   void *map;
+   *transfer = trace_transfer_create(tr_context, tr_res, result);
 
-   map = context->transfer_map(context, transfer);
-   if(map) {
-      if(transfer->usage & PIPE_TRANSFER_WRITE) {
-         assert(!tr_trans->map);
-         tr_trans->map = map;
+   if (map) {
+      if(usage & PIPE_TRANSFER_WRITE) {
+         trace_transfer(*transfer)->map = map;
       }
    }
 
-   return map;
+   return *transfer ? map : NULL;
 }
 
-
 static void
 trace_context_transfer_flush_region( struct pipe_context *_context,
 				     struct pipe_transfer *_transfer,
@@ -1331,7 +1391,7 @@ trace_context_transfer_unmap(struct pipe_context *_context,
 
       trace_dump_arg_begin("data");
       trace_dump_box_bytes(tr_trans->map,
-                           resource->format,
+                           resource,
                            box,
                            stride,
                            layer_stride);
@@ -1346,6 +1406,7 @@ trace_context_transfer_unmap(struct pipe_context *_context,
    }
 
    context->transfer_unmap(context, transfer);
+   trace_transfer_destroy(tr_ctx, tr_trans);
 }
 
 
@@ -1360,9 +1421,9 @@ trace_context_transfer_inline_write(struct pipe_context *_context,
                                     unsigned layer_stride)
 {
    struct trace_context *tr_context = trace_context(_context);
-   struct trace_resource *tr_tex = trace_resource(_resource);
+   struct trace_resource *tr_res = trace_resource(_resource);
    struct pipe_context *context = tr_context->pipe;
-   struct pipe_resource *resource = tr_tex->resource;
+   struct pipe_resource *resource = tr_res->resource;
 
    assert(resource->screen == context->screen);
 
@@ -1376,7 +1437,7 @@ trace_context_transfer_inline_write(struct pipe_context *_context,
 
    trace_dump_arg_begin("data");
    trace_dump_box_bytes(data,
-                        resource->format,
+                        resource,
                         box,
                         stride,
                         layer_stride);
@@ -1392,27 +1453,56 @@ trace_context_transfer_inline_write(struct pipe_context *_context,
 }
 
 
-static void trace_redefine_user_buffer(struct pipe_context *_context,
-                                       struct pipe_resource *_resource,
-                                       unsigned offset, unsigned size)
+static void trace_context_render_condition(struct pipe_context *_context,
+                                           struct pipe_query *query,
+                                           boolean condition,
+                                           uint mode)
 {
    struct trace_context *tr_context = trace_context(_context);
-   struct trace_resource *tr_tex = trace_resource(_resource);
    struct pipe_context *context = tr_context->pipe;
-   struct pipe_resource *resource = tr_tex->resource;
 
-   assert(resource->screen == context->screen);
+   query = trace_query_unwrap(query);
 
-   trace_dump_call_begin("pipe_context", "redefine_user_buffer");
+   trace_dump_call_begin("pipe_context", "render_condition");
 
    trace_dump_arg(ptr, context);
-   trace_dump_arg(ptr, resource);
-   trace_dump_arg(uint, offset);
-   trace_dump_arg(uint, size);
+   trace_dump_arg(ptr, query);
+   trace_dump_arg(bool, condition);
+   trace_dump_arg(uint, mode);
 
    trace_dump_call_end();
 
-   context->redefine_user_buffer(context, resource, offset, size);
+   context->render_condition(context, query, condition, mode);
+}
+
+
+static void trace_context_texture_barrier(struct pipe_context *_context)
+{
+   struct trace_context *tr_context = trace_context(_context);
+   struct pipe_context *context = tr_context->pipe;
+
+   trace_dump_call_begin("pipe_context", "texture_barrier");
+
+   trace_dump_arg(ptr, context);
+
+   trace_dump_call_end();
+
+   context->texture_barrier(context);
+}
+
+
+static void trace_context_memory_barrier(struct pipe_context *_context,
+                                         unsigned flags)
+{
+   struct trace_context *tr_context = trace_context(_context);
+   struct pipe_context *context = tr_context->pipe;
+
+   trace_dump_call_begin("pipe_context", "memory_barrier");
+   trace_dump_arg(ptr, context);
+   trace_dump_arg(uint, flags);
+   trace_dump_call_end();
+
+   context->memory_barrier(context, flags);
 }
 
 
@@ -1438,69 +1528,80 @@ trace_context_create(struct trace_screen *tr_scr,
    if(!tr_ctx)
       goto error1;
 
-   tr_ctx->base.winsys = NULL;
    tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
    tr_ctx->base.screen = &tr_scr->base;
 
    tr_ctx->base.destroy = trace_context_destroy;
-   tr_ctx->base.draw_vbo = trace_context_draw_vbo;
-   tr_ctx->base.create_query = trace_context_create_query;
-   tr_ctx->base.destroy_query = trace_context_destroy_query;
-   tr_ctx->base.begin_query = trace_context_begin_query;
-   tr_ctx->base.end_query = trace_context_end_query;
-   tr_ctx->base.get_query_result = trace_context_get_query_result;
-   tr_ctx->base.create_blend_state = trace_context_create_blend_state;
-   tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
-   tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
-   tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
-   tr_ctx->base.bind_fragment_sampler_states = trace_context_bind_fragment_sampler_states;
-   tr_ctx->base.bind_vertex_sampler_states = trace_context_bind_vertex_sampler_states;
-   tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
-   tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
-   tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
-   tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
-   tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
-   tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
-   tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
-   tr_ctx->base.create_fs_state = trace_context_create_fs_state;
-   tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
-   tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
-   tr_ctx->base.create_vs_state = trace_context_create_vs_state;
-   tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
-   tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
-   tr_ctx->base.create_vertex_elements_state = trace_context_create_vertex_elements_state;
-   tr_ctx->base.bind_vertex_elements_state = trace_context_bind_vertex_elements_state;
-   tr_ctx->base.delete_vertex_elements_state = trace_context_delete_vertex_elements_state;
-   tr_ctx->base.set_blend_color = trace_context_set_blend_color;
-   tr_ctx->base.set_stencil_ref = trace_context_set_stencil_ref;
-   tr_ctx->base.set_clip_state = trace_context_set_clip_state;
-   tr_ctx->base.set_sample_mask = trace_context_set_sample_mask;
-   tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
-   tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
-   tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
-   tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
-   tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
-   tr_ctx->base.set_fragment_sampler_views = trace_context_set_fragment_sampler_views;
-   tr_ctx->base.set_vertex_sampler_views = trace_context_set_vertex_sampler_views;
-   tr_ctx->base.create_sampler_view = trace_create_sampler_view;
-   tr_ctx->base.sampler_view_destroy = trace_sampler_view_destroy;
-   tr_ctx->base.create_surface = trace_create_surface;
-   tr_ctx->base.surface_destroy = trace_surface_destroy;
-   tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
-   tr_ctx->base.set_index_buffer = trace_context_set_index_buffer;
-   tr_ctx->base.resource_copy_region = trace_context_resource_copy_region;
-   tr_ctx->base.clear = trace_context_clear;
-   tr_ctx->base.clear_render_target = trace_context_clear_render_target;
-   tr_ctx->base.clear_depth_stencil = trace_context_clear_depth_stencil;
-   tr_ctx->base.flush = trace_context_flush;
-
-   tr_ctx->base.get_transfer = trace_context_get_transfer;
-   tr_ctx->base.transfer_destroy = trace_context_transfer_destroy;
-   tr_ctx->base.transfer_map = trace_context_transfer_map;
-   tr_ctx->base.transfer_unmap = trace_context_transfer_unmap;
-   tr_ctx->base.transfer_flush_region = trace_context_transfer_flush_region;
-   tr_ctx->base.transfer_inline_write = trace_context_transfer_inline_write;
-   tr_ctx->base.redefine_user_buffer = trace_redefine_user_buffer;
+
+#define TR_CTX_INIT(_member) \
+   tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL
+
+   TR_CTX_INIT(draw_vbo);
+   TR_CTX_INIT(render_condition);
+   TR_CTX_INIT(create_query);
+   TR_CTX_INIT(destroy_query);
+   TR_CTX_INIT(begin_query);
+   TR_CTX_INIT(end_query);
+   TR_CTX_INIT(get_query_result);
+   TR_CTX_INIT(create_blend_state);
+   TR_CTX_INIT(bind_blend_state);
+   TR_CTX_INIT(delete_blend_state);
+   TR_CTX_INIT(create_sampler_state);
+   TR_CTX_INIT(bind_sampler_states);
+   TR_CTX_INIT(delete_sampler_state);
+   TR_CTX_INIT(create_rasterizer_state);
+   TR_CTX_INIT(bind_rasterizer_state);
+   TR_CTX_INIT(delete_rasterizer_state);
+   TR_CTX_INIT(create_depth_stencil_alpha_state);
+   TR_CTX_INIT(bind_depth_stencil_alpha_state);
+   TR_CTX_INIT(delete_depth_stencil_alpha_state);
+   TR_CTX_INIT(create_fs_state);
+   TR_CTX_INIT(bind_fs_state);
+   TR_CTX_INIT(delete_fs_state);
+   TR_CTX_INIT(create_vs_state);
+   TR_CTX_INIT(bind_vs_state);
+   TR_CTX_INIT(delete_vs_state);
+   TR_CTX_INIT(create_gs_state);
+   TR_CTX_INIT(bind_gs_state);
+   TR_CTX_INIT(delete_gs_state);
+   TR_CTX_INIT(create_vertex_elements_state);
+   TR_CTX_INIT(bind_vertex_elements_state);
+   TR_CTX_INIT(delete_vertex_elements_state);
+   TR_CTX_INIT(set_blend_color);
+   TR_CTX_INIT(set_stencil_ref);
+   TR_CTX_INIT(set_clip_state);
+   TR_CTX_INIT(set_sample_mask);
+   TR_CTX_INIT(set_constant_buffer);
+   TR_CTX_INIT(set_framebuffer_state);
+   TR_CTX_INIT(set_polygon_stipple);
+   TR_CTX_INIT(set_scissor_states);
+   TR_CTX_INIT(set_viewport_states);
+   TR_CTX_INIT(set_sampler_views);
+   TR_CTX_INIT(create_sampler_view);
+   TR_CTX_INIT(sampler_view_destroy);
+   TR_CTX_INIT(create_surface);
+   TR_CTX_INIT(surface_destroy);
+   TR_CTX_INIT(set_vertex_buffers);
+   TR_CTX_INIT(set_index_buffer);
+   TR_CTX_INIT(create_stream_output_target);
+   TR_CTX_INIT(stream_output_target_destroy);
+   TR_CTX_INIT(set_stream_output_targets);
+   TR_CTX_INIT(resource_copy_region);
+   TR_CTX_INIT(blit);
+   TR_CTX_INIT(flush_resource);
+   TR_CTX_INIT(clear);
+   TR_CTX_INIT(clear_render_target);
+   TR_CTX_INIT(clear_depth_stencil);
+   TR_CTX_INIT(flush);
+   TR_CTX_INIT(texture_barrier);
+   TR_CTX_INIT(memory_barrier);
+
+   TR_CTX_INIT(transfer_map);
+   TR_CTX_INIT(transfer_unmap);
+   TR_CTX_INIT(transfer_flush_region);
+   TR_CTX_INIT(transfer_inline_write);
+
+#undef TR_CTX_INIT
 
    tr_ctx->pipe = pipe;
 
@@ -1509,3 +1610,16 @@ trace_context_create(struct trace_screen *tr_scr,
 error1:
    return pipe;
 }
+
+
+/**
+ * Sanity checker: check that the given context really is a 
+ * trace context (and not the wrapped driver's context).
+ */
+void
+trace_context_check(const struct pipe_context *pipe)
+{
+   struct trace_context *tr_ctx = (struct trace_context *) pipe;
+   assert(tr_ctx->base.destroy == trace_context_destroy);
+}
+