X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Ftrace%2Ftr_dump_state.c;h=18d9938a39d0de44e476e8394036301c959e43b2;hb=e9edbf0a688c68ef0896e5d4278f411f6b6f8398;hp=7cbf705287580bf4536af3f0198cf281d77fc021;hpb=6f5e0539dc681b800bd08d14221751d0f3484280;p=mesa.git

diff --git a/src/gallium/drivers/trace/tr_dump_state.c b/src/gallium/drivers/trace/tr_dump_state.c
index 7cbf7052875..18d9938a39d 100644
--- a/src/gallium/drivers/trace/tr_dump_state.c
+++ b/src/gallium/drivers/trace/tr_dump_state.c
@@ -44,18 +44,7 @@ void trace_dump_format(enum pipe_format format)
 }
 
 
-static void trace_dump_reference(const struct pipe_reference *reference)
-{
-   if (!trace_dumping_enabled_locked())
-      return;
-
-   trace_dump_struct_begin("pipe_reference");
-   trace_dump_member(int, reference, count);
-   trace_dump_struct_end();
-}
-
-
-void trace_dump_template(const struct pipe_texture *templat)
+void trace_dump_resource_template(const struct pipe_resource *templat)
 {
    if (!trace_dumping_enabled_locked())
       return;
@@ -65,7 +54,7 @@ void trace_dump_template(const struct pipe_texture *templat)
       return;
    }
 
-   trace_dump_struct_begin("pipe_texture");
+   trace_dump_struct_begin("pipe_resource");
 
    trace_dump_member(int, templat, target);
    trace_dump_member(format, templat, format);
@@ -82,8 +71,38 @@ void trace_dump_template(const struct pipe_texture *templat)
    trace_dump_uint(templat->depth0);
    trace_dump_member_end();
 
+   trace_dump_member_begin("array_size");
+   trace_dump_uint(templat->array_size);
+   trace_dump_member_end();
+
    trace_dump_member(uint, templat, last_level);
-   trace_dump_member(uint, templat, tex_usage);
+   trace_dump_member(uint, templat, nr_samples);
+   trace_dump_member(uint, templat, usage);
+   trace_dump_member(uint, templat, bind);
+   trace_dump_member(uint, templat, flags);
+
+   trace_dump_struct_end();
+}
+
+
+void trace_dump_box(const struct pipe_box *box)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if(!box) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_box");
+
+   trace_dump_member(int, box, x);
+   trace_dump_member(int, box, y);
+   trace_dump_member(int, box, z);
+   trace_dump_member(int, box, width);
+   trace_dump_member(int, box, height);
+   trace_dump_member(int, box, depth);
 
    trace_dump_struct_end();
 }
@@ -103,12 +122,15 @@ void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
 
    trace_dump_member(bool, state, flatshade);
    trace_dump_member(bool, state, light_twoside);
-   trace_dump_member(uint, state, front_winding);
-   trace_dump_member(uint, state, cull_mode);
-   trace_dump_member(uint, state, fill_cw);
-   trace_dump_member(uint, state, fill_ccw);
-   trace_dump_member(bool, state, offset_cw);
-   trace_dump_member(bool, state, offset_ccw);
+   trace_dump_member(bool, state, clamp_vertex_color);
+   trace_dump_member(bool, state, clamp_fragment_color);
+   trace_dump_member(uint, state, front_ccw);
+   trace_dump_member(uint, state, cull_face);
+   trace_dump_member(uint, state, fill_front);
+   trace_dump_member(uint, state, fill_back);
+   trace_dump_member(bool, state, offset_point);
+   trace_dump_member(bool, state, offset_line);
+   trace_dump_member(bool, state, offset_tri);
    trace_dump_member(bool, state, scissor);
    trace_dump_member(bool, state, poly_smooth);
    trace_dump_member(bool, state, poly_stipple_enable);
@@ -123,14 +145,18 @@ void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
    trace_dump_member(uint, state, line_stipple_factor);
    trace_dump_member(uint, state, line_stipple_pattern);
    trace_dump_member(bool, state, line_last_pixel);
-   trace_dump_member(bool, state, bypass_vs_clip_and_viewport);
    trace_dump_member(bool, state, flatshade_first);
-   trace_dump_member(bool, state, gl_rasterization_rules);
+   trace_dump_member(bool, state, half_pixel_center);
+   trace_dump_member(bool, state, bottom_edge_rule);
+   trace_dump_member(bool, state, rasterizer_discard);
+   trace_dump_member(bool, state, depth_clip);
+   trace_dump_member(uint, state, clip_plane_enable);
 
    trace_dump_member(float, state, line_width);
    trace_dump_member(float, state, point_size);
    trace_dump_member(float, state, offset_units);
    trace_dump_member(float, state, offset_scale);
+   trace_dump_member(float, state, offset_clamp);
 
    trace_dump_struct_end();
 }
