src/gallium/auxiliary/driver_trace/tr_screen.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 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 #include "util/u_format.h"
  29 #include "util/u_memory.h"
  30 #include "util/simple_list.h"
  31
  32 #include "tr_dump.h"
  33 #include "tr_dump_defines.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
  41 static bool trace = false;
  42
  43 static const char *
  44 trace_screen_get_name(struct pipe_screen *_screen)
  45 {
  46    struct trace_screen *tr_scr = trace_screen(_screen);
  47    struct pipe_screen *screen = tr_scr->screen;
  48    const char *result;
  49
  50    trace_dump_call_begin("pipe_screen", "get_name");
  51
  52    trace_dump_arg(ptr, screen);
  53
  54    result = screen->get_name(screen);
  55
  56    trace_dump_ret(string, result);
  57
  58    trace_dump_call_end();
  59
  60    return result;
  61 }
  62
  63
  64 static const char *
  65 trace_screen_get_vendor(struct pipe_screen *_screen)
  66 {
  67    struct trace_screen *tr_scr = trace_screen(_screen);
  68    struct pipe_screen *screen = tr_scr->screen;
  69    const char *result;
  70
  71    trace_dump_call_begin("pipe_screen", "get_vendor");
  72
  73    trace_dump_arg(ptr, screen);
  74
  75    result = screen->get_vendor(screen);
  76
  77    trace_dump_ret(string, result);
  78
  79    trace_dump_call_end();
  80
  81    return result;
  82 }
  83
  84
  85 static const char *
  86 trace_screen_get_device_vendor(struct pipe_screen *_screen)
  87 {
  88    struct trace_screen *tr_scr = trace_screen(_screen);
  89    struct pipe_screen *screen = tr_scr->screen;
  90    const char *result;
  91
  92    trace_dump_call_begin("pipe_screen", "get_device_vendor");
  93
  94    trace_dump_arg(ptr, screen);
  95
  96    result = screen->get_device_vendor(screen);
  97
  98    trace_dump_ret(string, result);
  99
 100    trace_dump_call_end();
 101
 102    return result;
 103 }
 104
 105
 106 static struct disk_cache *
 107 trace_screen_get_disk_shader_cache(struct pipe_screen *_screen)
 108 {
 109    struct trace_screen *tr_scr = trace_screen(_screen);
 110    struct pipe_screen *screen = tr_scr->screen;
 111
 112    trace_dump_call_begin("pipe_screen", "get_disk_shader_cache");
 113
 114    trace_dump_arg(ptr, screen);
 115
 116    struct disk_cache *result = screen->get_disk_shader_cache(screen);
 117
 118    trace_dump_ret(ptr, result);
 119
 120    trace_dump_call_end();
 121
 122    return result;
 123 }
 124
 125
 126 static int
 127 trace_screen_get_param(struct pipe_screen *_screen,
 128                        enum pipe_cap param)
 129 {
 130    struct trace_screen *tr_scr = trace_screen(_screen);
 131    struct pipe_screen *screen = tr_scr->screen;
 132    int result;
 133
 134    trace_dump_call_begin("pipe_screen", "get_param");
 135
 136    trace_dump_arg(ptr, screen);
 137    trace_dump_arg(int, param);
 138
 139    result = screen->get_param(screen, param);
 140
 141    trace_dump_ret(int, result);
 142
 143    trace_dump_call_end();
 144
 145    return result;
 146 }
 147
 148
 149 static int
 150 trace_screen_get_shader_param(struct pipe_screen *_screen,
 151                               enum pipe_shader_type shader,
 152                               enum pipe_shader_cap param)
 153 {
 154    struct trace_screen *tr_scr = trace_screen(_screen);
 155    struct pipe_screen *screen = tr_scr->screen;
 156    int result;
 157
 158    trace_dump_call_begin("pipe_screen", "get_shader_param");
 159
 160    trace_dump_arg(ptr, screen);
 161    trace_dump_arg(uint, shader);
 162    trace_dump_arg(int, param);
 163
 164    result = screen->get_shader_param(screen, shader, param);
 165
 166    trace_dump_ret(int, result);
 167
 168    trace_dump_call_end();
 169
 170    return result;
 171 }
 172
 173
 174 static float
 175 trace_screen_get_paramf(struct pipe_screen *_screen,
 176                         enum pipe_capf param)
 177 {
 178    struct trace_screen *tr_scr = trace_screen(_screen);
 179    struct pipe_screen *screen = tr_scr->screen;
 180    float result;
 181
 182    trace_dump_call_begin("pipe_screen", "get_paramf");
 183
 184    trace_dump_arg(ptr, screen);
 185    trace_dump_arg(int, param);
 186
 187    result = screen->get_paramf(screen, param);
 188
 189    trace_dump_ret(float, result);
 190
 191    trace_dump_call_end();
 192
 193    return result;
 194 }
 195
 196
 197 static int
 198 trace_screen_get_compute_param(struct pipe_screen *_screen,
 199                                enum pipe_shader_ir ir_type,
 200                                enum pipe_compute_cap param, void *data)
 201 {
 202    struct trace_screen *tr_scr = trace_screen(_screen);
 203    struct pipe_screen *screen = tr_scr->screen;
 204    int result;
 205
 206    trace_dump_call_begin("pipe_screen", "get_compute_param");
 207
 208    trace_dump_arg(ptr, screen);
 209    trace_dump_arg(int, ir_type);
 210    trace_dump_arg(int, param);
 211    trace_dump_arg(ptr, data);
 212
 213    result = screen->get_compute_param(screen, ir_type, param, data);
 214
 215    trace_dump_ret(int, result);
 216
 217    trace_dump_call_end();
 218
 219    return result;
 220 }
 221
 222
 223 static bool
 224 trace_screen_is_format_supported(struct pipe_screen *_screen,
 225                                  enum pipe_format format,
 226                                  enum pipe_texture_target target,
 227                                  unsigned sample_count,
 228                                  unsigned storage_sample_count,
 229                                  unsigned tex_usage)
 230 {
 231    struct trace_screen *tr_scr = trace_screen(_screen);
 232    struct pipe_screen *screen = tr_scr->screen;
 233    bool result;
 234
 235    trace_dump_call_begin("pipe_screen", "is_format_supported");
 236
 237    trace_dump_arg(ptr, screen);
 238    trace_dump_arg(format, format);
 239    trace_dump_arg(int, target);
 240    trace_dump_arg(uint, sample_count);
 241    trace_dump_arg(uint, tex_usage);
 242
 243    result = screen->is_format_supported(screen, format, target, sample_count,
 244                                         storage_sample_count, tex_usage);
 245
 246    trace_dump_ret(bool, result);
 247
 248    trace_dump_call_end();
 249
 250    return result;
 251 }
 252
 253
 254 static struct pipe_context *
 255 trace_screen_context_create(struct pipe_screen *_screen, void *priv,
 256                             unsigned flags)
 257 {
 258    struct trace_screen *tr_scr = trace_screen(_screen);
 259    struct pipe_screen *screen = tr_scr->screen;
 260    struct pipe_context *result;
 261
 262    trace_dump_call_begin("pipe_screen", "context_create");
 263
 264    trace_dump_arg(ptr, screen);
 265    trace_dump_arg(ptr, priv);
 266    trace_dump_arg(uint, flags);
 267
 268    result = screen->context_create(screen, priv, flags);
 269
 270    trace_dump_ret(ptr, result);
 271
 272    trace_dump_call_end();
 273
 274    result = trace_context_create(tr_scr, result);
 275
 276    return result;
 277 }
 278
 279
 280 static void
 281 trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
 282                                struct pipe_resource *resource,
 283                                unsigned level, unsigned layer,
 284                                void *context_private,
 285                                struct pipe_box *sub_box)
 286 {
 287    struct trace_screen *tr_scr = trace_screen(_screen);
 288    struct pipe_screen *screen = tr_scr->screen;
 289
 290    trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
 291
 292    trace_dump_arg(ptr, screen);
 293    trace_dump_arg(ptr, resource);
 294    trace_dump_arg(uint, level);
 295    trace_dump_arg(uint, layer);
 296    /* XXX: hide, as there is nothing we can do with this
 297    trace_dump_arg(ptr, context_private);
 298    */
 299
 300    screen->flush_frontbuffer(screen, resource, level, layer, context_private, sub_box);
 301
 302    trace_dump_call_end();
 303 }
 304
 305
 306 static void
 307 trace_screen_get_driver_uuid(struct pipe_screen *_screen, char *uuid)
 308 {
 309    struct pipe_screen *screen = trace_screen(_screen)->screen;
 310
 311    trace_dump_call_begin("pipe_screen", "get_driver_uuid");
 312    trace_dump_arg(ptr, screen);
 313
 314    screen->get_driver_uuid(screen, uuid);
 315
 316    trace_dump_ret(string, uuid);
 317    trace_dump_call_end();
 318 }
 319
 320 static void
 321 trace_screen_get_device_uuid(struct pipe_screen *_screen, char *uuid)
 322 {
 323    struct pipe_screen *screen = trace_screen(_screen)->screen;
 324
 325    trace_dump_call_begin("pipe_screen", "get_device_uuid");
 326    trace_dump_arg(ptr, screen);
 327
 328    screen->get_device_uuid(screen, uuid);
 329
 330    trace_dump_ret(string, uuid);
 331    trace_dump_call_end();
 332 }
 333
 334
 335 /********************************************************************
 336  * texture
 337  */
 338
 339
 340 static struct pipe_resource *
 341 trace_screen_resource_create(struct pipe_screen *_screen,
 342                             const struct pipe_resource *templat)
 343 {
 344    struct trace_screen *tr_scr = trace_screen(_screen);
 345    struct pipe_screen *screen = tr_scr->screen;
 346    struct pipe_resource *result;
 347
 348    trace_dump_call_begin("pipe_screen", "resource_create");
 349
 350    trace_dump_arg(ptr, screen);
 351    trace_dump_arg(resource_template, templat);
 352
 353    result = screen->resource_create(screen, templat);
 354
 355    trace_dump_ret(ptr, result);
 356
 357    trace_dump_call_end();
 358
 359    if (result)
 360       result->screen = _screen;
 361    return result;
 362 }
 363
 364 static struct pipe_resource *
 365 trace_screen_resource_from_handle(struct pipe_screen *_screen,
 366                                  const struct pipe_resource *templ,
 367                                  struct winsys_handle *handle,
 368                                   unsigned usage)
 369 {
 370    struct trace_screen *tr_screen = trace_screen(_screen);
 371    struct pipe_screen *screen = tr_screen->screen;
 372    struct pipe_resource *result;
 373
 374    /* TODO trace call */
 375
 376    result = screen->resource_from_handle(screen, templ, handle, usage);
 377
 378    if (result)
 379       result->screen = _screen;
 380    return result;
 381 }
 382
 383 static bool
 384 trace_screen_check_resource_capability(struct pipe_screen *_screen,
 385                                        struct pipe_resource *resource,
 386                                        unsigned bind)
 387 {
 388    struct pipe_screen *screen = trace_screen(_screen)->screen;
 389
 390    return screen->check_resource_capability(screen, resource, bind);
 391 }
 392
 393 static bool
 394 trace_screen_resource_get_handle(struct pipe_screen *_screen,
 395                                  struct pipe_context *_pipe,
 396                                 struct pipe_resource *resource,
 397                                 struct winsys_handle *handle,
 398                                  unsigned usage)
 399 {
 400    struct trace_screen *tr_screen = trace_screen(_screen);
 401    struct trace_context *tr_pipe = _pipe ? trace_context(_pipe) : NULL;
 402    struct pipe_screen *screen = tr_screen->screen;
 403
 404    /* TODO trace call */
 405
 406    return screen->resource_get_handle(screen, tr_pipe ? tr_pipe->pipe : NULL,
 407                                       resource, handle, usage);
 408 }
 409
 410 static bool
 411 trace_screen_resource_get_param(struct pipe_screen *_screen,
 412                                 struct pipe_context *_pipe,
 413                                 struct pipe_resource *resource,
 414                                 unsigned plane,
 415                                 unsigned layer,
 416                                 enum pipe_resource_param param,
 417                                 unsigned handle_usage,
 418                                 uint64_t *value)
 419 {
 420    struct trace_screen *tr_screen = trace_screen(_screen);
 421    struct trace_context *tr_pipe = _pipe ? trace_context(_pipe) : NULL;
 422    struct pipe_screen *screen = tr_screen->screen;
 423
 424    /* TODO trace call */
 425
 426    return screen->resource_get_param(screen, tr_pipe ? tr_pipe->pipe : NULL,
 427                                      resource, plane, layer, param,
 428                                      handle_usage, value);
 429 }
 430
 431 static void
 432 trace_screen_resource_get_info(struct pipe_screen *_screen,
 433                                struct pipe_resource *resource,
 434                                unsigned *stride,
 435                                unsigned *offset)
 436 {
 437    struct trace_screen *tr_screen = trace_screen(_screen);
 438    struct pipe_screen *screen = tr_screen->screen;
 439
 440    /* TODO trace call */
 441
 442    screen->resource_get_info(screen, resource, stride, offset);
 443 }
 444
 445 static struct pipe_resource *
 446 trace_screen_resource_from_memobj(struct pipe_screen *_screen,
 447                                   const struct pipe_resource *templ,
 448                                   struct pipe_memory_object *memobj,
 449                                   uint64_t offset)
 450 {
 451    struct pipe_screen *screen = trace_screen(_screen)->screen;
 452
 453    trace_dump_call_begin("pipe_screen", "resource_from_memobj");
 454    trace_dump_arg(ptr, screen);
 455    trace_dump_arg(resource_template, templ);
 456    trace_dump_arg(ptr, memobj);
 457    trace_dump_arg(uint, offset);
 458
 459    struct pipe_resource *res =
 460       screen->resource_from_memobj(screen, templ, memobj, offset);
 461
 462    if (!res)
 463       return NULL;
 464    res->screen = _screen;
 465
 466    trace_dump_ret(ptr, res);
 467    trace_dump_call_end();
 468    return res;
 469 }
 470
 471 static void
 472 trace_screen_resource_changed(struct pipe_screen *_screen,
 473                               struct pipe_resource *resource)
 474 {
 475    struct trace_screen *tr_scr = trace_screen(_screen);
 476    struct pipe_screen *screen = tr_scr->screen;
 477
 478    trace_dump_call_begin("pipe_screen", "resource_changed");
 479
 480    trace_dump_arg(ptr, screen);
 481    trace_dump_arg(ptr, resource);
 482
 483    if (screen->resource_changed)
 484       screen->resource_changed(screen, resource);
 485
 486    trace_dump_call_end();
 487 }
 488
 489 static void
 490 trace_screen_resource_destroy(struct pipe_screen *_screen,
 491                               struct pipe_resource *resource)
 492 {
 493    struct trace_screen *tr_scr = trace_screen(_screen);
 494    struct pipe_screen *screen = tr_scr->screen;
 495
 496    /* Don't trace this, because due to the lack of pipe_resource wrapping,
 497     * we can get this call from inside of driver calls, which would try
 498     * to lock an already-locked mutex.
 499     */
 500    screen->resource_destroy(screen, resource);
 501 }
 502
 503
 504 /********************************************************************
 505  * fence
 506  */
 507
 508
 509 static void
 510 trace_screen_fence_reference(struct pipe_screen *_screen,
 511                              struct pipe_fence_handle **pdst,
 512                              struct pipe_fence_handle *src)
 513 {
 514    struct trace_screen *tr_scr = trace_screen(_screen);
 515    struct pipe_screen *screen = tr_scr->screen;
 516    struct pipe_fence_handle *dst;
 517
 518    assert(pdst);
 519    dst = *pdst;
 520
 521    trace_dump_call_begin("pipe_screen", "fence_reference");
 522
 523    trace_dump_arg(ptr, screen);
 524    trace_dump_arg(ptr, dst);
 525    trace_dump_arg(ptr, src);
 526
 527    screen->fence_reference(screen, pdst, src);
 528
 529    trace_dump_call_end();
 530 }
 531
 532
 533 static int
 534 trace_screen_fence_get_fd(struct pipe_screen *_screen,
 535                           struct pipe_fence_handle *fence)
 536 {
 537    struct trace_screen *tr_scr = trace_screen(_screen);
 538    struct pipe_screen *screen = tr_scr->screen;
 539    int result;
 540
 541    trace_dump_call_begin("pipe_screen", "fence_get_fd");
 542
 543    trace_dump_arg(ptr, screen);
 544    trace_dump_arg(ptr, fence);
 545
 546    result = screen->fence_get_fd(screen, fence);
 547
 548    trace_dump_ret(int, result);
 549
 550    trace_dump_call_end();
 551
 552    return result;
 553 }
 554
 555
 556 static bool
 557 trace_screen_fence_finish(struct pipe_screen *_screen,
 558                           struct pipe_context *_ctx,
 559                           struct pipe_fence_handle *fence,
 560                           uint64_t timeout)
 561 {
 562    struct trace_screen *tr_scr = trace_screen(_screen);
 563    struct pipe_screen *screen = tr_scr->screen;
 564    struct pipe_context *ctx = _ctx ? trace_context(_ctx)->pipe : NULL;
 565    int result;
 566
 567    trace_dump_call_begin("pipe_screen", "fence_finish");
 568
 569    trace_dump_arg(ptr, screen);
 570    trace_dump_arg(ptr, ctx);
 571    trace_dump_arg(ptr, fence);
 572    trace_dump_arg(uint, timeout);
 573
 574    result = screen->fence_finish(screen, ctx, fence, timeout);
 575
 576    trace_dump_ret(bool, result);
 577
 578    trace_dump_call_end();
 579
 580    return result;
 581 }
 582
 583
 584 /********************************************************************
 585  * memobj
 586  */
 587
 588 static struct pipe_memory_object *
 589 trace_screen_memobj_create_from_handle(struct pipe_screen *_screen,
 590                                        struct winsys_handle *handle,
 591                                        bool dedicated)
 592 {
 593    struct pipe_screen *screen = trace_screen(_screen)->screen;
 594
 595    trace_dump_call_begin("pipe_screen", "memobj_create_from_handle");
 596    trace_dump_arg(ptr, screen);
 597    trace_dump_arg(ptr, handle);
 598    trace_dump_arg(bool, dedicated);
 599
 600    struct pipe_memory_object *res =
 601       screen->memobj_create_from_handle(screen, handle, dedicated);
 602
 603    trace_dump_ret(ptr, res);
 604    trace_dump_call_end();
 605
 606    return res;
 607 }
 608
 609 static void
 610 trace_screen_memobj_destroy(struct pipe_screen *_screen,
 611                             struct pipe_memory_object *memobj)
 612 {
 613    struct pipe_screen *screen = trace_screen(_screen)->screen;
 614
 615    trace_dump_call_begin("pipe_screen", "memobj_destroy");
 616    trace_dump_arg(ptr, screen);
 617    trace_dump_arg(ptr, memobj);
 618    trace_dump_call_end();
 619
 620    screen->memobj_destroy(screen, memobj);
 621 }
 622
 623
 624 /********************************************************************
 625  * screen
 626  */
 627
 628 static uint64_t
 629 trace_screen_get_timestamp(struct pipe_screen *_screen)
 630 {
 631    struct trace_screen *tr_scr = trace_screen(_screen);
 632    struct pipe_screen *screen = tr_scr->screen;
 633    uint64_t result;
 634
 635    trace_dump_call_begin("pipe_screen", "get_timestamp");
 636    trace_dump_arg(ptr, screen);
 637
 638    result = screen->get_timestamp(screen);
 639
 640    trace_dump_ret(uint, result);
 641    trace_dump_call_end();
 642
 643    return result;
 644 }
 645
 646 static void
 647 trace_screen_finalize_nir(struct pipe_screen *_screen, void *nir, bool optimize)
 648 {
 649    struct pipe_screen *screen = trace_screen(_screen)->screen;
 650
 651    screen->finalize_nir(screen, nir, optimize);
 652 }
 653
 654 static void
 655 trace_screen_destroy(struct pipe_screen *_screen)
 656 {
 657    struct trace_screen *tr_scr = trace_screen(_screen);
 658    struct pipe_screen *screen = tr_scr->screen;
 659
 660    trace_dump_call_begin("pipe_screen", "destroy");
 661    trace_dump_arg(ptr, screen);
 662    trace_dump_call_end();
 663
 664    screen->destroy(screen);
 665
 666    FREE(tr_scr);
 667 }
 668
 669 bool
 670 trace_enabled(void)
 671 {
 672    static bool firstrun = true;
 673
 674    if (!firstrun)
 675       return trace;
 676    firstrun = false;
 677
 678    if(trace_dump_trace_begin()) {
 679       trace_dumping_start();
 680       trace = true;
 681    }
 682
 683    return trace;
 684 }
 685
 686 struct pipe_screen *
 687 trace_screen_create(struct pipe_screen *screen)
 688 {
 689    struct trace_screen *tr_scr;
 690
 691    if (!trace_enabled())
 692       goto error1;
 693
 694    trace_dump_call_begin("", "pipe_screen_create");
 695
 696    tr_scr = CALLOC_STRUCT(trace_screen);
 697    if (!tr_scr)
 698       goto error2;
 699
 700 #define SCR_INIT(_member) \
 701    tr_scr->base._member = screen->_member ? trace_screen_##_member : NULL
 702
 703    tr_scr->base.destroy = trace_screen_destroy;
 704    tr_scr->base.get_name = trace_screen_get_name;
 705    tr_scr->base.get_vendor = trace_screen_get_vendor;
 706    tr_scr->base.get_device_vendor = trace_screen_get_device_vendor;
 707    SCR_INIT(get_disk_shader_cache);
 708    tr_scr->base.get_param = trace_screen_get_param;
 709    tr_scr->base.get_shader_param = trace_screen_get_shader_param;
 710    tr_scr->base.get_paramf = trace_screen_get_paramf;
 711    tr_scr->base.get_compute_param = trace_screen_get_compute_param;
 712    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
 713    assert(screen->context_create);
 714    tr_scr->base.context_create = trace_screen_context_create;
 715    tr_scr->base.resource_create = trace_screen_resource_create;
 716    tr_scr->base.resource_from_handle = trace_screen_resource_from_handle;
 717    SCR_INIT(check_resource_capability);
 718    tr_scr->base.resource_get_handle = trace_screen_resource_get_handle;
 719    SCR_INIT(resource_get_param);
 720    SCR_INIT(resource_get_info);
 721    SCR_INIT(resource_from_memobj);
 722    SCR_INIT(resource_changed);
 723    tr_scr->base.resource_destroy = trace_screen_resource_destroy;
 724    tr_scr->base.fence_reference = trace_screen_fence_reference;
 725    SCR_INIT(fence_get_fd);
 726    tr_scr->base.fence_finish = trace_screen_fence_finish;
 727    SCR_INIT(memobj_create_from_handle);
 728    SCR_INIT(memobj_destroy);
 729    tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
 730    tr_scr->base.get_timestamp = trace_screen_get_timestamp;
 731    SCR_INIT(get_driver_uuid);
 732    SCR_INIT(get_device_uuid);
 733    SCR_INIT(finalize_nir);
 734
 735    tr_scr->screen = screen;
 736
 737    trace_dump_ret(ptr, screen);
 738    trace_dump_call_end();
 739
 740    return &tr_scr->base;
 741
 742 error2:
 743    trace_dump_ret(ptr, screen);
 744    trace_dump_call_end();
 745 error1:
 746    return screen;
 747 }
 748
 749
 750 struct trace_screen *
 751 trace_screen(struct pipe_screen *screen)
 752 {
 753    assert(screen);
 754    assert(screen->destroy == trace_screen_destroy);
 755    return (struct trace_screen *)screen;
 756 }