u_dump_state.c revision dc4c821f0817a3db716f965692fb701079f66340
1/************************************************************************** 2 * 3 * Copyright 2008-2010 VMware, Inc. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28 29#include "pipe/p_compiler.h" 30#include "util/u_memory.h" 31#include "util/u_string.h" 32#include "util/u_format.h" 33#include "tgsi/tgsi_dump.h" 34 35#include "u_dump.h" 36 37 38/* 39 * Dump primitives 40 */ 41 42static INLINE void 43util_stream_writef(FILE *stream, const char *format, ...) 44{ 45 static char buf[1024]; 46 unsigned len; 47 va_list ap; 48 va_start(ap, format); 49 len = util_vsnprintf(buf, sizeof(buf), format, ap); 50 va_end(ap); 51 fwrite(buf, len, 1, stream); 52} 53 54static void 55util_dump_bool(FILE *stream, int value) 56{ 57 util_stream_writef(stream, "%c", value ? '1' : '0'); 58} 59 60static void 61util_dump_int(FILE *stream, long long int value) 62{ 63 util_stream_writef(stream, "%lli", value); 64} 65 66static void 67util_dump_uint(FILE *stream, long long unsigned value) 68{ 69 util_stream_writef(stream, "%llu", value); 70} 71 72static void 73util_dump_float(FILE *stream, double value) 74{ 75 util_stream_writef(stream, "%g", value); 76} 77 78static void 79util_dump_string(FILE *stream, const char *str) 80{ 81 fputs("\"", stream); 82 fputs(str, stream); 83 fputs("\"", stream); 84} 85 86static void 87util_dump_enum(FILE *stream, const char *value) 88{ 89 fputs(value, stream); 90} 91 92static void 93util_dump_array_begin(FILE *stream) 94{ 95 fputs("{", stream); 96} 97 98static void 99util_dump_array_end(FILE *stream) 100{ 101 fputs("}", stream); 102} 103 104static void 105util_dump_elem_begin(FILE *stream) 106{ 107} 108 109static void 110util_dump_elem_end(FILE *stream) 111{ 112 fputs(", ", stream); 113} 114 115static void 116util_dump_struct_begin(FILE *stream, const char *name) 117{ 118 fputs("{", stream); 119} 120 121static void 122util_dump_struct_end(FILE *stream) 123{ 124 fputs("}", stream); 125} 126 127static void 128util_dump_member_begin(FILE *stream, const char *name) 129{ 130 util_stream_writef(stream, "%s = ", name); 131} 132 133static void 134util_dump_member_end(FILE *stream) 135{ 136 fputs(", ", stream); 137} 138 139static void 140util_dump_null(FILE *stream) 141{ 142 fputs("NULL", stream); 143} 144 145static void 146util_dump_ptr(FILE *stream, const void *value) 147{ 148 if(value) 149 util_stream_writef(stream, "0x%08lx", (unsigned long)(uintptr_t)value); 150 else 151 util_dump_null(stream); 152} 153 154 155/* 156 * Code saving macros. 157 */ 158 159#define util_dump_arg(_stream, _type, _arg) \ 160 do { \ 161 util_dump_arg_begin(_stream, #_arg); \ 162 util_dump_##_type(_stream, _arg); \ 163 util_dump_arg_end(_stream); \ 164 } while(0) 165 166#define util_dump_ret(_stream, _type, _arg) \ 167 do { \ 168 util_dump_ret_begin(_stream); \ 169 util_dump_##_type(_stream, _arg); \ 170 util_dump_ret_end(_stream); \ 171 } while(0) 172 173#define util_dump_array(_stream, _type, _obj, _size) \ 174 do { \ 175 size_t idx; \ 176 util_dump_array_begin(_stream); \ 177 for(idx = 0; idx < (_size); ++idx) { \ 178 util_dump_elem_begin(_stream); \ 179 util_dump_##_type(_stream, (_obj)[idx]); \ 180 util_dump_elem_end(_stream); \ 181 } \ 182 util_dump_array_end(_stream); \ 183 } while(0) 184 185#define util_dump_struct_array(_stream, _type, _obj, _size) \ 186 do { \ 187 size_t idx; \ 188 util_dump_array_begin(_stream); \ 189 for(idx = 0; idx < (_size); ++idx) { \ 190 util_dump_elem_begin(_stream); \ 191 util_dump_##_type(_stream, &(_obj)[idx]); \ 192 util_dump_elem_end(_stream); \ 193 } \ 194 util_dump_array_end(_stream); \ 195 } while(0) 196 197#define util_dump_member(_stream, _type, _obj, _member) \ 198 do { \ 199 util_dump_member_begin(_stream, #_member); \ 200 util_dump_##_type(_stream, (_obj)->_member); \ 201 util_dump_member_end(_stream); \ 202 } while(0) 203 204#define util_dump_arg_array(_stream, _type, _arg, _size) \ 205 do { \ 206 util_dump_arg_begin(_stream, #_arg); \ 207 util_dump_array(_stream, _type, _arg, _size); \ 208 util_dump_arg_end(_stream); \ 209 } while(0) 210 211#define util_dump_member_array(_stream, _type, _obj, _member) \ 212 do { \ 213 util_dump_member_begin(_stream, #_member); \ 214 util_dump_array(_stream, _type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \ 215 util_dump_member_end(_stream); \ 216 } while(0) 217 218 219 220/* 221 * Wrappers for enum -> string dumpers. 222 */ 223 224 225static void 226util_dump_format(FILE *stream, enum pipe_format format) 227{ 228 util_dump_enum(stream, util_format_name(format)); 229} 230 231 232static void 233util_dump_enum_blend_factor(FILE *stream, unsigned value) 234{ 235 util_dump_enum(stream, util_dump_blend_factor(value, TRUE)); 236} 237 238static void 239util_dump_enum_blend_func(FILE *stream, unsigned value) 240{ 241 util_dump_enum(stream, util_dump_blend_func(value, TRUE)); 242} 243 244static void 245util_dump_enum_func(FILE *stream, unsigned value) 246{ 247 util_dump_enum(stream, util_dump_func(value, TRUE)); 248} 249 250 251/* 252 * Public functions 253 */ 254 255 256void 257util_dump_template(FILE *stream, const struct pipe_resource *templat) 258{ 259 if(!templat) { 260 util_dump_null(stream); 261 return; 262 } 263 264 util_dump_struct_begin(stream, "pipe_resource"); 265 266 util_dump_member(stream, int, templat, target); 267 util_dump_member(stream, format, templat, format); 268 269 util_dump_member_begin(stream, "width"); 270 util_dump_uint(stream, templat->width0); 271 util_dump_member_end(stream); 272 273 util_dump_member_begin(stream, "height"); 274 util_dump_uint(stream, templat->height0); 275 util_dump_member_end(stream); 276 277 util_dump_member_begin(stream, "depth"); 278 util_dump_uint(stream, templat->depth0); 279 util_dump_member_end(stream); 280 281 util_dump_member_begin(stream, "array_size"); 282 util_dump_uint(stream, templat->array_size); 283 util_dump_member_end(stream); 284 285 util_dump_member(stream, uint, templat, last_level); 286 util_dump_member(stream, uint, templat, usage); 287 util_dump_member(stream, uint, templat, bind); 288 util_dump_member(stream, uint, templat, flags); 289 290 util_dump_struct_end(stream); 291} 292 293 294void 295util_dump_rasterizer_state(FILE *stream, const struct pipe_rasterizer_state *state) 296{ 297 if(!state) { 298 util_dump_null(stream); 299 return; 300 } 301 302 util_dump_struct_begin(stream, "pipe_rasterizer_state"); 303 304 util_dump_member(stream, bool, state, flatshade); 305 util_dump_member(stream, bool, state, light_twoside); 306 util_dump_member(stream, bool, state, clamp_vertex_color); 307 util_dump_member(stream, bool, state, clamp_fragment_color); 308 util_dump_member(stream, uint, state, front_ccw); 309 util_dump_member(stream, uint, state, cull_face); 310 util_dump_member(stream, uint, state, fill_front); 311 util_dump_member(stream, uint, state, fill_back); 312 util_dump_member(stream, bool, state, offset_point); 313 util_dump_member(stream, bool, state, offset_line); 314 util_dump_member(stream, bool, state, offset_tri); 315 util_dump_member(stream, bool, state, scissor); 316 util_dump_member(stream, bool, state, poly_smooth); 317 util_dump_member(stream, bool, state, poly_stipple_enable); 318 util_dump_member(stream, bool, state, point_smooth); 319 util_dump_member(stream, uint, state, sprite_coord_enable); 320 util_dump_member(stream, bool, state, sprite_coord_mode); 321 util_dump_member(stream, bool, state, point_quad_rasterization); 322 util_dump_member(stream, bool, state, point_size_per_vertex); 323 util_dump_member(stream, bool, state, multisample); 324 util_dump_member(stream, bool, state, line_smooth); 325 util_dump_member(stream, bool, state, line_stipple_enable); 326 util_dump_member(stream, uint, state, line_stipple_factor); 327 util_dump_member(stream, uint, state, line_stipple_pattern); 328 util_dump_member(stream, bool, state, line_last_pixel); 329 util_dump_member(stream, bool, state, flatshade_first); 330 util_dump_member(stream, bool, state, gl_rasterization_rules); 331 util_dump_member(stream, bool, state, rasterizer_discard); 332 util_dump_member(stream, bool, state, depth_clip); 333 util_dump_member(stream, uint, state, clip_plane_enable); 334 335 util_dump_member(stream, float, state, line_width); 336 util_dump_member(stream, float, state, point_size); 337 util_dump_member(stream, float, state, offset_units); 338 util_dump_member(stream, float, state, offset_scale); 339 util_dump_member(stream, float, state, offset_clamp); 340 341 util_dump_struct_end(stream); 342} 343 344 345void 346util_dump_poly_stipple(FILE *stream, const struct pipe_poly_stipple *state) 347{ 348 if(!state) { 349 util_dump_null(stream); 350 return; 351 } 352 353 util_dump_struct_begin(stream, "pipe_poly_stipple"); 354 355 util_dump_member_begin(stream, "stipple"); 356 util_dump_member_array(stream, uint, state, stipple); 357 util_dump_member_end(stream); 358 359 util_dump_struct_end(stream); 360} 361 362 363void 364util_dump_viewport_state(FILE *stream, const struct pipe_viewport_state *state) 365{ 366 if(!state) { 367 util_dump_null(stream); 368 return; 369 } 370 371 util_dump_struct_begin(stream, "pipe_viewport_state"); 372 373 util_dump_member_array(stream, float, state, scale); 374 util_dump_member_array(stream, float, state, translate); 375 376 util_dump_struct_end(stream); 377} 378 379 380void 381util_dump_scissor_state(FILE *stream, const struct pipe_scissor_state *state) 382{ 383 if(!state) { 384 util_dump_null(stream); 385 return; 386 } 387 388 util_dump_struct_begin(stream, "pipe_scissor_state"); 389 390 util_dump_member(stream, uint, state, minx); 391 util_dump_member(stream, uint, state, miny); 392 util_dump_member(stream, uint, state, maxx); 393 util_dump_member(stream, uint, state, maxy); 394 395 util_dump_struct_end(stream); 396} 397 398 399void 400util_dump_clip_state(FILE *stream, const struct pipe_clip_state *state) 401{ 402 unsigned i; 403 404 if(!state) { 405 util_dump_null(stream); 406 return; 407 } 408 409 util_dump_struct_begin(stream, "pipe_clip_state"); 410 411 util_dump_member_begin(stream, "ucp"); 412 util_dump_array_begin(stream); 413 for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) { 414 util_dump_elem_begin(stream); 415 util_dump_array(stream, float, state->ucp[i], 4); 416 util_dump_elem_end(stream); 417 } 418 util_dump_array_end(stream); 419 util_dump_member_end(stream); 420 421 util_dump_struct_end(stream); 422} 423 424 425void 426util_dump_shader_state(FILE *stream, const struct pipe_shader_state *state) 427{ 428 char str[8192]; 429 unsigned i; 430 431 if(!state) { 432 util_dump_null(stream); 433 return; 434 } 435 436 tgsi_dump_str(state->tokens, 0, str, sizeof(str)); 437 438 util_dump_struct_begin(stream, "pipe_shader_state"); 439 440 util_dump_member_begin(stream, "tokens"); 441 util_dump_string(stream, str); 442 util_dump_member_end(stream); 443 444 util_dump_member_begin(stream, "stream_output"); 445 util_dump_struct_begin(stream, "pipe_stream_output_info"); 446 util_dump_member(stream, uint, &state->stream_output, num_outputs); 447 util_dump_member(stream, uint, &state->stream_output, stride); 448 util_dump_array_begin(stream); 449 for(i = 0; i < state->stream_output.num_outputs; ++i) { 450 util_dump_elem_begin(stream); 451 util_dump_struct_begin(stream, ""); /* anonymous */ 452 util_dump_member(stream, uint, &state->stream_output.output[i], register_index); 453 util_dump_member(stream, uint, &state->stream_output.output[i], register_mask); 454 util_dump_member(stream, uint, &state->stream_output.output[i], output_buffer); 455 util_dump_struct_end(stream); 456 util_dump_elem_end(stream); 457 } 458 util_dump_array_end(stream); 459 util_dump_struct_end(stream); 460 util_dump_member_end(stream); 461 462 util_dump_struct_end(stream); 463} 464 465 466void 467util_dump_depth_stencil_alpha_state(FILE *stream, const struct pipe_depth_stencil_alpha_state *state) 468{ 469 unsigned i; 470 471 if(!state) { 472 util_dump_null(stream); 473 return; 474 } 475 476 util_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state"); 477 478 util_dump_member_begin(stream, "depth"); 479 util_dump_struct_begin(stream, "pipe_depth_state"); 480 util_dump_member(stream, bool, &state->depth, enabled); 481 if (state->depth.enabled) { 482 util_dump_member(stream, bool, &state->depth, writemask); 483 util_dump_member(stream, enum_func, &state->depth, func); 484 } 485 util_dump_struct_end(stream); 486 util_dump_member_end(stream); 487 488 util_dump_member_begin(stream, "stencil"); 489 util_dump_array_begin(stream); 490 for(i = 0; i < Elements(state->stencil); ++i) { 491 util_dump_elem_begin(stream); 492 util_dump_struct_begin(stream, "pipe_stencil_state"); 493 util_dump_member(stream, bool, &state->stencil[i], enabled); 494 if (state->stencil[i].enabled) { 495 util_dump_member(stream, enum_func, &state->stencil[i], func); 496 util_dump_member(stream, uint, &state->stencil[i], fail_op); 497 util_dump_member(stream, uint, &state->stencil[i], zpass_op); 498 util_dump_member(stream, uint, &state->stencil[i], zfail_op); 499 util_dump_member(stream, uint, &state->stencil[i], valuemask); 500 util_dump_member(stream, uint, &state->stencil[i], writemask); 501 } 502 util_dump_struct_end(stream); 503 util_dump_elem_end(stream); 504 } 505 util_dump_array_end(stream); 506 util_dump_member_end(stream); 507 508 util_dump_member_begin(stream, "alpha"); 509 util_dump_struct_begin(stream, "pipe_alpha_state"); 510 util_dump_member(stream, bool, &state->alpha, enabled); 511 if (state->alpha.enabled) { 512 util_dump_member(stream, enum_func, &state->alpha, func); 513 util_dump_member(stream, float, &state->alpha, ref_value); 514 } 515 util_dump_struct_end(stream); 516 util_dump_member_end(stream); 517 518 util_dump_struct_end(stream); 519} 520 521void 522util_dump_rt_blend_state(FILE *stream, const struct pipe_rt_blend_state *state) 523{ 524 util_dump_struct_begin(stream, "pipe_rt_blend_state"); 525 526 util_dump_member(stream, uint, state, blend_enable); 527 if (state->blend_enable) { 528 util_dump_member(stream, enum_blend_func, state, rgb_func); 529 util_dump_member(stream, enum_blend_factor, state, rgb_src_factor); 530 util_dump_member(stream, enum_blend_factor, state, rgb_dst_factor); 531 532 util_dump_member(stream, enum_blend_func, state, alpha_func); 533 util_dump_member(stream, enum_blend_factor, state, alpha_src_factor); 534 util_dump_member(stream, enum_blend_factor, state, alpha_dst_factor); 535 } 536 537 util_dump_member(stream, uint, state, colormask); 538 539 util_dump_struct_end(stream); 540} 541 542void 543util_dump_blend_state(FILE *stream, const struct pipe_blend_state *state) 544{ 545 unsigned valid_entries = 1; 546 547 if(!state) { 548 util_dump_null(stream); 549 return; 550 } 551 552 util_dump_struct_begin(stream, "pipe_blend_state"); 553 554 util_dump_member(stream, bool, state, dither); 555 556 util_dump_member(stream, bool, state, logicop_enable); 557 if (state->logicop_enable) { 558 util_dump_member(stream, enum_func, state, logicop_func); 559 } 560 else { 561 util_dump_member(stream, bool, state, independent_blend_enable); 562 563 util_dump_member_begin(stream, "rt"); 564 if (state->independent_blend_enable) 565 valid_entries = PIPE_MAX_COLOR_BUFS; 566 util_dump_struct_array(stream, rt_blend_state, state->rt, valid_entries); 567 util_dump_member_end(stream); 568 } 569 570 util_dump_struct_end(stream); 571} 572 573 574void 575util_dump_blend_color(FILE *stream, const struct pipe_blend_color *state) 576{ 577 if(!state) { 578 util_dump_null(stream); 579 return; 580 } 581 582 util_dump_struct_begin(stream, "pipe_blend_color"); 583 584 util_dump_member_array(stream, float, state, color); 585 586 util_dump_struct_end(stream); 587} 588 589void 590util_dump_stencil_ref(FILE *stream, const struct pipe_stencil_ref *state) 591{ 592 if(!state) { 593 util_dump_null(stream); 594 return; 595 } 596 597 util_dump_struct_begin(stream, "pipe_stencil_ref"); 598 599 util_dump_member_array(stream, uint, state, ref_value); 600 601 util_dump_struct_end(stream); 602} 603 604void 605util_dump_framebuffer_state(FILE *stream, const struct pipe_framebuffer_state *state) 606{ 607 util_dump_struct_begin(stream, "pipe_framebuffer_state"); 608 609 util_dump_member(stream, uint, state, width); 610 util_dump_member(stream, uint, state, height); 611 util_dump_member(stream, uint, state, nr_cbufs); 612 util_dump_member_array(stream, ptr, state, cbufs); 613 util_dump_member(stream, ptr, state, zsbuf); 614 615 util_dump_struct_end(stream); 616} 617 618 619void 620util_dump_sampler_state(FILE *stream, const struct pipe_sampler_state *state) 621{ 622 if(!state) { 623 util_dump_null(stream); 624 return; 625 } 626 627 util_dump_struct_begin(stream, "pipe_sampler_state"); 628 629 util_dump_member(stream, uint, state, wrap_s); 630 util_dump_member(stream, uint, state, wrap_t); 631 util_dump_member(stream, uint, state, wrap_r); 632 util_dump_member(stream, uint, state, min_img_filter); 633 util_dump_member(stream, uint, state, min_mip_filter); 634 util_dump_member(stream, uint, state, mag_img_filter); 635 util_dump_member(stream, uint, state, compare_mode); 636 util_dump_member(stream, enum_func, state, compare_func); 637 util_dump_member(stream, bool, state, normalized_coords); 638 util_dump_member(stream, uint, state, max_anisotropy); 639 util_dump_member(stream, float, state, lod_bias); 640 util_dump_member(stream, float, state, min_lod); 641 util_dump_member(stream, float, state, max_lod); 642 util_dump_member_array(stream, float, state, border_color.f); 643 644 util_dump_struct_end(stream); 645} 646 647 648void 649util_dump_surface(FILE *stream, const struct pipe_surface *state) 650{ 651 if(!state) { 652 util_dump_null(stream); 653 return; 654 } 655 656 util_dump_struct_begin(stream, "pipe_surface"); 657 658 util_dump_member(stream, format, state, format); 659 util_dump_member(stream, uint, state, width); 660 util_dump_member(stream, uint, state, height); 661 662 util_dump_member(stream, uint, state, usage); 663 664 util_dump_member(stream, ptr, state, texture); 665 util_dump_member(stream, uint, state, u.tex.level); 666 util_dump_member(stream, uint, state, u.tex.first_layer); 667 util_dump_member(stream, uint, state, u.tex.last_layer); 668 669 util_dump_struct_end(stream); 670} 671 672 673void 674util_dump_transfer(FILE *stream, const struct pipe_transfer *state) 675{ 676 if(!state) { 677 util_dump_null(stream); 678 return; 679 } 680 681 util_dump_struct_begin(stream, "pipe_transfer"); 682 683 util_dump_member(stream, ptr, state, resource); 684 /*util_dump_member(stream, uint, state, box);*/ 685 686 util_dump_member(stream, uint, state, stride); 687 util_dump_member(stream, uint, state, layer_stride); 688 689 /*util_dump_member(stream, ptr, state, data);*/ 690 691 util_dump_struct_end(stream); 692} 693 694 695void 696util_dump_vertex_buffer(FILE *stream, const struct pipe_vertex_buffer *state) 697{ 698 if(!state) { 699 util_dump_null(stream); 700 return; 701 } 702 703 util_dump_struct_begin(stream, "pipe_vertex_buffer"); 704 705 util_dump_member(stream, uint, state, stride); 706 util_dump_member(stream, uint, state, buffer_offset); 707 util_dump_member(stream, ptr, state, buffer); 708 709 util_dump_struct_end(stream); 710} 711 712 713void 714util_dump_vertex_element(FILE *stream, const struct pipe_vertex_element *state) 715{ 716 if(!state) { 717 util_dump_null(stream); 718 return; 719 } 720 721 util_dump_struct_begin(stream, "pipe_vertex_element"); 722 723 util_dump_member(stream, uint, state, src_offset); 724 725 util_dump_member(stream, uint, state, vertex_buffer_index); 726 727 util_dump_member(stream, format, state, src_format); 728 729 util_dump_struct_end(stream); 730} 731 732 733void 734util_dump_draw_info(FILE *stream, const struct pipe_draw_info *state) 735{ 736 if(!state) { 737 util_dump_null(stream); 738 return; 739 } 740 741 util_dump_struct_begin(stream, "pipe_draw_info"); 742 743 util_dump_member(stream, bool, state, indexed); 744 745 util_dump_member(stream, uint, state, mode); 746 util_dump_member(stream, uint, state, start); 747 util_dump_member(stream, uint, state, count); 748 749 util_dump_member(stream, uint, state, start_instance); 750 util_dump_member(stream, uint, state, instance_count); 751 752 util_dump_member(stream, int, state, index_bias); 753 util_dump_member(stream, uint, state, min_index); 754 util_dump_member(stream, uint, state, max_index); 755 756 util_dump_member(stream, bool, state, primitive_restart); 757 util_dump_member(stream, uint, state, restart_index); 758 759 util_dump_member(stream, ptr, state, count_from_stream_output); 760 761 util_dump_struct_end(stream); 762} 763