@@ -222,8 +248,6 @@ void trace_dump_clip_state(const struct pipe_clip_state *state)
    trace_dump_array_end();
    trace_dump_member_end();
 
-   trace_dump_member(uint, state, nr);
-
    trace_dump_struct_end();
 }
 
@@ -231,6 +255,7 @@ void trace_dump_clip_state(const struct pipe_clip_state *state)
 void trace_dump_shader_state(const struct pipe_shader_state *state)
 {
    static char str[8192];
+   unsigned i;
 
    if (!trace_dumping_enabled_locked())
       return;
@@ -248,6 +273,28 @@ void trace_dump_shader_state(const struct pipe_shader_state *state)
    trace_dump_string(str);
    trace_dump_member_end();
 
+   trace_dump_member_begin("stream_output");
+   trace_dump_struct_begin("pipe_stream_output_info");
+   trace_dump_member(uint, &state->stream_output, num_outputs);
+   trace_dump_member_array(uint, &state->stream_output, stride);
+   trace_dump_member_begin("output");
+   trace_dump_array_begin();
+   for(i = 0; i < state->stream_output.num_outputs; ++i) {
+      trace_dump_elem_begin();
+      trace_dump_struct_begin(""); /* anonymous */
+      trace_dump_member(uint, &state->stream_output.output[i], register_index);
+      trace_dump_member(uint, &state->stream_output.output[i], start_component);
+      trace_dump_member(uint, &state->stream_output.output[i], num_components);
+      trace_dump_member(uint, &state->stream_output.output[i], output_buffer);
+      trace_dump_member(uint, &state->stream_output.output[i], dst_offset);
+      trace_dump_struct_end();
+      trace_dump_elem_end();
+   }
+   trace_dump_array_end();
+   trace_dump_member_end(); // output
+   trace_dump_struct_end();
+   trace_dump_member_end(); // stream_output
+
    trace_dump_struct_end();
 }
 
@@ -429,13 +476,14 @@ void trace_dump_sampler_state(const struct pipe_sampler_state *state)
    trace_dump_member(float, state, lod_bias);
    trace_dump_member(float, state, min_lod);
    trace_dump_member(float, state, max_lod);
-   trace_dump_member_array(float, state, border_color);
+   trace_dump_member_array(float, state, border_color.f);
 
    trace_dump_struct_end();
 }
 
 
-void trace_dump_surface(const struct pipe_surface *state)
+void trace_dump_sampler_view_template(const struct pipe_sampler_view *state,
+                                      enum pipe_texture_target target)
 {
    if (!trace_dumping_enabled_locked())
       return;
@@ -445,22 +493,78 @@ void trace_dump_surface(const struct pipe_surface *state)
       return;
    }
 
-   trace_dump_struct_begin("pipe_surface");
+   trace_dump_struct_begin("pipe_sampler_view");
 
-   trace_dump_reference(&state->reference);
+   trace_dump_member(format, state, format);
+
+   trace_dump_member_begin("u");
+   trace_dump_struct_begin(""); /* anonymous */
+   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_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, first_level);
+      trace_dump_member(uint, &state->u.tex, last_level);
+      trace_dump_struct_end(); /* anonymous */
+      trace_dump_member_end(); /* tex */
+   }
+   trace_dump_struct_end(); /* anonymous */
+   trace_dump_member_end(); /* u */
+
+   trace_dump_member(uint, state, swizzle_r);
+   trace_dump_member(uint, state, swizzle_g);
+   trace_dump_member(uint, state, swizzle_b);
+   trace_dump_member(uint, state, swizzle_a);
+
+   trace_dump_struct_end();
+}
+
+
+void trace_dump_surface_template(const struct pipe_surface *state,
+                                 enum pipe_texture_target target)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if(!state) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_surface");
 
    trace_dump_member(format, state, format);
    trace_dump_member(uint, state, width);
    trace_dump_member(uint, state, height);
 
-   trace_dump_member(uint, state, layout);
-   trace_dump_member(uint, state, offset);
-   trace_dump_member(uint, state, usage);
-
-   trace_dump_member(ptr, state, texture);
-   trace_dump_member(uint, state, face);
-   trace_dump_member(uint, state, level);
-   trace_dump_member(uint, state, zslice);
+   trace_dump_member_begin("u");
+   trace_dump_struct_begin(""); /* anonymous */
+   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_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, level);
+      trace_dump_member(uint, &state->u.tex, first_layer);
+      trace_dump_member(uint, &state->u.tex, last_layer);
+      trace_dump_struct_end(); /* anonymous */
+      trace_dump_member_end(); /* tex */
+   }
+   trace_dump_struct_end(); /* anonymous */
+   trace_dump_member_end(); /* u */
 
    trace_dump_struct_end();
 }
@@ -478,16 +582,18 @@ void trace_dump_transfer(const struct pipe_transfer *state)
 
    trace_dump_struct_begin("pipe_transfer");
 
