r600: Add support for B5G5R5A1.

[mesa.git] / src / gallium / drivers / trace / tr_dump_state.c

diff --git a/src/gallium/drivers/trace/tr_dump_state.c b/src/gallium/drivers/trace/tr_dump_state.c
index 54f022a8ab66fe351c8df2d6525362c17acb6381..41f7faf513b0618819105372cc79946f28254452 100644 (file)
--- a/src/gallium/drivers/trace/tr_dump_state.c
+++ b/src/gallium/drivers/trace/tr_dump_state.c
@@ -178,7 +178,7 @@ void trace_dump_poly_stipple(const struct pipe_poly_stipple *state)
    trace_dump_member_begin("stipple");
    trace_dump_array(uint,
                     state->stipple,
-                    Elements(state->stipple));
+                    ARRAY_SIZE(state->stipple));
    trace_dump_member_end();
 
    trace_dump_struct_end();
@@ -305,6 +305,38 @@ void trace_dump_shader_state(const struct pipe_shader_state *state)
 }
 
 
+void trace_dump_compute_state(const struct pipe_compute_state *state)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if (!state) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_compute_state");
+
+   trace_dump_member(uint, state, ir_type);
+
+   trace_dump_member_begin("prog");
+   if (state->prog && state->ir_type == PIPE_SHADER_IR_TGSI) {
+      static char str[64 * 1024];
+      tgsi_dump_str(state->prog, 0, str, sizeof(str));
+      trace_dump_string(str);
+   } else {
+      trace_dump_null();
+   }
+   trace_dump_member_end();
+
+   trace_dump_member(uint, state, req_local_mem);
+   trace_dump_member(uint, state, req_private_mem);
+   trace_dump_member(uint, state, req_input_mem);
+
+   trace_dump_struct_end();
+}
+
+
 void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state)
 {
    unsigned i;
@@ -329,7 +361,7 @@ void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_
 
    trace_dump_member_begin("stencil");
    trace_dump_array_begin();
-   for(i = 0; i < Elements(state->stencil); ++i) {
+   for(i = 0; i < ARRAY_SIZE(state->stencil); ++i) {
       trace_dump_elem_begin();
       trace_dump_struct_begin("pipe_stencil_state");
       trace_dump_member(bool, &state->stencil[i], enabled);
@@ -449,6 +481,8 @@ void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state)
 
    trace_dump_member(uint, state, width);
    trace_dump_member(uint, state, height);
+   trace_dump_member(uint, state, samples);
+   trace_dump_member(uint, state, layers);
    trace_dump_member(uint, state, nr_cbufs);
    trace_dump_member_array(ptr, state, cbufs);
    trace_dump_member(ptr, state, zsbuf);
@@ -509,8 +543,8 @@ void trace_dump_sampler_view_template(const struct pipe_sampler_view *state,
    if (target == PIPE_BUFFER) {
       trace_dump_member_begin("buf");
       trace_dump_struct_begin(""); /* anonymous */
-      trace_dump_member(uint, &state->u.buf, first_element);
-      trace_dump_member(uint, &state->u.buf, last_element);
+      trace_dump_member(uint, &state->u.buf, offset);
+      trace_dump_member(uint, &state->u.buf, size);
       trace_dump_struct_end(); /* anonymous */
       trace_dump_member_end(); /* buf */
    } else {
@@ -619,15 +653,15 @@ void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state)
    trace_dump_struct_begin("pipe_vertex_buffer");
 
    trace_dump_member(uint, state, stride);
+   trace_dump_member(bool, state, is_user_buffer);
    trace_dump_member(uint, state, buffer_offset);
-   trace_dump_member(resource_ptr, state, buffer);
-   trace_dump_member(ptr, state, user_buffer);
+   trace_dump_member(ptr, state, buffer.resource);
 
    trace_dump_struct_end();
 }
 
 
-void trace_dump_index_buffer(const struct pipe_index_buffer *state)
+void trace_dump_vertex_element(const struct pipe_vertex_element *state)
 {
    if (!trace_dumping_enabled_locked())
       return;
@@ -637,18 +671,19 @@ void trace_dump_index_buffer(const struct pipe_index_buffer *state)
       return;
    }
 
-   trace_dump_struct_begin("pipe_index_buffer");
+   trace_dump_struct_begin("pipe_vertex_element");
+
+   trace_dump_member(uint, state, src_offset);
 
-   trace_dump_member(uint, state, index_size);
-   trace_dump_member(uint, state, offset);
-   trace_dump_member(resource_ptr, state, buffer);
-   trace_dump_member(ptr, state, user_buffer);
+   trace_dump_member(uint, state, vertex_buffer_index);
+
+   trace_dump_member(format, state, src_format);
 
    trace_dump_struct_end();
 }
 
 
-void trace_dump_vertex_element(const struct pipe_vertex_element *state)
+void trace_dump_constant_buffer(const struct pipe_constant_buffer *state)
 {
    if (!trace_dumping_enabled_locked())
       return;
@@ -658,32 +693,68 @@ void trace_dump_vertex_element(const struct pipe_vertex_element *state)
       return;
    }
 
-   trace_dump_struct_begin("pipe_vertex_element");
+   trace_dump_struct_begin("pipe_constant_buffer");
+   trace_dump_member(ptr, state, buffer);
+   trace_dump_member(uint, state, buffer_offset);
+   trace_dump_member(uint, state, buffer_size);
+   trace_dump_struct_end();
+}
 
-   trace_dump_member(uint, state, src_offset);
 
