/**************************************************************************
*
- * 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
* 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.
#include "tgsi/tgsi_dump.h"
#include "tr_dump.h"
+#include "tr_dump_defines.h"
#include "tr_dump_state.h"
-void trace_dump_format(enum pipe_format format)
-{
- if (!trace_dumping_enabled_locked())
- return;
-
- trace_dump_enum(util_format_name(format) );
-}
-
-
void trace_dump_resource_template(const struct pipe_resource *templat)
{
if (!trace_dumping_enabled_locked())
return;
- if(!templat) {
+ if (!templat) {
trace_dump_null();
return;
}
if (!trace_dumping_enabled_locked())
return;
- if(!box) {
+ if (!box) {
trace_dump_null();
return;
}
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
trace_dump_member(bool, state, poly_smooth);
trace_dump_member(bool, state, poly_stipple_enable);
trace_dump_member(bool, state, point_smooth);
- trace_dump_member(uint, state, sprite_coord_enable);
trace_dump_member(bool, state, sprite_coord_mode);
trace_dump_member(bool, state, point_quad_rasterization);
trace_dump_member(bool, state, point_size_per_vertex);
trace_dump_member(bool, state, multisample);
trace_dump_member(bool, state, line_smooth);
trace_dump_member(bool, state, line_stipple_enable);
- 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, flatshade_first);
+
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(bool, state, clip_halfz);
+
trace_dump_member(uint, state, clip_plane_enable);
+ trace_dump_member(uint, state, line_stipple_factor);
+ trace_dump_member(uint, state, line_stipple_pattern);
+
+ trace_dump_member(uint, state, sprite_coord_enable);
+
trace_dump_member(float, state, line_width);
trace_dump_member(float, state, point_size);
trace_dump_member(float, state, offset_units);
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
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();
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
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_member(uint, &state->stream_output.output[i], stream);
trace_dump_struct_end();
trace_dump_elem_end();
}
}
+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;
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
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);
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
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);
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
trace_dump_member(uint, state, compare_func);
trace_dump_member(bool, state, normalized_coords);
trace_dump_member(uint, state, max_anisotropy);
+ trace_dump_member(bool, state, seamless_cube_map);
trace_dump_member(float, state, lod_bias);
trace_dump_member(float, state, min_lod);
trace_dump_member(float, state, max_lod);
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
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 {
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
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, 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;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
- trace_dump_struct_begin("pipe_index_buffer");
+ trace_dump_struct_begin("pipe_vertex_element");
- trace_dump_member(uint, state, index_size);
- trace_dump_member(uint, state, offset);
- trace_dump_member(resource_ptr, state, buffer);
+ trace_dump_member(uint, state, src_offset);
+
+ 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;
- if(!state) {
+ if (!state) {
trace_dump_null();
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;
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();
}
if (!trace_dumping_enabled_locked())
return;
- if(!state) {
+ if (!state) {
trace_dump_null();
return;
}
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);
trace_dump_member(uint, state, start_instance);
trace_dump_member(uint, state, instance_count);
+ trace_dump_member(uint, state, vertices_per_patch);
+
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, index.resource);
trace_dump_member(ptr, state, count_from_stream_output);
+ 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();
}
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");
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");
trace_dump_struct_end();
}
+
+void
+trace_dump_query_result(unsigned query_type,
+ const union pipe_query_result *result)
+{
+ if (!trace_dumping_enabled_locked())
+ return;
+
+ if (!result) {
+ trace_dump_null();
+ return;
+ }
+
+ switch (query_type) {
+ case PIPE_QUERY_OCCLUSION_PREDICATE:
+ case PIPE_QUERY_SO_OVERFLOW_PREDICATE:
+ case PIPE_QUERY_GPU_FINISHED:
+ trace_dump_bool(result->b);
+ break;
+
+ case PIPE_QUERY_OCCLUSION_COUNTER:
+ case PIPE_QUERY_TIMESTAMP:
+ case PIPE_QUERY_TIME_ELAPSED:
+ case PIPE_QUERY_PRIMITIVES_GENERATED:
+ case PIPE_QUERY_PRIMITIVES_EMITTED:
+ trace_dump_uint(result->u64);
+ break;
+
+ case PIPE_QUERY_SO_STATISTICS:
+ trace_dump_struct_begin("pipe_query_data_so_statistics");
+ trace_dump_member(uint, &result->so_statistics, num_primitives_written);
+ trace_dump_member(uint, &result->so_statistics, primitives_storage_needed);
+ trace_dump_struct_end();
+ break;
+
+ case PIPE_QUERY_TIMESTAMP_DISJOINT:
+ trace_dump_struct_begin("pipe_query_data_timestamp_disjoint");
+ trace_dump_member(uint, &result->timestamp_disjoint, frequency);
+ trace_dump_member(bool, &result->timestamp_disjoint, disjoint);
+ trace_dump_struct_end();
+ break;
+
+ case PIPE_QUERY_PIPELINE_STATISTICS:
+ trace_dump_struct_begin("pipe_query_data_pipeline_statistics");
+ trace_dump_member(uint, &result->pipeline_statistics, ia_vertices);
+ trace_dump_member(uint, &result->pipeline_statistics, ia_primitives);
+ trace_dump_member(uint, &result->pipeline_statistics, vs_invocations);
+ trace_dump_member(uint, &result->pipeline_statistics, gs_invocations);
+ trace_dump_member(uint, &result->pipeline_statistics, gs_primitives);
+ trace_dump_member(uint, &result->pipeline_statistics, c_invocations);
+ trace_dump_member(uint, &result->pipeline_statistics, c_primitives);
+ trace_dump_member(uint, &result->pipeline_statistics, ps_invocations);
+ trace_dump_member(uint, &result->pipeline_statistics, hs_invocations);
+ trace_dump_member(uint, &result->pipeline_statistics, ds_invocations);
+ trace_dump_member(uint, &result->pipeline_statistics, cs_invocations);
+ trace_dump_struct_end();
+ break;
+
+ default:
+ assert(query_type >= PIPE_QUERY_DRIVER_SPECIFIC);
+ trace_dump_uint(result->u64);
+ 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();
+}
+
projects / mesa.git / blobdiff