-   trace_dump_member(uint, state, width);
-   trace_dump_member(uint, state, height);
+   trace_dump_member(uint, state, box.x);
+   trace_dump_member(uint, state, box.y);
+   trace_dump_member(uint, state, box.z);
+   trace_dump_member(uint, state, box.width);
+   trace_dump_member(uint, state, box.height);
+   trace_dump_member(uint, state, box.depth);
 
    trace_dump_member(uint, state, stride);
+   trace_dump_member(uint, state, layer_stride);
    trace_dump_member(uint, state, usage);
 
-   trace_dump_member(ptr, state, texture);
-   trace_dump_member(uint, state, face);
-   trace_dump_member(uint, state, level);
-   trace_dump_member(uint, state, zslice);
+   trace_dump_member(ptr, state, resource);
 
    trace_dump_struct_end();
 }
@@ -506,9 +612,28 @@ 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(uint, state, max_index);
    trace_dump_member(uint, state, buffer_offset);
-   trace_dump_member(buffer_ptr, state, buffer);
+   trace_dump_member(resource_ptr, state, buffer);
+
+   trace_dump_struct_end();
+}
+
+
+void trace_dump_index_buffer(const struct pipe_index_buffer *state)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if(!state) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_index_buffer");
+
+   trace_dump_member(uint, state, index_size);
+   trace_dump_member(uint, state, offset);
+   trace_dump_member(resource_ptr, state, buffer);
 
    trace_dump_struct_end();
 }
@@ -529,9 +654,117 @@ void trace_dump_vertex_element(const struct pipe_vertex_element *state)
    trace_dump_member(uint, state, src_offset);
 
    trace_dump_member(uint, state, vertex_buffer_index);
-   trace_dump_member(uint, state, nr_components);
 
    trace_dump_member(format, state, src_format);
 
    trace_dump_struct_end();
 }
+
+
+void trace_dump_constant_buffer(const struct pipe_constant_buffer *state)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   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_end();
+}
+
+
+void trace_dump_draw_info(const struct pipe_draw_info *state)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if(!state) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_draw_info");
+
+   trace_dump_member(bool, state, indexed);
+
+   trace_dump_member(uint, state, mode);
+   trace_dump_member(uint, state, start);
+   trace_dump_member(uint, state, count);
+
+   trace_dump_member(uint, state, start_instance);
+   trace_dump_member(uint, state, instance_count);
+
+   trace_dump_member(int,  state, index_bias);
+   trace_dump_member(uint, state, min_index);
+   trace_dump_member(uint, state, max_index);
+
+   trace_dump_member(bool, state, primitive_restart);
+   trace_dump_member(uint, state, restart_index);
+
+   trace_dump_member(ptr, state, count_from_stream_output);
+
+   trace_dump_struct_end();
+}
+
+void trace_dump_blit_info(const struct pipe_blit_info *info)
+{
+   char mask[7];
+
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if (!info) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_blit_info");
+
+   trace_dump_member_begin("dst");
+   trace_dump_struct_begin("dst");
+   trace_dump_member(resource_ptr, &info->dst, resource);
+   trace_dump_member(uint, &info->dst, level);
+   trace_dump_member(format, &info->dst, format);
+   trace_dump_member_begin("box");
+   trace_dump_box(&info->dst.box);
+   trace_dump_member_end();
+   trace_dump_struct_end();
+   trace_dump_member_end();
+
+   trace_dump_member_begin("src");
+   trace_dump_struct_begin("src");
+   trace_dump_member(resource_ptr, &info->src, resource);
+   trace_dump_member(uint, &info->src, level);
+   trace_dump_member(format, &info->src, format);
+   trace_dump_member_begin("box");
+   trace_dump_box(&info->src.box);
+   trace_dump_member_end();
+   trace_dump_struct_end();
+   trace_dump_member_end();
+
+   mask[0] = (info->mask & PIPE_MASK_R) ? 'R' : '-';
+   mask[1] = (info->mask & PIPE_MASK_G) ? 'G' : '-';
+   mask[2] = (info->mask & PIPE_MASK_B) ? 'B' : '-';
+   mask[3] = (info->mask & PIPE_MASK_A) ? 'A' : '-';
+   mask[4] = (info->mask & PIPE_MASK_Z) ? 'Z' : '-';
+   mask[5] = (info->mask & PIPE_MASK_S) ? 'S' : '-';
+   mask[6] = 0;
+
+   trace_dump_member_begin("mask");
+   trace_dump_string(mask);
+   trace_dump_member_end();
+   trace_dump_member(uint, info, filter);
+
+   trace_dump_member(bool, info, scissor_enable);
+   trace_dump_member_begin("scissor");
+   trace_dump_scissor_state(&info->scissor);
+   trace_dump_member_end();
+
+   trace_dump_struct_end();
+}