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,
  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,
  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    nir_shader_gather_info(nir, nir_shader_get_entrypoint(nir));
 109
 110    if (shader_prog) {
 111       NIR_PASS_V(nir, nir_lower_samplers, shader_prog);
 112       NIR_PASS_V(nir, nir_lower_atomics, shader_prog);
 113    }
 114
 115    return nir;
 116 }
 117
 118 static unsigned
 119 get_new_program_id(struct intel_screen *screen)
 120 {
 121    static pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
 122    pthread_mutex_lock(&m);
 123    unsigned id = screen->program_id++;
 124    pthread_mutex_unlock(&m);
 125    return id;
 126 }
 127
 128 static struct gl_program *brwNewProgram( struct gl_context *ctx,
 129                                       GLenum target,
 130                                       GLuint id )
 131 {
 132    struct brw_context *brw = brw_context(ctx);
 133
 134    switch (target) {
 135    case GL_VERTEX_PROGRAM_ARB:
 136    case GL_TESS_CONTROL_PROGRAM_NV:
 137    case GL_TESS_EVALUATION_PROGRAM_NV:
 138    case GL_GEOMETRY_PROGRAM_NV:
 139    case GL_COMPUTE_PROGRAM_NV: {
 140       struct brw_program *prog = rzalloc(NULL, struct brw_program);
 141       if (prog) {
 142          prog->id = get_new_program_id(brw->screen);
 143
 144          return _mesa_init_gl_program(&prog->program, target, id);
 145       }
 146       else
 147          return NULL;
 148    }
 149
 150    case GL_FRAGMENT_PROGRAM_ARB: {
 151       struct brw_program *prog;
 152       if (brw->gen < 6) {
 153          struct gen4_fragment_program *g4_prog =
 154             rzalloc(NULL, struct gen4_fragment_program);
 155          prog = &g4_prog->base;
 156       } else {
 157          prog = rzalloc(NULL, struct brw_program);
 158       }
 159
 160       if (prog) {
 161          prog->id = get_new_program_id(brw->screen);
 162
 163          return _mesa_init_gl_program(&prog->program, target, id);
 164       }
 165       else
 166          return NULL;
 167    }
 168
 169    default:
 170       unreachable("Unsupported target in brwNewProgram()");
 171    }
 172 }
 173
 174 static void brwDeleteProgram( struct gl_context *ctx,
 175                               struct gl_program *prog )
 176 {
 177    _mesa_delete_program( ctx, prog );
 178 }
 179
 180
 181 static GLboolean
 182 brwProgramStringNotify(struct gl_context *ctx,
 183                        GLenum target,
 184                        struct gl_program *prog)
 185 {
 186    assert(target == GL_VERTEX_PROGRAM_ARB || !prog->IsPositionInvariant);
 187
 188    struct brw_context *brw = brw_context(ctx);
 189    const struct brw_compiler *compiler = brw->screen->compiler;
 190
 191    switch (target) {
 192    case GL_FRAGMENT_PROGRAM_ARB: {
 193       struct brw_program *newFP = brw_program(prog);
 194       const struct brw_program *curFP =
 195          brw_program_const(brw->fragment_program);
 196
 197       if (newFP == curFP)
 198          brw->ctx.NewDriverState |= BRW_NEW_FRAGMENT_PROGRAM;
 199       newFP->id = get_new_program_id(brw->screen);
 200
 201       brw_add_texrect_params(prog);
 202
 203       prog->nir = brw_create_nir(brw, NULL, prog, MESA_SHADER_FRAGMENT, true);
 204
 205       brw_fs_precompile(ctx, NULL, prog);
 206       break;
 207    }
 208    case GL_VERTEX_PROGRAM_ARB: {
 209       struct brw_program *newVP = brw_program(prog);
 210       const struct brw_program *curVP =
 211          brw_program_const(brw->vertex_program);
 212
 213       if (newVP == curVP)
 214          brw->ctx.NewDriverState |= BRW_NEW_VERTEX_PROGRAM;
 215       if (newVP->program.IsPositionInvariant) {
 216          _mesa_insert_mvp_code(ctx, &newVP->program);
 217       }
 218       newVP->id = get_new_program_id(brw->screen);
 219
 220       /* Also tell tnl about it:
 221        */
 222       _tnl_program_string(ctx, target, prog);
 223
 224       brw_add_texrect_params(prog);
 225
 226       prog->nir = brw_create_nir(brw, NULL, prog, MESA_SHADER_VERTEX,
 227                                  compiler->scalar_stage[MESA_SHADER_VERTEX]);
 228
 229       brw_vs_precompile(ctx, NULL, prog);
 230       break;
 231    }
 232    default:
 233       /*
 234        * driver->ProgramStringNotify is only called for ARB programs, fixed
 235        * function vertex programs, and ir_to_mesa (which isn't used by the
 236        * i965 back-end).  Therefore, even after geometry shaders are added,
 237        * this function should only ever be called with a target of
 238        * GL_VERTEX_PROGRAM_ARB or GL_FRAGMENT_PROGRAM_ARB.
 239        */
 240       unreachable("Unexpected target in brwProgramStringNotify");
 241    }
 242
 243    return true;
 244 }
 245
 246 static void
 247 brw_memory_barrier(struct gl_context *ctx, GLbitfield barriers)
 248 {
 249    struct brw_context *brw = brw_context(ctx);
 250    unsigned bits = (PIPE_CONTROL_DATA_CACHE_FLUSH |
 251                     PIPE_CONTROL_NO_WRITE |
 252                     PIPE_CONTROL_CS_STALL);
 253    assert(brw->gen >= 7 && brw->gen <= 9);
 254
 255    if (barriers & (GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT |
 256                    GL_ELEMENT_ARRAY_BARRIER_BIT |
 257                    GL_COMMAND_BARRIER_BIT))
 258       bits |= PIPE_CONTROL_VF_CACHE_INVALIDATE;
 259
 260    if (barriers & GL_UNIFORM_BARRIER_BIT)
 261       bits |= (PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE |
 262                PIPE_CONTROL_CONST_CACHE_INVALIDATE);
 263
 264    if (barriers & GL_TEXTURE_FETCH_BARRIER_BIT)
 265       bits |= PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE;
 266
 267    if (barriers & GL_TEXTURE_UPDATE_BARRIER_BIT)
 268       bits |= PIPE_CONTROL_RENDER_TARGET_FLUSH;
 269
 270    if (barriers & GL_FRAMEBUFFER_BARRIER_BIT)
 271       bits |= (PIPE_CONTROL_DEPTH_CACHE_FLUSH |
 272                PIPE_CONTROL_RENDER_TARGET_FLUSH);
 273
 274    /* Typed surface messages are handled by the render cache on IVB, so we
 275     * need to flush it too.
 276     */
 277    if (brw->gen == 7 && !brw->is_haswell)
 278       bits |= PIPE_CONTROL_RENDER_TARGET_FLUSH;
 279
 280    brw_emit_pipe_control_flush(brw, bits);
 281 }
 282
 283 static void
 284 brw_blend_barrier(struct gl_context *ctx)
 285 {
 286    struct brw_context *brw = brw_context(ctx);
 287
 288    if (!ctx->Extensions.MESA_shader_framebuffer_fetch) {
 289       if (brw->gen >= 6) {
 290          brw_emit_pipe_control_flush(brw,
 291                                      PIPE_CONTROL_RENDER_TARGET_FLUSH |
 292                                      PIPE_CONTROL_CS_STALL);
 293          brw_emit_pipe_control_flush(brw,
 294                                      PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE);
 295       } else {
 296          brw_emit_pipe_control_flush(brw,
 297                                      PIPE_CONTROL_RENDER_TARGET_FLUSH);
 298       }
 299    }
 300 }
 301
 302 void
 303 brw_add_texrect_params(struct gl_program *prog)
 304 {
 305    for (int texunit = 0; texunit < BRW_MAX_TEX_UNIT; texunit++) {
 306       if (!(prog->TexturesUsed[texunit] & (1 << TEXTURE_RECT_INDEX)))
 307          continue;
 308
 309       int tokens[STATE_LENGTH] = {
 310          STATE_INTERNAL,
 311          STATE_TEXRECT_SCALE,
 312          texunit,
 313          0,
 314          0
 315       };
 316
 317       _mesa_add_state_reference(prog->Parameters, (gl_state_index *)tokens);
 318    }
 319 }
 320
 321 void
 322 brw_get_scratch_bo(struct brw_context *brw,
 323                    drm_intel_bo **scratch_bo, int size)
 324 {
 325    drm_intel_bo *old_bo = *scratch_bo;
 326
 327    if (old_bo && old_bo->size < size) {
 328       drm_intel_bo_unreference(old_bo);
 329       old_bo = NULL;
 330    }
 331
 332    if (!old_bo) {
 333       *scratch_bo = drm_intel_bo_alloc(brw->bufmgr, "scratch bo", size, 4096);
 334    }
 335 }
 336
 337 /**
 338  * Reserve enough scratch space for the given stage to hold \p per_thread_size
 339  * bytes times the given \p thread_count.
 340  */
 341 void
 342 brw_alloc_stage_scratch(struct brw_context *brw,
 343                         struct brw_stage_state *stage_state,
 344                         unsigned per_thread_size,
 345                         unsigned thread_count)
 346 {
 347    if (stage_state->per_thread_scratch < per_thread_size) {
 348       stage_state->per_thread_scratch = per_thread_size;
 349
 350       if (stage_state->scratch_bo)
 351          drm_intel_bo_unreference(stage_state->scratch_bo);
 352
 353       stage_state->scratch_bo =
 354          drm_intel_bo_alloc(brw->bufmgr, "shader scratch space",
 355                             per_thread_size * thread_count, 4096);
 356    }
 357 }
 358
 359 void brwInitFragProgFuncs( struct dd_function_table *functions )
 360 {
 361    assert(functions->ProgramStringNotify == _tnl_program_string);
 362
 363    functions->NewProgram = brwNewProgram;
 364    functions->DeleteProgram = brwDeleteProgram;
 365    functions->ProgramStringNotify = brwProgramStringNotify;
 366
 367    functions->NewShader = brw_new_shader;
 368    functions->LinkShader = brw_link_shader;
 369
 370    functions->MemoryBarrier = brw_memory_barrier;
 371    functions->BlendBarrier = brw_blend_barrier;
 372 }
 373
 374 struct shader_times {
 375    uint64_t time;
 376    uint64_t written;
 377    uint64_t reset;
 378 };
 379
 380 void
 381 brw_init_shader_time(struct brw_context *brw)
 382 {
 383    const int max_entries = 2048;
 384    brw->shader_time.bo =
 385       drm_intel_bo_alloc(brw->bufmgr, "shader time",
 386                          max_entries * SHADER_TIME_STRIDE * 3, 4096);
 387    brw->shader_time.names = rzalloc_array(brw, const char *, max_entries);
 388    brw->shader_time.ids = rzalloc_array(brw, int, max_entries);
 389    brw->shader_time.types = rzalloc_array(brw, enum shader_time_shader_type,
 390                                           max_entries);
 391    brw->shader_time.cumulative = rzalloc_array(brw, struct shader_times,
 392                                                max_entries);
 393    brw->shader_time.max_entries = max_entries;
 394 }
 395
 396 static int
 397 compare_time(const void *a, const void *b)
 398 {
 399    uint64_t * const *a_val = a;
 400    uint64_t * const *b_val = b;
 401
 402    /* We don't just subtract because we're turning the value to an int. */
 403    if (**a_val < **b_val)
 404       return -1;
 405    else if (**a_val == **b_val)
 406       return 0;
 407    else
 408       return 1;
 409 }
 410
 411 static void
 412 print_shader_time_line(const char *stage, const char *name,
 413                        int shader_num, uint64_t time, uint64_t total)
 414 {
 415    fprintf(stderr, "%-6s%-18s", stage, name);
 416
 417    if (shader_num != 0)
 418       fprintf(stderr, "%4d: ", shader_num);
 419    else
 420       fprintf(stderr, "    : ");
 421
 422    fprintf(stderr, "%16lld (%7.2f Gcycles)      %4.1f%%\n",
 423            (long long)time,
 424            (double)time / 1000000000.0,
 425            (double)time / total * 100.0);
 426 }
 427
 428 static void
 429 brw_report_shader_time(struct brw_context *brw)
 430 {
 431    if (!brw->shader_time.bo || !brw->shader_time.num_entries)
 432       return;
 433
 434    uint64_t scaled[brw->shader_time.num_entries];
 435    uint64_t *sorted[brw->shader_time.num_entries];
 436    uint64_t total_by_type[ST_CS + 1];
 437    memset(total_by_type, 0, sizeof(total_by_type));
 438    double total = 0;
 439    for (int i = 0; i < brw->shader_time.num_entries; i++) {
 440       uint64_t written = 0, reset = 0;
 441       enum shader_time_shader_type type = brw->shader_time.types[i];
 442
 443       sorted[i] = &scaled[i];
 444
 445       switch (type) {
 446       case ST_VS:
 447       case ST_TCS:
 448       case ST_TES:
 449       case ST_GS:
 450       case ST_FS8:
 451       case ST_FS16:
 452       case ST_CS:
 453          written = brw->shader_time.cumulative[i].written;
 454          reset = brw->shader_time.cumulative[i].reset;
 455          break;
 456
 457       default:
 458          /* I sometimes want to print things that aren't the 3 shader times.
 459           * Just print the sum in that case.
 460           */
 461          written = 1;
 462          reset = 0;
 463          break;
 464       }
 465
 466       uint64_t time = brw->shader_time.cumulative[i].time;
 467       if (written) {
 468          scaled[i] = time / written * (written + reset);
 469       } else {
 470          scaled[i] = time;
 471       }
 472
 473       switch (type) {
 474       case ST_VS:
 475       case ST_TCS:
 476       case ST_TES:
 477       case ST_GS:
 478       case ST_FS8:
 479       case ST_FS16:
 480       case ST_CS:
 481          total_by_type[type] += scaled[i];
 482          break;
 483       default:
 484          break;
 485       }
 486
 487       total += scaled[i];
 488    }
 489
 490    if (total == 0) {
 491       fprintf(stderr, "No shader time collected yet\n");
 492       return;
 493    }
 494
 495    qsort(sorted, brw->shader_time.num_entries, sizeof(sorted[0]), compare_time);
 496
 497    fprintf(stderr, "\n");
 498    fprintf(stderr, "type          ID                  cycles spent                   %% of total\n");
 499    for (int s = 0; s < brw->shader_time.num_entries; s++) {
 500       const char *stage;
 501       /* Work back from the sorted pointers times to a time to print. */
 502       int i = sorted[s] - scaled;
 503
 504       if (scaled[i] == 0)
 505          continue;
 506
 507       int shader_num = brw->shader_time.ids[i];
 508       const char *shader_name = brw->shader_time.names[i];
 509
 510       switch (brw->shader_time.types[i]) {
 511       case ST_VS:
 512          stage = "vs";
 513          break;
 514       case ST_TCS:
 515          stage = "tcs";
 516          break;
 517       case ST_TES:
 518          stage = "tes";
 519          break;
 520       case ST_GS:
 521          stage = "gs";
 522          break;
 523       case ST_FS8:
 524          stage = "fs8";
 525          break;
 526       case ST_FS16:
 527          stage = "fs16";
 528          break;
 529       case ST_CS:
 530          stage = "cs";
 531          break;
 532       default:
 533          stage = "other";
 534          break;
 535       }
 536
 537       print_shader_time_line(stage, shader_name, shader_num,
 538                              scaled[i], total);
 539    }
 540
 541    fprintf(stderr, "\n");
 542    print_shader_time_line("total", "vs", 0, total_by_type[ST_VS], total);
 543    print_shader_time_line("total", "tcs", 0, total_by_type[ST_TCS], total);
 544    print_shader_time_line("total", "tes", 0, total_by_type[ST_TES], total);
 545    print_shader_time_line("total", "gs", 0, total_by_type[ST_GS], total);
 546    print_shader_time_line("total", "fs8", 0, total_by_type[ST_FS8], total);
 547    print_shader_time_line("total", "fs16", 0, total_by_type[ST_FS16], total);
 548    print_shader_time_line("total", "cs", 0, total_by_type[ST_CS], total);
 549 }
 550
 551 static void
 552 brw_collect_shader_time(struct brw_context *brw)
 553 {
 554    if (!brw->shader_time.bo)
 555       return;
 556
 557    /* This probably stalls on the last rendering.  We could fix that by
 558     * delaying reading the reports, but it doesn't look like it's a big
 559     * overhead compared to the cost of tracking the time in the first place.
 560     */
 561    drm_intel_bo_map(brw->shader_time.bo, true);
 562    void *bo_map = brw->shader_time.bo->virtual;
 563
 564    for (int i = 0; i < brw->shader_time.num_entries; i++) {
 565       uint32_t *times = bo_map + i * 3 * SHADER_TIME_STRIDE;
 566
 567       brw->shader_time.cumulative[i].time += times[SHADER_TIME_STRIDE * 0 / 4];
 568       brw->shader_time.cumulative[i].written += times[SHADER_TIME_STRIDE * 1 / 4];
 569       brw->shader_time.cumulative[i].reset += times[SHADER_TIME_STRIDE * 2 / 4];
 570    }
 571
 572    /* Zero the BO out to clear it out for our next collection.
 573     */
 574    memset(bo_map, 0, brw->shader_time.bo->size);
 575    drm_intel_bo_unmap(brw->shader_time.bo);
 576 }
 577
 578 void
 579 brw_collect_and_report_shader_time(struct brw_context *brw)
 580 {
 581    brw_collect_shader_time(brw);
 582
 583    if (brw->shader_time.report_time == 0 ||
 584        get_time() - brw->shader_time.report_time >= 1.0) {
 585       brw_report_shader_time(brw);
 586       brw->shader_time.report_time = get_time();
 587    }
 588 }
 589
 590 /**
 591  * Chooses an index in the shader_time buffer and sets up tracking information
 592  * for our printouts.
 593  *
 594  * Note that this holds on to references to the underlying programs, which may
 595  * change their lifetimes compared to normal operation.
 596  */
 597 int
 598 brw_get_shader_time_index(struct brw_context *brw,
 599                           struct gl_shader_program *shader_prog,
 600                           struct gl_program *prog,
 601                           enum shader_time_shader_type type)
 602 {
 603    int shader_time_index = brw->shader_time.num_entries++;
 604    assert(shader_time_index < brw->shader_time.max_entries);
 605    brw->shader_time.types[shader_time_index] = type;
 606
 607    int id = shader_prog ? shader_prog->Name : prog->Id;
 608    const char *name;
 609    if (id == 0) {
 610       name = "ff";
 611    } else if (!shader_prog) {
 612       name = "prog";
 613    } else if (shader_prog->Label) {
 614       name = ralloc_strdup(brw->shader_time.names, shader_prog->Label);
 615    } else {
 616       name = "glsl";
 617    }
 618
 619    brw->shader_time.names[shader_time_index] = name;
 620    brw->shader_time.ids[shader_time_index] = id;
 621
 622    return shader_time_index;
 623 }
 624
 625 void
 626 brw_destroy_shader_time(struct brw_context *brw)
 627 {
 628    drm_intel_bo_unreference(brw->shader_time.bo);
 629    brw->shader_time.bo = NULL;
 630 }
 631
 632 void
 633 brw_stage_prog_data_free(const void *p)
 634 {
 635    struct brw_stage_prog_data *prog_data = (struct brw_stage_prog_data *)p;
 636
 637    ralloc_free(prog_data->param);
 638    ralloc_free(prog_data->pull_param);
 639    ralloc_free(prog_data->image_param);
 640 }
 641
 642 void
 643 brw_dump_ir(const char *stage, struct gl_shader_program *shader_prog,
 644             struct gl_linked_shader *shader, struct gl_program *prog)
 645 {
 646    if (shader_prog) {
 647       if (shader->ir) {
 648          fprintf(stderr,
 649                  "GLSL IR for native %s shader %d:\n",
 650                  stage, shader_prog->Name);
 651          _mesa_print_ir(stderr, shader->ir, NULL);
 652          fprintf(stderr, "\n\n");
 653       }
 654    } else {
 655       fprintf(stderr, "ARB_%s_program %d ir for native %s shader\n",
 656               stage, prog->Id, stage);
 657       _mesa_print_program(prog);
 658    }
 659 }
 660
 661 void
 662 brw_setup_tex_for_precompile(struct brw_context *brw,
 663                              struct brw_sampler_prog_key_data *tex,
 664                              struct gl_program *prog)
 665 {
 666    const bool has_shader_channel_select = brw->is_haswell || brw->gen >= 8;
 667    unsigned sampler_count = util_last_bit(prog->SamplersUsed);
 668    for (unsigned i = 0; i < sampler_count; i++) {
 669       if (!has_shader_channel_select && (prog->ShadowSamplers & (1 << i))) {
 670          /* Assume DEPTH_TEXTURE_MODE is the default: X, X, X, 1 */
 671          tex->swizzles[i] =
 672             MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_ONE);
 673       } else {
 674          /* Color sampler: assume no swizzling. */
 675          tex->swizzles[i] = SWIZZLE_XYZW;
 676       }
 677    }
 678 }