src/mesa/drivers/dri/i965/brw_program.c

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a 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, sublicense, 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
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keithw@vmware.com>
  30   */
  31
  32 #include <pthread.h>
  33 #include "main/imports.h"
  34 #include "program/prog_parameter.h"
  35 #include "program/prog_print.h"
  36 #include "program/prog_to_nir.h"
  37 #include "program/program.h"
  38 #include "program/programopt.h"
  39 #include "tnl/tnl.h"
  40 #include "util/ralloc.h"
  41 #include "compiler/glsl/ir.h"
  42 #include "compiler/glsl/glsl_to_nir.h"
  43
  44 #include "brw_program.h"
  45 #include "brw_context.h"
  46 #include "brw_shader.h"
  47 #include "brw_nir.h"
  48 #include "intel_batchbuffer.h"
  49
  50 static void
  51 brw_nir_lower_uniforms(nir_shader *nir, bool is_scalar)
  52 {
  53    if (is_scalar) {
  54       nir_assign_var_locations(&nir->uniforms, &nir->num_uniforms, 0,
  55                                type_size_scalar_bytes);
  56       nir_lower_io(nir, nir_var_uniform, type_size_scalar_bytes, 0);
  57    } else {
  58       nir_assign_var_locations(&nir->uniforms, &nir->num_uniforms, 0,
  59                                type_size_vec4_bytes);
  60       nir_lower_io(nir, nir_var_uniform, type_size_vec4_bytes, 0);
  61    }
  62 }
  63
  64 nir_shader *
  65 brw_create_nir(struct brw_context *brw,
  66                const struct gl_shader_program *shader_prog,
  67                const struct gl_program *prog,
  68                gl_shader_stage stage,
  69                bool is_scalar)
  70 {
  71    struct gl_context *ctx = &brw->ctx;
  72    const nir_shader_compiler_options *options =
  73       ctx->Const.ShaderCompilerOptions[stage].NirOptions;
  74    bool progress;
  75    nir_shader *nir;
  76
  77    /* First, lower the GLSL IR or Mesa IR to NIR */
  78    if (shader_prog) {
  79       nir = glsl_to_nir(shader_prog, stage, options);
  80       nir_remove_dead_variables(nir, nir_var_shader_in | nir_var_shader_out);
  81       NIR_PASS_V(nir, nir_lower_io_to_temporaries,
  82                  nir_shader_get_entrypoint(nir), true, false);
  83    } else {
  84       nir = prog_to_nir(prog, options);
  85       NIR_PASS_V(nir, nir_convert_to_ssa); /* turn registers into SSA */
  86    }
  87    nir_validate_shader(nir);
  88
  89    (void)progress;
  90
  91    nir = brw_preprocess_nir(brw->screen->compiler, nir);
  92
  93    if (stage == MESA_SHADER_FRAGMENT) {
  94       static const struct nir_lower_wpos_ytransform_options wpos_options = {
  95          .state_tokens = {STATE_INTERNAL, STATE_FB_WPOS_Y_TRANSFORM, 0, 0, 0},
  96          .fs_coord_pixel_center_integer = 1,
  97          .fs_coord_origin_upper_left = 1,
  98       };
  99       _mesa_add_state_reference(prog->Parameters,
 100                                 (gl_state_index *) wpos_options.state_tokens);
 101
 102       NIR_PASS(progress, nir, nir_lower_wpos_ytransform, &wpos_options);
 103    }
 104
 105    NIR_PASS(progress, nir, nir_lower_system_values);
 106    NIR_PASS_V(nir, brw_nir_lower_uniforms, is_scalar);
 107
 108    if (shader_prog) {
 109       NIR_PASS_V(nir, nir_lower_samplers, shader_prog);
 110       NIR_PASS_V(nir, nir_lower_atomics, shader_prog);
 111    }
 112
 113    return nir;
 114 }
 115
 116 static unsigned
 117 get_new_program_id(struct intel_screen *screen)
 118 {
 119    static pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
 120    pthread_mutex_lock(&m);
 121    unsigned id = screen->program_id++;
 122    pthread_mutex_unlock(&m);
 123    return id;
 124 }
 125
 126 static struct gl_program *brwNewProgram( struct gl_context *ctx,
 127                                       GLenum target,
 128                                       GLuint id )
 129 {
 130    struct brw_context *brw = brw_context(ctx);
 131
 132    switch (target) {
 133    case GL_VERTEX_PROGRAM_ARB: {
 134       struct brw_vertex_program *prog = CALLOC_STRUCT(brw_vertex_program);
 135       if (prog) {
 136          prog->id = get_new_program_id(brw->screen);
 137
 138          return _mesa_init_gl_program(&prog->program, target, id);
 139       }
 140       else
 141          return NULL;
 142    }
 143
 144    case GL_FRAGMENT_PROGRAM_ARB: {
 145       struct brw_fragment_program *prog = CALLOC_STRUCT(brw_fragment_program);
 146       if (prog) {
 147          prog->id = get_new_program_id(brw->screen);
 148
 149          return _mesa_init_gl_program(&prog->program.Base, target, id);
 150       }
 151       else
 152          return NULL;
 153    }
 154
 155    case GL_GEOMETRY_PROGRAM_NV: {
 156       struct brw_geometry_program *prog = CALLOC_STRUCT(brw_geometry_program);
 157       if (prog) {
 158          prog->id = get_new_program_id(brw->screen);
 159
 160          return _mesa_init_gl_program(&prog->program, target, id);
 161       } else {
 162          return NULL;
 163       }
 164    }
 165
 166    case GL_TESS_CONTROL_PROGRAM_NV: {
 167       struct brw_tess_ctrl_program *prog = CALLOC_STRUCT(brw_tess_ctrl_program);
 168       if (prog) {
 169          prog->id = get_new_program_id(brw->screen);
 170
 171          return _mesa_init_gl_program(&prog->program, target, id);
 172       } else {
 173          return NULL;
 174       }
 175    }
 176
 177    case GL_TESS_EVALUATION_PROGRAM_NV: {
 178       struct brw_tess_eval_program *prog = CALLOC_STRUCT(brw_tess_eval_program);
 179       if (prog) {
 180          prog->id = get_new_program_id(brw->screen);
 181
 182          return _mesa_init_gl_program(&prog->program, target, id);
 183       } else {
 184          return NULL;
 185       }
 186    }
 187
 188    case GL_COMPUTE_PROGRAM_NV: {
 189       struct brw_compute_program *prog = CALLOC_STRUCT(brw_compute_program);
 190       if (prog) {
 191          prog->id = get_new_program_id(brw->screen);
 192
 193          return _mesa_init_gl_program(&prog->program.Base, target, id);
 194       } else {
 195          return NULL;
 196       }
 197    }
 198
 199    default:
 200       unreachable("Unsupported target in brwNewProgram()");
 201    }
 202 }
 203
 204 static void brwDeleteProgram( struct gl_context *ctx,
 205                               struct gl_program *prog )
 206 {
 207    _mesa_delete_program( ctx, prog );
 208 }
 209
 210
 211 static GLboolean
 212 brwProgramStringNotify(struct gl_context *ctx,
 213                        GLenum target,
 214                        struct gl_program *prog)
 215 {
 216    assert(target == GL_VERTEX_PROGRAM_ARB || !prog->IsPositionInvariant);
 217
 218    struct brw_context *brw = brw_context(ctx);
 219    const struct brw_compiler *compiler = brw->screen->compiler;
 220
 221    switch (target) {
 222    case GL_FRAGMENT_PROGRAM_ARB: {
 223       struct gl_fragment_program *fprog = (struct gl_fragment_program *) prog;
 224       struct brw_fragment_program *newFP = brw_fragment_program(fprog);
 225       const struct brw_fragment_program *curFP =
 226          brw_fragment_program_const(brw->fragment_program);
 227
 228       if (newFP == curFP)
 229          brw->ctx.NewDriverState |= BRW_NEW_FRAGMENT_PROGRAM;
 230       newFP->id = get_new_program_id(brw->screen);
 231
 232       brw_add_texrect_params(prog);
 233
 234       prog->nir = brw_create_nir(brw, NULL, prog, MESA_SHADER_FRAGMENT, true);
 235
 236       brw_fs_precompile(ctx, NULL, prog);
 237       break;
 238    }
 239    case GL_VERTEX_PROGRAM_ARB: {
 240       struct brw_vertex_program *newVP = brw_vertex_program(prog);
 241       const struct brw_vertex_program *curVP =
 242          brw_vertex_program_const(brw->vertex_program);
 243
 244       if (newVP == curVP)
 245          brw->ctx.NewDriverState |= BRW_NEW_VERTEX_PROGRAM;
 246       if (newVP->program.IsPositionInvariant) {
 247          _mesa_insert_mvp_code(ctx, &newVP->program);
 248       }
 249       newVP->id = get_new_program_id(brw->screen);
 250
 251       /* Also tell tnl about it:
 252        */
 253       _tnl_program_string(ctx, target, prog);
 254
 255       brw_add_texrect_params(prog);
 256
 257       prog->nir = brw_create_nir(brw, NULL, prog, MESA_SHADER_VERTEX,
 258                                  compiler->scalar_stage[MESA_SHADER_VERTEX]);
 259
 260       brw_vs_precompile(ctx, NULL, prog);
 261       break;
 262    }
 263    default:
 264       /*
 265        * driver->ProgramStringNotify is only called for ARB programs, fixed
 266        * function vertex programs, and ir_to_mesa (which isn't used by the
 267        * i965 back-end).  Therefore, even after geometry shaders are added,
 268        * this function should only ever be called with a target of
 269        * GL_VERTEX_PROGRAM_ARB or GL_FRAGMENT_PROGRAM_ARB.
 270        */
 271       unreachable("Unexpected target in brwProgramStringNotify");
 272    }
 273
 274    return true;
 275 }
 276
 277 static void
 278 brw_memory_barrier(struct gl_context *ctx, GLbitfield barriers)
 279 {
 280    struct brw_context *brw = brw_context(ctx);
 281    unsigned bits = (PIPE_CONTROL_DATA_CACHE_FLUSH |
 282                     PIPE_CONTROL_NO_WRITE |
 283                     PIPE_CONTROL_CS_STALL);
 284    assert(brw->gen >= 7 && brw->gen <= 9);
 285
 286    if (barriers & (GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT |
 287                    GL_ELEMENT_ARRAY_BARRIER_BIT |
 288                    GL_COMMAND_BARRIER_BIT))
 289       bits |= PIPE_CONTROL_VF_CACHE_INVALIDATE;
 290
 291    if (barriers & GL_UNIFORM_BARRIER_BIT)
 292       bits |= (PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE |
 293                PIPE_CONTROL_CONST_CACHE_INVALIDATE);
 294
 295    if (barriers & GL_TEXTURE_FETCH_BARRIER_BIT)
 296       bits |= PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE;
 297
 298    if (barriers & GL_TEXTURE_UPDATE_BARRIER_BIT)
 299       bits |= PIPE_CONTROL_RENDER_TARGET_FLUSH;
 300
 301    if (barriers & GL_FRAMEBUFFER_BARRIER_BIT)
 302       bits |= (PIPE_CONTROL_DEPTH_CACHE_FLUSH |
 303                PIPE_CONTROL_RENDER_TARGET_FLUSH);
 304
 305    /* Typed surface messages are handled by the render cache on IVB, so we
 306     * need to flush it too.
 307     */
 308    if (brw->gen == 7 && !brw->is_haswell)
 309       bits |= PIPE_CONTROL_RENDER_TARGET_FLUSH;
 310
 311    brw_emit_pipe_control_flush(brw, bits);
 312 }
 313
 314 static void
 315 brw_blend_barrier(struct gl_context *ctx)
 316 {
 317    struct brw_context *brw = brw_context(ctx);
 318
 319    if (!ctx->Extensions.MESA_shader_framebuffer_fetch) {
 320       if (brw->gen >= 6) {
 321          brw_emit_pipe_control_flush(brw,
 322                                      PIPE_CONTROL_RENDER_TARGET_FLUSH |
 323                                      PIPE_CONTROL_CS_STALL);
 324          brw_emit_pipe_control_flush(brw,
 325                                      PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE);
 326       } else {
 327          brw_emit_pipe_control_flush(brw,
 328                                      PIPE_CONTROL_RENDER_TARGET_FLUSH);
 329       }
 330    }
 331 }
 332
 333 void
 334 brw_add_texrect_params(struct gl_program *prog)
 335 {
 336    for (int texunit = 0; texunit < BRW_MAX_TEX_UNIT; texunit++) {
 337       if (!(prog->TexturesUsed[texunit] & (1 << TEXTURE_RECT_INDEX)))
 338          continue;
 339
 340       int tokens[STATE_LENGTH] = {
 341          STATE_INTERNAL,
 342          STATE_TEXRECT_SCALE,
 343          texunit,
 344          0,
 345          0
 346       };
 347
 348       _mesa_add_state_reference(prog->Parameters, (gl_state_index *)tokens);
 349    }
 350 }
 351
 352 void
 353 brw_get_scratch_bo(struct brw_context *brw,
 354                    drm_intel_bo **scratch_bo, int size)
 355 {
 356    drm_intel_bo *old_bo = *scratch_bo;
 357
 358    if (old_bo && old_bo->size < size) {
 359       drm_intel_bo_unreference(old_bo);
 360       old_bo = NULL;
 361    }
 362
 363    if (!old_bo) {
 364       *scratch_bo = drm_intel_bo_alloc(brw->bufmgr, "scratch bo", size, 4096);
 365    }
 366 }
 367
 368 /**
 369  * Reserve enough scratch space for the given stage to hold \p per_thread_size
 370  * bytes times the given \p thread_count.
 371  */
 372 void
 373 brw_alloc_stage_scratch(struct brw_context *brw,
 374                         struct brw_stage_state *stage_state,
 375                         unsigned per_thread_size,
 376                         unsigned thread_count)
 377 {
 378    if (stage_state->per_thread_scratch < per_thread_size) {
 379       stage_state->per_thread_scratch = per_thread_size;
 380
 381       if (stage_state->scratch_bo)
 382          drm_intel_bo_unreference(stage_state->scratch_bo);
 383
 384       stage_state->scratch_bo =
 385          drm_intel_bo_alloc(brw->bufmgr, "shader scratch space",
 386                             per_thread_size * thread_count, 4096);
 387    }
 388 }
 389
 390 void brwInitFragProgFuncs( struct dd_function_table *functions )
 391 {
 392    assert(functions->ProgramStringNotify == _tnl_program_string);
 393
 394    functions->NewProgram = brwNewProgram;
 395    functions->DeleteProgram = brwDeleteProgram;
 396    functions->ProgramStringNotify = brwProgramStringNotify;
 397
 398    functions->NewShader = brw_new_shader;
 399    functions->LinkShader = brw_link_shader;
 400
 401    functions->MemoryBarrier = brw_memory_barrier;
 402    functions->BlendBarrier = brw_blend_barrier;
 403 }
 404
 405 struct shader_times {
 406    uint64_t time;
 407    uint64_t written;
 408    uint64_t reset;
 409 };
 410
 411 void
 412 brw_init_shader_time(struct brw_context *brw)
 413 {
 414    const int max_entries = 2048;
 415    brw->shader_time.bo =
 416       drm_intel_bo_alloc(brw->bufmgr, "shader time",
 417                          max_entries * SHADER_TIME_STRIDE * 3, 4096);
 418    brw->shader_time.names = rzalloc_array(brw, const char *, max_entries);
 419    brw->shader_time.ids = rzalloc_array(brw, int, max_entries);
 420    brw->shader_time.types = rzalloc_array(brw, enum shader_time_shader_type,
 421                                           max_entries);
 422    brw->shader_time.cumulative = rzalloc_array(brw, struct shader_times,
 423                                                max_entries);
 424    brw->shader_time.max_entries = max_entries;
 425 }
 426
 427 static int
 428 compare_time(const void *a, const void *b)
 429 {
 430    uint64_t * const *a_val = a;
 431    uint64_t * const *b_val = b;
 432
 433    /* We don't just subtract because we're turning the value to an int. */
 434    if (**a_val < **b_val)
 435       return -1;
 436    else if (**a_val == **b_val)
 437       return 0;
 438    else
 439       return 1;
 440 }
 441
 442 static void
 443 print_shader_time_line(const char *stage, const char *name,
 444                        int shader_num, uint64_t time, uint64_t total)
 445 {
 446    fprintf(stderr, "%-6s%-18s", stage, name);
 447
 448    if (shader_num != 0)
 449       fprintf(stderr, "%4d: ", shader_num);
 450    else
 451       fprintf(stderr, "    : ");
 452
 453    fprintf(stderr, "%16lld (%7.2f Gcycles)      %4.1f%%\n",
 454            (long long)time,
 455            (double)time / 1000000000.0,
 456            (double)time / total * 100.0);
 457 }
 458
 459 static void
 460 brw_report_shader_time(struct brw_context *brw)
 461 {
 462    if (!brw->shader_time.bo || !brw->shader_time.num_entries)
 463       return;
 464
 465    uint64_t scaled[brw->shader_time.num_entries];
 466    uint64_t *sorted[brw->shader_time.num_entries];
 467    uint64_t total_by_type[ST_CS + 1];
 468    memset(total_by_type, 0, sizeof(total_by_type));
 469    double total = 0;
 470    for (int i = 0; i < brw->shader_time.num_entries; i++) {
 471       uint64_t written = 0, reset = 0;
 472       enum shader_time_shader_type type = brw->shader_time.types[i];
 473
 474       sorted[i] = &scaled[i];
 475
 476       switch (type) {
 477       case ST_VS:
 478       case ST_TCS:
 479       case ST_TES:
 480       case ST_GS:
 481       case ST_FS8:
 482       case ST_FS16:
 483       case ST_CS:
 484          written = brw->shader_time.cumulative[i].written;
 485          reset = brw->shader_time.cumulative[i].reset;
 486          break;
 487
 488       default:
 489          /* I sometimes want to print things that aren't the 3 shader times.
 490           * Just print the sum in that case.
 491           */
 492          written = 1;
 493          reset = 0;
 494          break;
 495       }
 496
 497       uint64_t time = brw->shader_time.cumulative[i].time;
 498       if (written) {
 499          scaled[i] = time / written * (written + reset);
 500       } else {
 501          scaled[i] = time;
 502       }
 503
 504       switch (type) {
 505       case ST_VS:
 506       case ST_TCS:
 507       case ST_TES:
 508       case ST_GS:
 509       case ST_FS8:
 510       case ST_FS16:
 511       case ST_CS:
 512          total_by_type[type] += scaled[i];
 513          break;
 514       default:
 515          break;
 516       }
 517
 518       total += scaled[i];
 519    }
 520
 521    if (total == 0) {
 522       fprintf(stderr, "No shader time collected yet\n");
 523       return;
 524    }
 525
 526    qsort(sorted, brw->shader_time.num_entries, sizeof(sorted[0]), compare_time);
 527
 528    fprintf(stderr, "\n");
 529    fprintf(stderr, "type          ID                  cycles spent                   %% of total\n");
 530    for (int s = 0; s < brw->shader_time.num_entries; s++) {
 531       const char *stage;
 532       /* Work back from the sorted pointers times to a time to print. */
 533       int i = sorted[s] - scaled;
 534
 535       if (scaled[i] == 0)
 536          continue;
 537
 538       int shader_num = brw->shader_time.ids[i];
 539       const char *shader_name = brw->shader_time.names[i];
 540
 541       switch (brw->shader_time.types[i]) {
 542       case ST_VS:
 543          stage = "vs";
 544          break;
 545       case ST_TCS:
 546          stage = "tcs";
 547          break;
 548       case ST_TES:
 549          stage = "tes";
 550          break;
 551       case ST_GS:
 552          stage = "gs";
 553          break;
 554       case ST_FS8:
 555          stage = "fs8";
 556          break;
 557       case ST_FS16:
 558          stage = "fs16";
 559          break;
 560       case ST_CS:
 561          stage = "cs";
 562          break;
 563       default:
 564          stage = "other";
 565          break;
 566       }
 567
 568       print_shader_time_line(stage, shader_name, shader_num,
 569                              scaled[i], total);
 570    }
 571
 572    fprintf(stderr, "\n");
 573    print_shader_time_line("total", "vs", 0, total_by_type[ST_VS], total);
 574    print_shader_time_line("total", "tcs", 0, total_by_type[ST_TCS], total);
 575    print_shader_time_line("total", "tes", 0, total_by_type[ST_TES], total);
 576    print_shader_time_line("total", "gs", 0, total_by_type[ST_GS], total);
 577    print_shader_time_line("total", "fs8", 0, total_by_type[ST_FS8], total);
 578    print_shader_time_line("total", "fs16", 0, total_by_type[ST_FS16], total);
 579    print_shader_time_line("total", "cs", 0, total_by_type[ST_CS], total);
 580 }
 581
 582 static void
 583 brw_collect_shader_time(struct brw_context *brw)
 584 {
 585    if (!brw->shader_time.bo)
 586       return;
 587
 588    /* This probably stalls on the last rendering.  We could fix that by
 589     * delaying reading the reports, but it doesn't look like it's a big
 590     * overhead compared to the cost of tracking the time in the first place.
 591     */
 592    drm_intel_bo_map(brw->shader_time.bo, true);
 593    void *bo_map = brw->shader_time.bo->virtual;
 594
 595    for (int i = 0; i < brw->shader_time.num_entries; i++) {
 596       uint32_t *times = bo_map + i * 3 * SHADER_TIME_STRIDE;
 597
 598       brw->shader_time.cumulative[i].time += times[SHADER_TIME_STRIDE * 0 / 4];
 599       brw->shader_time.cumulative[i].written += times[SHADER_TIME_STRIDE * 1 / 4];
 600       brw->shader_time.cumulative[i].reset += times[SHADER_TIME_STRIDE * 2 / 4];
 601    }
 602
 603    /* Zero the BO out to clear it out for our next collection.
 604     */
 605    memset(bo_map, 0, brw->shader_time.bo->size);
 606    drm_intel_bo_unmap(brw->shader_time.bo);
 607 }
 608
 609 void
 610 brw_collect_and_report_shader_time(struct brw_context *brw)
 611 {
 612    brw_collect_shader_time(brw);
 613
 614    if (brw->shader_time.report_time == 0 ||
 615        get_time() - brw->shader_time.report_time >= 1.0) {
 616       brw_report_shader_time(brw);
 617       brw->shader_time.report_time = get_time();
 618    }
 619 }
 620
 621 /**
 622  * Chooses an index in the shader_time buffer and sets up tracking information
 623  * for our printouts.
 624  *
 625  * Note that this holds on to references to the underlying programs, which may
 626  * change their lifetimes compared to normal operation.
 627  */
 628 int
 629 brw_get_shader_time_index(struct brw_context *brw,
 630                           struct gl_shader_program *shader_prog,
 631                           struct gl_program *prog,
 632                           enum shader_time_shader_type type)
 633 {
 634    int shader_time_index = brw->shader_time.num_entries++;
 635    assert(shader_time_index < brw->shader_time.max_entries);
 636    brw->shader_time.types[shader_time_index] = type;
 637
 638    int id = shader_prog ? shader_prog->Name : prog->Id;
 639    const char *name;
 640    if (id == 0) {
 641       name = "ff";
 642    } else if (!shader_prog) {
 643       name = "prog";
 644    } else if (shader_prog->Label) {
 645       name = ralloc_strdup(brw->shader_time.names, shader_prog->Label);
 646    } else {
 647       name = "glsl";
 648    }
 649
 650    brw->shader_time.names[shader_time_index] = name;
 651    brw->shader_time.ids[shader_time_index] = id;
 652
 653    return shader_time_index;
 654 }
 655
 656 void
 657 brw_destroy_shader_time(struct brw_context *brw)
 658 {
 659    drm_intel_bo_unreference(brw->shader_time.bo);
 660    brw->shader_time.bo = NULL;
 661 }
 662
 663 void
 664 brw_stage_prog_data_free(const void *p)
 665 {
 666    struct brw_stage_prog_data *prog_data = (struct brw_stage_prog_data *)p;
 667
 668    ralloc_free(prog_data->param);
 669    ralloc_free(prog_data->pull_param);
 670    ralloc_free(prog_data->image_param);
 671 }
 672
 673 void
 674 brw_dump_ir(const char *stage, struct gl_shader_program *shader_prog,
 675             struct gl_linked_shader *shader, struct gl_program *prog)
 676 {
 677    if (shader_prog) {
 678       if (shader->ir) {
 679          fprintf(stderr,
 680                  "GLSL IR for native %s shader %d:\n",
 681                  stage, shader_prog->Name);
 682          _mesa_print_ir(stderr, shader->ir, NULL);
 683          fprintf(stderr, "\n\n");
 684       }
 685    } else {
 686       fprintf(stderr, "ARB_%s_program %d ir for native %s shader\n",
 687               stage, prog->Id, stage);
 688       _mesa_print_program(prog);
 689    }
 690 }
 691
 692 void
 693 brw_setup_tex_for_precompile(struct brw_context *brw,
 694                              struct brw_sampler_prog_key_data *tex,
 695                              struct gl_program *prog)
 696 {
 697    const bool has_shader_channel_select = brw->is_haswell || brw->gen >= 8;
 698    unsigned sampler_count = util_last_bit(prog->SamplersUsed);
 699    for (unsigned i = 0; i < sampler_count; i++) {
 700       if (!has_shader_channel_select && (prog->ShadowSamplers & (1 << i))) {
 701          /* Assume DEPTH_TEXTURE_MODE is the default: X, X, X, 1 */
 702          tex->swizzles[i] =
 703             MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_ONE);
 704       } else {
 705          /* Color sampler: assume no swizzling. */
 706          tex->swizzles[i] = SWIZZLE_XYZW;
 707       }
 708    }
 709 }