-   trace_dump_member(uint, state, vertex_buffer_index);
+void trace_dump_shader_buffer(const struct pipe_shader_buffer *state)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
 
-   trace_dump_member(format, state, src_format);
+   if(!state) {
+      trace_dump_null();
+      return;
+   }
 
+   trace_dump_struct_begin("pipe_shader_buffer");
+   trace_dump_member(ptr, state, buffer);
+   trace_dump_member(uint, state, buffer_offset);
+   trace_dump_member(uint, state, buffer_size);
    trace_dump_struct_end();
 }
 
 
-void trace_dump_constant_buffer(const struct pipe_constant_buffer *state)
+void trace_dump_image_view(const struct pipe_image_view *state)
 {
    if (!trace_dumping_enabled_locked())
       return;
 
-   if (!state) {
+   if(!state) {
       trace_dump_null();
       return;
    }
 
-   trace_dump_struct_begin("pipe_constant_buffer");
-   trace_dump_member(ptr, state, buffer);
-   trace_dump_member(uint, state, buffer_offset);
-   trace_dump_member(uint, state, buffer_size);
+   trace_dump_struct_begin("pipe_image_view");
+   trace_dump_member(ptr, state, resource);
+   trace_dump_member(uint, state, format);
+   trace_dump_member(uint, state, access);
+
+   trace_dump_member_begin("u");
+   trace_dump_struct_begin(""); /* anonymous */
+   if (state->resource->target == PIPE_BUFFER) {
+      trace_dump_member_begin("buf");
+      trace_dump_struct_begin(""); /* anonymous */
+      trace_dump_member(uint, &state->u.buf, offset);
+      trace_dump_member(uint, &state->u.buf, size);
+      trace_dump_struct_end(); /* anonymous */
+      trace_dump_member_end(); /* buf */
+   } else {
+      trace_dump_member_begin("tex");
+      trace_dump_struct_begin(""); /* anonymous */
+      trace_dump_member(uint, &state->u.tex, first_layer);
+      trace_dump_member(uint, &state->u.tex, last_layer);
+      trace_dump_member(uint, &state->u.tex, level);
+      trace_dump_struct_end(); /* anonymous */
+      trace_dump_member_end(); /* tex */
+   }
+   trace_dump_struct_end(); /* anonymous */
+   trace_dump_member_end(); /* u */
+
    trace_dump_struct_end();
 }
 
@@ -700,7 +771,8 @@ void trace_dump_draw_info(const struct pipe_draw_info *state)
 
    trace_dump_struct_begin("pipe_draw_info");
 
-   trace_dump_member(bool, state, indexed);
+   trace_dump_member(uint, state, index_size);
+   trace_dump_member(uint, state, has_user_indices);
 
    trace_dump_member(uint, state, mode);
    trace_dump_member(uint, state, start);
@@ -718,10 +790,19 @@ void trace_dump_draw_info(const struct pipe_draw_info *state)
    trace_dump_member(bool, state, primitive_restart);
    trace_dump_member(uint, state, restart_index);
 
+   trace_dump_member(ptr, state, index.resource);
    trace_dump_member(ptr, state, count_from_stream_output);
 
-   trace_dump_member(ptr, state, indirect);
-   trace_dump_member(uint, state, indirect_offset);
+   if (!state->indirect) {
+      trace_dump_member(ptr, state, indirect);
+   } else {
+      trace_dump_member(uint, state, indirect->offset);
+      trace_dump_member(uint, state, indirect->stride);
+      trace_dump_member(uint, state, indirect->draw_count);
+      trace_dump_member(uint, state, indirect->indirect_draw_count_offset);
+      trace_dump_member(ptr, state, indirect->buffer);
+      trace_dump_member(ptr, state, indirect->indirect_draw_count);
+   }
 
    trace_dump_struct_end();
 }
@@ -742,7 +823,7 @@ void trace_dump_blit_info(const struct pipe_blit_info *info)
 
    trace_dump_member_begin("dst");
    trace_dump_struct_begin("dst");
-   trace_dump_member(resource_ptr, &info->dst, resource);
+   trace_dump_member(ptr, &info->dst, resource);
    trace_dump_member(uint, &info->dst, level);
    trace_dump_member(format, &info->dst, format);
    trace_dump_member_begin("box");
@@ -753,7 +834,7 @@ void trace_dump_blit_info(const struct pipe_blit_info *info)
 
    trace_dump_member_begin("src");
    trace_dump_struct_begin("src");
-   trace_dump_member(resource_ptr, &info->src, resource);
+   trace_dump_member(ptr, &info->src, resource);
    trace_dump_member(uint, &info->src, level);
    trace_dump_member(format, &info->src, format);
    trace_dump_member_begin("box");
@@ -846,3 +927,33 @@ trace_dump_query_result(unsigned query_type,
       break;
    }
 }
+
+void trace_dump_grid_info(const struct pipe_grid_info *state)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if (!state) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_grid_info");
+
+   trace_dump_member(uint, state, pc);
+   trace_dump_member(ptr, state, input);
+
+   trace_dump_member_begin("block");
+   trace_dump_array(uint, state->block, ARRAY_SIZE(state->block));
+   trace_dump_member_end();
+
+   trace_dump_member_begin("grid");
+   trace_dump_array(uint, state->grid, ARRAY_SIZE(state->grid));
+   trace_dump_member_end();
+
+   trace_dump_member(ptr, state, indirect);
+   trace_dump_member(uint, state, indirect_offset);
+
+   trace_dump_struct_end();
+}
+