src/gallium/drivers/trace/tr_screen.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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 #include "util/u_format.h"
  29 #include "util/u_memory.h"
  30 #include "util/u_simple_list.h"
  31
  32 #include "tr_buffer.h"
  33 #include "tr_dump.h"
  34 #include "tr_dump_state.h"
  35 #include "tr_texture.h"
  36 #include "tr_context.h"
  37 #include "tr_screen.h"
  38 #include "tr_public.h"
  39
  40 #include "util/u_inlines.h"
  41 #include "pipe/p_format.h"
  42
  43
  44 static boolean trace = FALSE;
  45 static boolean rbug = FALSE;
  46
  47 static const char *
  48 trace_screen_get_name(struct pipe_screen *_screen)
  49 {
  50    struct trace_screen *tr_scr = trace_screen(_screen);
  51    struct pipe_screen *screen = tr_scr->screen;
  52    const char *result;
  53
  54    trace_dump_call_begin("pipe_screen", "get_name");
  55
  56    trace_dump_arg(ptr, screen);
  57
  58    result = screen->get_name(screen);
  59
  60    trace_dump_ret(string, result);
  61
  62    trace_dump_call_end();
  63
  64    return result;
  65 }
  66
  67
  68 static const char *
  69 trace_screen_get_vendor(struct pipe_screen *_screen)
  70 {
  71    struct trace_screen *tr_scr = trace_screen(_screen);
  72    struct pipe_screen *screen = tr_scr->screen;
  73    const char *result;
  74
  75    trace_dump_call_begin("pipe_screen", "get_vendor");
  76
  77    trace_dump_arg(ptr, screen);
  78
  79    result = screen->get_vendor(screen);
  80
  81    trace_dump_ret(string, result);
  82
  83    trace_dump_call_end();
  84
  85    return result;
  86 }
  87
  88
  89 static int
  90 trace_screen_get_param(struct pipe_screen *_screen,
  91                        int param)
  92 {
  93    struct trace_screen *tr_scr = trace_screen(_screen);
  94    struct pipe_screen *screen = tr_scr->screen;
  95    int result;
  96
  97    trace_dump_call_begin("pipe_screen", "get_param");
  98
  99    trace_dump_arg(ptr, screen);
 100    trace_dump_arg(int, param);
 101
 102    result = screen->get_param(screen, param);
 103
 104    trace_dump_ret(int, result);
 105
 106    trace_dump_call_end();
 107
 108    return result;
 109 }
 110
 111
 112 static float
 113 trace_screen_get_paramf(struct pipe_screen *_screen,
 114                         int param)
 115 {
 116    struct trace_screen *tr_scr = trace_screen(_screen);
 117    struct pipe_screen *screen = tr_scr->screen;
 118    float result;
 119
 120    trace_dump_call_begin("pipe_screen", "get_paramf");
 121
 122    trace_dump_arg(ptr, screen);
 123    trace_dump_arg(int, param);
 124
 125    result = screen->get_paramf(screen, param);
 126
 127    trace_dump_ret(float, result);
 128
 129    trace_dump_call_end();
 130
 131    return result;
 132 }
 133
 134
 135 static boolean
 136 trace_screen_is_format_supported(struct pipe_screen *_screen,
 137                                  enum pipe_format format,
 138                                  enum pipe_texture_target target,
 139                                  unsigned tex_usage,
 140                                  unsigned geom_flags)
 141 {
 142    struct trace_screen *tr_scr = trace_screen(_screen);
 143    struct pipe_screen *screen = tr_scr->screen;
 144    boolean result;
 145
 146    trace_dump_call_begin("pipe_screen", "is_format_supported");
 147
 148    trace_dump_arg(ptr, screen);
 149    trace_dump_arg(format, format);
 150    trace_dump_arg(int, target);
 151    trace_dump_arg(uint, tex_usage);
 152    trace_dump_arg(uint, geom_flags);
 153
 154    result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
 155
 156    trace_dump_ret(bool, result);
 157
 158    trace_dump_call_end();
 159
 160    return result;
 161 }
 162
 163
 164 static struct pipe_context *
 165 trace_screen_context_create(struct pipe_screen *_screen, void *priv)
 166 {
 167    struct trace_screen *tr_scr = trace_screen(_screen);
 168    struct pipe_screen *screen = tr_scr->screen;
 169    struct pipe_context *result;
 170
 171    trace_dump_call_begin("pipe_screen", "context_create");
 172
 173    trace_dump_arg(ptr, screen);
 174
 175    result = screen->context_create(screen, priv);
 176
 177    trace_dump_ret(ptr, result);
 178
 179    trace_dump_call_end();
 180
 181    result = trace_context_create(tr_scr, result);
 182
 183    return result;
 184 }
 185
 186
 187 static void
 188 trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
 189                                struct pipe_surface *_surface,
 190                                void *context_private)
 191 {
 192    struct trace_screen *tr_scr = trace_screen(_screen);
 193    struct trace_surface *tr_surf = trace_surface(_surface);
 194    struct pipe_screen *screen = tr_scr->screen;
 195    struct pipe_surface *surface = tr_surf->surface;
 196
 197    trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
 198
 199    trace_dump_arg(ptr, screen);
 200    trace_dump_arg(ptr, surface);
 201    /* XXX: hide, as there is nothing we can do with this
 202    trace_dump_arg(ptr, context_private);
 203    */
 204
 205    screen->flush_frontbuffer(screen, surface, context_private);
 206
 207    trace_dump_call_end();
 208 }
 209
 210
 211 /********************************************************************
 212  * texture
 213  */
 214
 215
 216 static struct pipe_texture *
 217 trace_screen_texture_create(struct pipe_screen *_screen,
 218                             const struct pipe_texture *templat)
 219 {
 220    struct trace_screen *tr_scr = trace_screen(_screen);
 221    struct pipe_screen *screen = tr_scr->screen;
 222    struct pipe_texture *result;
 223
 224    trace_dump_call_begin("pipe_screen", "texture_create");
 225
 226    trace_dump_arg(ptr, screen);
 227    trace_dump_arg(template, templat);
 228
 229    result = screen->texture_create(screen, templat);
 230
 231    trace_dump_ret(ptr, result);
 232
 233    trace_dump_call_end();
 234
 235    result = trace_texture_create(tr_scr, result);
 236
 237    return result;
 238 }
 239
 240 static struct pipe_texture *
 241 trace_screen_texture_from_handle(struct pipe_screen *_screen,
 242                                  const struct pipe_texture *templ,
 243                                  struct winsys_handle *handle)
 244 {
 245    struct trace_screen *tr_screen = trace_screen(_screen);
 246    struct pipe_screen *screen = tr_screen->screen;
 247    struct pipe_texture *result;
 248
 249    /* TODO trace call */
 250
 251    result = screen->texture_from_handle(screen, templ, handle);
 252
 253    result = trace_texture_create(trace_screen(_screen), result);
 254
 255    return result;
 256 }
 257
 258 static boolean
 259 trace_screen_texture_get_handle(struct pipe_screen *_screen,
 260                                 struct pipe_texture *_texture,
 261                                 struct winsys_handle *handle)
 262 {
 263    struct trace_screen *tr_screen = trace_screen(_screen);
 264    struct trace_texture *tr_texture = trace_texture(_texture);
 265    struct pipe_screen *screen = tr_screen->screen;
 266    struct pipe_texture *texture = tr_texture->texture;
 267
 268    /* TODO trace call */
 269
 270    return screen->texture_get_handle(screen, texture, handle);
 271 }
 272
 273
 274
 275 static void
 276 trace_screen_texture_destroy(struct pipe_texture *_texture)
 277 {
 278    struct trace_screen *tr_scr = trace_screen(_texture->screen);
 279    struct trace_texture *tr_tex = trace_texture(_texture);
 280    struct pipe_screen *screen = tr_scr->screen;
 281    struct pipe_texture *texture = tr_tex->texture;
 282
 283    assert(texture->screen == screen);
 284
 285    trace_dump_call_begin("pipe_screen", "texture_destroy");
 286
 287    trace_dump_arg(ptr, screen);
 288    trace_dump_arg(ptr, texture);
 289
 290    trace_dump_call_end();
 291
 292    trace_texture_destroy(tr_tex);
 293 }
 294
 295
 296 /********************************************************************
 297  * surface
 298  */
 299
 300
 301 static struct pipe_surface *
 302 trace_screen_get_tex_surface(struct pipe_screen *_screen,
 303                              struct pipe_texture *_texture,
 304                              unsigned face, unsigned level,
 305                              unsigned zslice,
 306                              unsigned usage)
 307 {
 308    struct trace_screen *tr_scr = trace_screen(_screen);
 309    struct trace_texture *tr_tex = trace_texture(_texture);
 310    struct pipe_screen *screen = tr_scr->screen;
 311    struct pipe_texture *texture = tr_tex->texture;
 312    struct pipe_surface *result = NULL;
 313
 314    assert(texture->screen == screen);
 315
 316    trace_dump_call_begin("pipe_screen", "get_tex_surface");
 317
 318    trace_dump_arg(ptr, screen);
 319    trace_dump_arg(ptr, texture);
 320    trace_dump_arg(uint, face);
 321    trace_dump_arg(uint, level);
 322    trace_dump_arg(uint, zslice);
 323    trace_dump_arg(uint, usage);
 324
 325    result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
 326
 327    trace_dump_ret(ptr, result);
 328
 329    trace_dump_call_end();
 330
 331    result = trace_surface_create(tr_tex, result);
 332
 333    return result;
 334 }
 335
 336
 337 static void
 338 trace_screen_tex_surface_destroy(struct pipe_surface *_surface)
 339 {
 340    struct trace_screen *tr_scr = trace_screen(_surface->texture->screen);
 341    struct trace_surface *tr_surf = trace_surface(_surface);
 342    struct pipe_screen *screen = tr_scr->screen;
 343    struct pipe_surface *surface = tr_surf->surface;
 344
 345    trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
 346
 347    trace_dump_arg(ptr, screen);
 348    trace_dump_arg(ptr, surface);
 349
 350    trace_dump_call_end();
 351
 352    trace_surface_destroy(tr_surf);
 353 }
 354
 355
 356
 357
 358
 359 /********************************************************************
 360  * buffer
 361  */
 362
 363
 364
 365
 366
 367 static struct pipe_buffer *
 368 trace_screen_buffer_create(struct pipe_screen *_screen,
 369                            unsigned alignment,
 370                            unsigned usage,
 371                            unsigned size)
 372 {
 373    struct trace_screen *tr_scr = trace_screen(_screen);
 374    struct pipe_screen *screen = tr_scr->screen;
 375    struct pipe_buffer *result;
 376
 377    trace_dump_call_begin("pipe_screen", "buffer_create");
 378
 379    trace_dump_arg(ptr, screen);
 380    trace_dump_arg(uint, alignment);
 381    trace_dump_arg(uint, usage);
 382    trace_dump_arg(uint, size);
 383
 384    result = screen->buffer_create(screen, alignment, usage, size);
 385
 386    trace_dump_ret(ptr, result);
 387
 388    trace_dump_call_end();
 389
 390    /* Zero the buffer to avoid dumping uninitialized memory */
 391    if(result->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 392       void *map;
 393       map = pipe_buffer_map(screen, result, PIPE_BUFFER_USAGE_CPU_WRITE);
 394       if(map) {
 395          memset(map, 0, result->size);
 396          screen->buffer_unmap(screen, result);
 397       }
 398    }
 399
 400    return trace_buffer_create(tr_scr, result);
 401 }
 402
 403
 404 static struct pipe_buffer *
 405 trace_screen_user_buffer_create(struct pipe_screen *_screen,
 406                                 void *data,
 407                                 unsigned size)
 408 {
 409    struct trace_screen *tr_scr = trace_screen(_screen);
 410    struct pipe_screen *screen = tr_scr->screen;
 411    struct pipe_buffer *result;
 412
 413    trace_dump_call_begin("pipe_screen", "user_buffer_create");
 414
 415    trace_dump_arg(ptr, screen);
 416    trace_dump_arg_begin("data");
 417    trace_dump_bytes(data, size);
 418    trace_dump_arg_end();
 419    trace_dump_arg(uint, size);
 420
 421    result = screen->user_buffer_create(screen, data, size);
 422
 423    trace_dump_ret(ptr, result);
 424
 425    trace_dump_call_end();
 426
 427    if(result) {
 428       assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
 429       result->usage |= TRACE_BUFFER_USAGE_USER;
 430    }
 431
 432    return trace_buffer_create(tr_scr, result);
 433 }
 434
 435
 436 /**
 437  * This function is used to track if data has been changed on a user buffer
 438  * without map/unmap being called.
 439  */
 440 void
 441 trace_screen_user_buffer_update(struct pipe_screen *_screen,
 442                                 struct pipe_buffer *_buffer)
 443 {
 444 #if 0
 445    struct trace_screen *tr_scr = trace_screen(_screen);
 446    struct pipe_screen *screen = tr_scr->screen;
 447    const void *map;
 448
 449    if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
 450       map = screen->buffer_map(screen, buffer, PIPE_BUFFER_USAGE_CPU_READ);
 451       if(map) {
 452          trace_dump_call_begin("pipe_winsys", "buffer_write");
 453
 454          trace_dump_arg(ptr, screen);
 455
 456          trace_dump_arg(ptr, buffer);
 457
 458          trace_dump_arg_begin("data");
 459          trace_dump_bytes(map, buffer->size);
 460          trace_dump_arg_end();
 461
 462          trace_dump_arg_begin("size");
 463          trace_dump_uint(buffer->size);
 464          trace_dump_arg_end();
 465
 466          trace_dump_call_end();
 467
 468          screen->buffer_unmap(screen, buffer);
 469       }
 470    }
 471 #endif
 472 }
 473
 474
 475 static void *
 476 trace_screen_buffer_map(struct pipe_screen *_screen,
 477                         struct pipe_buffer *_buffer,
 478                         unsigned usage)
 479 {
 480    struct trace_screen *tr_scr = trace_screen(_screen);
 481    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 482    struct pipe_screen *screen = tr_scr->screen;
 483    struct pipe_buffer *buffer = tr_buf->buffer;
 484    void *map;
 485
 486    assert(screen->buffer_map);
 487    map = screen->buffer_map(screen, buffer, usage);
 488    if(map) {
 489       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 490          tr_buf->map = map;
 491       }
 492    }
 493
 494    return map;
 495 }
 496
 497
 498 static void *
 499 trace_screen_buffer_map_range(struct pipe_screen *_screen,
 500                               struct pipe_buffer *_buffer,
 501                               unsigned offset,
 502                               unsigned length,
 503                               unsigned usage)
 504 {
 505    struct trace_screen *tr_scr = trace_screen(_screen);
 506    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 507    struct pipe_screen *screen = tr_scr->screen;
 508    struct pipe_buffer *buffer = tr_buf->buffer;
 509    void *map;
 510
 511    assert(screen->buffer_map_range);
 512    map = screen->buffer_map_range(screen, buffer, offset, length, usage);
 513    if(map) {
 514       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 515          tr_buf->map = map;
 516       }
 517    }
 518
 519    return map;
 520 }
 521
 522
 523 static void
 524 buffer_write(struct pipe_screen *screen,
 525              struct pipe_buffer *buffer,
 526              unsigned offset,
 527              const char *map,
 528              unsigned size)
 529 {
 530    assert(map);
 531
 532    trace_dump_call_begin("pipe_screen", "buffer_write");
 533
 534    trace_dump_arg(ptr, screen);
 535
 536    trace_dump_arg(ptr, buffer);
 537
 538    trace_dump_arg(uint, offset);
 539
 540    trace_dump_arg_begin("data");
 541    trace_dump_bytes(map + offset, size);
 542    trace_dump_arg_end();
 543
 544    trace_dump_arg(uint, size);
 545
 546    trace_dump_call_end();
 547
 548 }
 549
 550
 551 static void
 552 trace_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
 553                                        struct pipe_buffer *_buffer,
 554                                        unsigned offset,
 555                                        unsigned length)
 556 {
 557    struct trace_screen *tr_scr = trace_screen(_screen);
 558    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 559    struct pipe_screen *screen = tr_scr->screen;
 560    struct pipe_buffer *buffer = tr_buf->buffer;
 561
 562    assert(tr_buf->map);
 563    buffer_write(screen, buffer, offset, tr_buf->map, length);
 564    tr_buf->range_flushed = TRUE;
 565    screen->buffer_flush_mapped_range(screen, buffer, offset, length);
 566 }
 567
 568
 569 static void
 570 trace_screen_buffer_unmap(struct pipe_screen *_screen,
 571                           struct pipe_buffer *_buffer)
 572 {
 573    struct trace_screen *tr_scr = trace_screen(_screen);
 574    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 575    struct pipe_screen *screen = tr_scr->screen;
 576    struct pipe_buffer *buffer = tr_buf->buffer;
 577
 578    if (tr_buf->map && !tr_buf->range_flushed)
 579       buffer_write(screen, buffer, 0, tr_buf->map, buffer->size);
 580    tr_buf->map = NULL;
 581    tr_buf->range_flushed = FALSE;
 582    screen->buffer_unmap(screen, buffer);
 583 }
 584
 585
 586 static void
 587 trace_screen_buffer_destroy(struct pipe_buffer *_buffer)
 588 {
 589    struct trace_screen *tr_scr = trace_screen(_buffer->screen);
 590    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 591    struct pipe_screen *screen = tr_scr->screen;
 592    struct pipe_buffer *buffer = tr_buf->buffer;
 593
 594    trace_dump_call_begin("pipe_screen", "buffer_destroy");
 595
 596    trace_dump_arg(ptr, screen);
 597    trace_dump_arg(ptr, buffer);
 598
 599    trace_dump_call_end();
 600
 601    trace_buffer_destroy(tr_scr, _buffer);
 602 }
 603
 604
 605 /********************************************************************
 606  * fence
 607  */
 608
 609
 610 static void
 611 trace_screen_fence_reference(struct pipe_screen *_screen,
 612                              struct pipe_fence_handle **pdst,
 613                              struct pipe_fence_handle *src)
 614 {
 615    struct trace_screen *tr_scr = trace_screen(_screen);
 616    struct pipe_screen *screen = tr_scr->screen;
 617    struct pipe_fence_handle *dst;
 618
 619    assert(pdst);
 620    dst = *pdst;
 621
 622    trace_dump_call_begin("pipe_screen", "fence_reference");
 623
 624    trace_dump_arg(ptr, screen);
 625    trace_dump_arg(ptr, dst);
 626    trace_dump_arg(ptr, src);
 627
 628    screen->fence_reference(screen, pdst, src);
 629
 630    trace_dump_call_end();
 631 }
 632
 633
 634 static int
 635 trace_screen_fence_signalled(struct pipe_screen *_screen,
 636                              struct pipe_fence_handle *fence,
 637                              unsigned flags)
 638 {
 639    struct trace_screen *tr_scr = trace_screen(_screen);
 640    struct pipe_screen *screen = tr_scr->screen;
 641    int result;
 642
 643    trace_dump_call_begin("pipe_screen", "fence_signalled");
 644
 645    trace_dump_arg(ptr, screen);
 646    trace_dump_arg(ptr, fence);
 647    trace_dump_arg(uint, flags);
 648
 649    result = screen->fence_signalled(screen, fence, flags);
 650
 651    trace_dump_ret(int, result);
 652
 653    trace_dump_call_end();
 654
 655    return result;
 656 }
 657
 658
 659 static int
 660 trace_screen_fence_finish(struct pipe_screen *_screen,
 661                           struct pipe_fence_handle *fence,
 662                           unsigned flags)
 663 {
 664    struct trace_screen *tr_scr = trace_screen(_screen);
 665    struct pipe_screen *screen = tr_scr->screen;
 666    int result;
 667
 668    trace_dump_call_begin("pipe_screen", "fence_finish");
 669
 670    trace_dump_arg(ptr, screen);
 671    trace_dump_arg(ptr, fence);
 672    trace_dump_arg(uint, flags);
 673
 674    result = screen->fence_finish(screen, fence, flags);
 675
 676    trace_dump_ret(int, result);
 677
 678    trace_dump_call_end();
 679
 680    return result;
 681 }
 682
 683
 684 /********************************************************************
 685  * screen
 686  */
 687
 688 static void
 689 trace_screen_destroy(struct pipe_screen *_screen)
 690 {
 691    struct trace_screen *tr_scr = trace_screen(_screen);
 692    struct pipe_screen *screen = tr_scr->screen;
 693
 694    trace_dump_call_begin("pipe_screen", "destroy");
 695    trace_dump_arg(ptr, screen);
 696    trace_dump_call_end();
 697    trace_dump_trace_end();
 698
 699    if (tr_scr->rbug)
 700       trace_rbug_stop(tr_scr->rbug);
 701
 702    screen->destroy(screen);
 703
 704    FREE(tr_scr);
 705 }
 706
 707 boolean
 708 trace_enabled(void)
 709 {
 710    static boolean firstrun = TRUE;
 711
 712    if (!firstrun)
 713       return trace;
 714    firstrun = FALSE;
 715
 716    trace_dump_init();
 717
 718    if(trace_dump_trace_begin()) {
 719       trace_dumping_start();
 720       trace = TRUE;
 721    }
 722
 723    if (debug_get_bool_option("GALLIUM_RBUG", FALSE)) {
 724       trace = TRUE;
 725       rbug = TRUE;
 726    }
 727
 728    return trace;
 729 }
 730
 731 struct pipe_screen *
 732 trace_screen_create(struct pipe_screen *screen)
 733 {
 734    struct trace_screen *tr_scr;
 735    struct pipe_winsys *winsys;
 736
 737    if(!screen)
 738       goto error1;
 739
 740    if (!trace_enabled())
 741       goto error1;
 742
 743    trace_dump_call_begin("", "pipe_screen_create");
 744
 745    tr_scr = CALLOC_STRUCT(trace_screen);
 746    if(!tr_scr)
 747       goto error2;
 748
 749 #if 0
 750    winsys = trace_winsys_create(screen->winsys);
 751    if(!winsys)
 752       goto error3;
 753 #else
 754    winsys = screen->winsys;
 755 #endif
 756    pipe_mutex_init(tr_scr->list_mutex);
 757    make_empty_list(&tr_scr->buffers);
 758    make_empty_list(&tr_scr->contexts);
 759    make_empty_list(&tr_scr->textures);
 760    make_empty_list(&tr_scr->surfaces);
 761    make_empty_list(&tr_scr->transfers);
 762
 763    tr_scr->base.winsys = winsys;
 764    tr_scr->base.destroy = trace_screen_destroy;
 765    tr_scr->base.get_name = trace_screen_get_name;
 766    tr_scr->base.get_vendor = trace_screen_get_vendor;
 767    tr_scr->base.get_param = trace_screen_get_param;
 768    tr_scr->base.get_paramf = trace_screen_get_paramf;
 769    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
 770    assert(screen->context_create);
 771    tr_scr->base.context_create = trace_screen_context_create;
 772    tr_scr->base.texture_create = trace_screen_texture_create;
 773    tr_scr->base.texture_from_handle = trace_screen_texture_from_handle;
 774    tr_scr->base.texture_get_handle = trace_screen_texture_get_handle;
 775    tr_scr->base.texture_destroy = trace_screen_texture_destroy;
 776    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
 777    tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
 778    tr_scr->base.buffer_create = trace_screen_buffer_create;
 779    tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
 780    if (screen->buffer_map)
 781       tr_scr->base.buffer_map = trace_screen_buffer_map;
 782    if (screen->buffer_map_range)
 783       tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
 784    if (screen->buffer_flush_mapped_range)
 785       tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
 786    if (screen->buffer_unmap)
 787       tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
 788    tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
 789    tr_scr->base.fence_reference = trace_screen_fence_reference;
 790    tr_scr->base.fence_signalled = trace_screen_fence_signalled;
 791    tr_scr->base.fence_finish = trace_screen_fence_finish;
 792    tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
 793
 794    tr_scr->screen = screen;
 795    tr_scr->private_context = screen->context_create(screen, NULL);
 796    if (tr_scr->private_context == NULL)
 797       goto error3;
 798
 799    trace_dump_ret(ptr, screen);
 800    trace_dump_call_end();
 801
 802    if (rbug)
 803       tr_scr->rbug = trace_rbug_start(tr_scr);
 804
 805    return &tr_scr->base;
 806
 807 error3:
 808    FREE(tr_scr);
 809 error2:
 810    trace_dump_ret(ptr, screen);
 811    trace_dump_call_end();
 812    trace_dump_trace_end();
 813 error1:
 814    return screen;
 815 }
 816
 817
 818 struct trace_screen *
 819 trace_screen(struct pipe_screen *screen)
 820 {
 821    assert(screen);
 822    assert(screen->destroy == trace_screen_destroy);
 823    return (struct trace_screen *)screen;
 824 }