1 /************************************************************************** 2 * 3 * Copyright 2007 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 * Authors: 29 * Keith Whitwell <keithw (at) vmware.com> 30 * Brian Paul 31 */ 32 33 34 #include "main/imports.h" 35 #include "main/hash.h" 36 #include "main/mtypes.h" 37 #include "program/prog_parameter.h" 38 #include "program/prog_print.h" 39 #include "program/programopt.h" 40 41 #include "compiler/nir/nir.h" 42 43 #include "pipe/p_context.h" 44 #include "pipe/p_defines.h" 45 #include "pipe/p_shader_tokens.h" 46 #include "draw/draw_context.h" 47 #include "tgsi/tgsi_dump.h" 48 #include "tgsi/tgsi_emulate.h" 49 #include "tgsi/tgsi_parse.h" 50 #include "tgsi/tgsi_ureg.h" 51 52 #include "st_debug.h" 53 #include "st_cb_bitmap.h" 54 #include "st_cb_drawpixels.h" 55 #include "st_context.h" 56 #include "st_tgsi_lower_yuv.h" 57 #include "st_program.h" 58 #include "st_mesa_to_tgsi.h" 59 #include "st_atifs_to_tgsi.h" 60 #include "st_nir.h" 61 #include "st_shader_cache.h" 62 #include "cso_cache/cso_context.h" 63 64 65 66 static void 67 set_affected_state_flags(uint64_t *states, 68 struct gl_program *prog, 69 uint64_t new_constants, 70 uint64_t new_sampler_views, 71 uint64_t new_samplers, 72 uint64_t new_images, 73 uint64_t new_ubos, 74 uint64_t new_ssbos, 75 uint64_t new_atomics) 76 { 77 if (prog->Parameters->NumParameters) 78 *states |= new_constants; 79 80 if (prog->info.num_textures) 81 *states |= new_sampler_views | new_samplers; 82 83 if (prog->info.num_images) 84 *states |= new_images; 85 86 if (prog->info.num_ubos) 87 *states |= new_ubos; 88 89 if (prog->info.num_ssbos) 90 *states |= new_ssbos; 91 92 if (prog->info.num_abos) 93 *states |= new_atomics; 94 } 95 96 /** 97 * This determines which states will be updated when the shader is bound. 98 */ 99 void 100 st_set_prog_affected_state_flags(struct gl_program *prog) 101 { 102 uint64_t *states; 103 104 switch (prog->info.stage) { 105 case MESA_SHADER_VERTEX: 106 states = &((struct st_vertex_program*)prog)->affected_states; 107 108 *states = ST_NEW_VS_STATE | 109 ST_NEW_RASTERIZER | 110 ST_NEW_VERTEX_ARRAYS; 111 112 set_affected_state_flags(states, prog, 113 ST_NEW_VS_CONSTANTS, 114 ST_NEW_VS_SAMPLER_VIEWS, 115 ST_NEW_VS_SAMPLERS, 116 ST_NEW_VS_IMAGES, 117 ST_NEW_VS_UBOS, 118 ST_NEW_VS_SSBOS, 119 ST_NEW_VS_ATOMICS); 120 break; 121 122 case MESA_SHADER_TESS_CTRL: 123 states = &(st_common_program(prog))->affected_states; 124 125 *states = ST_NEW_TCS_STATE; 126 127 set_affected_state_flags(states, prog, 128 ST_NEW_TCS_CONSTANTS, 129 ST_NEW_TCS_SAMPLER_VIEWS, 130 ST_NEW_TCS_SAMPLERS, 131 ST_NEW_TCS_IMAGES, 132 ST_NEW_TCS_UBOS, 133 ST_NEW_TCS_SSBOS, 134 ST_NEW_TCS_ATOMICS); 135 break; 136 137 case MESA_SHADER_TESS_EVAL: 138 states = &(st_common_program(prog))->affected_states; 139 140 *states = ST_NEW_TES_STATE | 141 ST_NEW_RASTERIZER; 142 143 set_affected_state_flags(states, prog, 144 ST_NEW_TES_CONSTANTS, 145 ST_NEW_TES_SAMPLER_VIEWS, 146 ST_NEW_TES_SAMPLERS, 147 ST_NEW_TES_IMAGES, 148 ST_NEW_TES_UBOS, 149 ST_NEW_TES_SSBOS, 150 ST_NEW_TES_ATOMICS); 151 break; 152 153 case MESA_SHADER_GEOMETRY: 154 states = &(st_common_program(prog))->affected_states; 155 156 *states = ST_NEW_GS_STATE | 157 ST_NEW_RASTERIZER; 158 159 set_affected_state_flags(states, prog, 160 ST_NEW_GS_CONSTANTS, 161 ST_NEW_GS_SAMPLER_VIEWS, 162 ST_NEW_GS_SAMPLERS, 163 ST_NEW_GS_IMAGES, 164 ST_NEW_GS_UBOS, 165 ST_NEW_GS_SSBOS, 166 ST_NEW_GS_ATOMICS); 167 break; 168 169 case MESA_SHADER_FRAGMENT: 170 states = &((struct st_fragment_program*)prog)->affected_states; 171 172 /* gl_FragCoord and glDrawPixels always use constants. */ 173 *states = ST_NEW_FS_STATE | 174 ST_NEW_SAMPLE_SHADING | 175 ST_NEW_FS_CONSTANTS; 176 177 set_affected_state_flags(states, prog, 178 ST_NEW_FS_CONSTANTS, 179 ST_NEW_FS_SAMPLER_VIEWS, 180 ST_NEW_FS_SAMPLERS, 181 ST_NEW_FS_IMAGES, 182 ST_NEW_FS_UBOS, 183 ST_NEW_FS_SSBOS, 184 ST_NEW_FS_ATOMICS); 185 break; 186 187 case MESA_SHADER_COMPUTE: 188 states = &((struct st_compute_program*)prog)->affected_states; 189 190 *states = ST_NEW_CS_STATE; 191 192 set_affected_state_flags(states, prog, 193 ST_NEW_CS_CONSTANTS, 194 ST_NEW_CS_SAMPLER_VIEWS, 195 ST_NEW_CS_SAMPLERS, 196 ST_NEW_CS_IMAGES, 197 ST_NEW_CS_UBOS, 198 ST_NEW_CS_SSBOS, 199 ST_NEW_CS_ATOMICS); 200 break; 201 202 default: 203 unreachable("unhandled shader stage"); 204 } 205 } 206 207 /** 208 * Delete a vertex program variant. Note the caller must unlink 209 * the variant from the linked list. 210 */ 211 static void 212 delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv) 213 { 214 if (vpv->driver_shader) 215 cso_delete_vertex_shader(st->cso_context, vpv->driver_shader); 216 217 if (vpv->draw_shader) 218 draw_delete_vertex_shader( st->draw, vpv->draw_shader ); 219 220 if (((vpv->tgsi.type == PIPE_SHADER_IR_TGSI)) && vpv->tgsi.tokens) 221 ureg_free_tokens(vpv->tgsi.tokens); 222 223 free( vpv ); 224 } 225 226 227 228 /** 229 * Clean out any old compilations: 230 */ 231 void 232 st_release_vp_variants( struct st_context *st, 233 struct st_vertex_program *stvp ) 234 { 235 struct st_vp_variant *vpv; 236 237 for (vpv = stvp->variants; vpv; ) { 238 struct st_vp_variant *next = vpv->next; 239 delete_vp_variant(st, vpv); 240 vpv = next; 241 } 242 243 stvp->variants = NULL; 244 245 if ((stvp->tgsi.type == PIPE_SHADER_IR_TGSI) && stvp->tgsi.tokens) { 246 tgsi_free_tokens(stvp->tgsi.tokens); 247 stvp->tgsi.tokens = NULL; 248 } 249 } 250 251 252 253 /** 254 * Delete a fragment program variant. Note the caller must unlink 255 * the variant from the linked list. 256 */ 257 static void 258 delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv) 259 { 260 if (fpv->driver_shader) 261 cso_delete_fragment_shader(st->cso_context, fpv->driver_shader); 262 free(fpv); 263 } 264 265 266 /** 267 * Free all variants of a fragment program. 268 */ 269 void 270 st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp) 271 { 272 struct st_fp_variant *fpv; 273 274 for (fpv = stfp->variants; fpv; ) { 275 struct st_fp_variant *next = fpv->next; 276 delete_fp_variant(st, fpv); 277 fpv = next; 278 } 279 280 stfp->variants = NULL; 281 282 if ((stfp->tgsi.type == PIPE_SHADER_IR_TGSI) && stfp->tgsi.tokens) { 283 ureg_free_tokens(stfp->tgsi.tokens); 284 stfp->tgsi.tokens = NULL; 285 } 286 } 287 288 289 /** 290 * Delete a basic program variant. Note the caller must unlink 291 * the variant from the linked list. 292 */ 293 static void 294 delete_basic_variant(struct st_context *st, struct st_basic_variant *v, 295 GLenum target) 296 { 297 if (v->driver_shader) { 298 switch (target) { 299 case GL_TESS_CONTROL_PROGRAM_NV: 300 cso_delete_tessctrl_shader(st->cso_context, v->driver_shader); 301 break; 302 case GL_TESS_EVALUATION_PROGRAM_NV: 303 cso_delete_tesseval_shader(st->cso_context, v->driver_shader); 304 break; 305 case GL_GEOMETRY_PROGRAM_NV: 306 cso_delete_geometry_shader(st->cso_context, v->driver_shader); 307 break; 308 case GL_COMPUTE_PROGRAM_NV: 309 cso_delete_compute_shader(st->cso_context, v->driver_shader); 310 break; 311 default: 312 assert(!"this shouldn't occur"); 313 } 314 } 315 316 free(v); 317 } 318 319 320 /** 321 * Free all basic program variants. 322 */ 323 void 324 st_release_basic_variants(struct st_context *st, GLenum target, 325 struct st_basic_variant **variants, 326 struct pipe_shader_state *tgsi) 327 { 328 struct st_basic_variant *v; 329 330 for (v = *variants; v; ) { 331 struct st_basic_variant *next = v->next; 332 delete_basic_variant(st, v, target); 333 v = next; 334 } 335 336 *variants = NULL; 337 338 if (tgsi->tokens) { 339 ureg_free_tokens(tgsi->tokens); 340 tgsi->tokens = NULL; 341 } 342 } 343 344 345 /** 346 * Free all variants of a compute program. 347 */ 348 void 349 st_release_cp_variants(struct st_context *st, struct st_compute_program *stcp) 350 { 351 struct st_basic_variant **variants = &stcp->variants; 352 struct st_basic_variant *v; 353 354 for (v = *variants; v; ) { 355 struct st_basic_variant *next = v->next; 356 delete_basic_variant(st, v, stcp->Base.Target); 357 v = next; 358 } 359 360 *variants = NULL; 361 362 if (stcp->tgsi.prog) { 363 switch (stcp->tgsi.ir_type) { 364 case PIPE_SHADER_IR_TGSI: 365 ureg_free_tokens(stcp->tgsi.prog); 366 stcp->tgsi.prog = NULL; 367 break; 368 case PIPE_SHADER_IR_NIR: 369 /* pipe driver took ownership of prog */ 370 break; 371 case PIPE_SHADER_IR_LLVM: 372 case PIPE_SHADER_IR_NATIVE: 373 /* ??? */ 374 stcp->tgsi.prog = NULL; 375 break; 376 } 377 } 378 } 379 380 /** 381 * Translate a vertex program. 382 */ 383 bool 384 st_translate_vertex_program(struct st_context *st, 385 struct st_vertex_program *stvp) 386 { 387 struct ureg_program *ureg; 388 enum pipe_error error; 389 unsigned num_outputs = 0; 390 unsigned attr; 391 ubyte input_to_index[VERT_ATTRIB_MAX] = {0}; 392 ubyte output_semantic_name[VARYING_SLOT_MAX] = {0}; 393 ubyte output_semantic_index[VARYING_SLOT_MAX] = {0}; 394 395 stvp->num_inputs = 0; 396 397 if (stvp->Base.arb.IsPositionInvariant) 398 _mesa_insert_mvp_code(st->ctx, &stvp->Base); 399 400 /* 401 * Determine number of inputs, the mappings between VERT_ATTRIB_x 402 * and TGSI generic input indexes, plus input attrib semantic info. 403 */ 404 for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) { 405 if ((stvp->Base.info.inputs_read & BITFIELD64_BIT(attr)) != 0) { 406 input_to_index[attr] = stvp->num_inputs; 407 stvp->index_to_input[stvp->num_inputs] = attr; 408 stvp->num_inputs++; 409 if ((stvp->Base.info.double_inputs_read & 410 BITFIELD64_BIT(attr)) != 0) { 411 /* add placeholder for second part of a double attribute */ 412 stvp->index_to_input[stvp->num_inputs] = ST_DOUBLE_ATTRIB_PLACEHOLDER; 413 stvp->num_inputs++; 414 } 415 } 416 } 417 /* bit of a hack, presetup potentially unused edgeflag input */ 418 input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs; 419 stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG; 420 421 /* Compute mapping of vertex program outputs to slots. 422 */ 423 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) { 424 if ((stvp->Base.info.outputs_written & BITFIELD64_BIT(attr)) == 0) { 425 stvp->result_to_output[attr] = ~0; 426 } 427 else { 428 unsigned slot = num_outputs++; 429 430 stvp->result_to_output[attr] = slot; 431 432 unsigned semantic_name, semantic_index; 433 tgsi_get_gl_varying_semantic(attr, st->needs_texcoord_semantic, 434 &semantic_name, &semantic_index); 435 output_semantic_name[slot] = semantic_name; 436 output_semantic_index[slot] = semantic_index; 437 } 438 } 439 /* similar hack to above, presetup potentially unused edgeflag output */ 440 stvp->result_to_output[VARYING_SLOT_EDGE] = num_outputs; 441 output_semantic_name[num_outputs] = TGSI_SEMANTIC_EDGEFLAG; 442 output_semantic_index[num_outputs] = 0; 443 444 /* ARB_vp: */ 445 if (!stvp->glsl_to_tgsi && !stvp->shader_program) { 446 _mesa_remove_output_reads(&stvp->Base, PROGRAM_OUTPUT); 447 448 /* This determines which states will be updated when the assembly 449 * shader is bound. 450 */ 451 stvp->affected_states = ST_NEW_VS_STATE | 452 ST_NEW_RASTERIZER | 453 ST_NEW_VERTEX_ARRAYS; 454 455 if (stvp->Base.Parameters->NumParameters) 456 stvp->affected_states |= ST_NEW_VS_CONSTANTS; 457 458 /* No samplers are allowed in ARB_vp. */ 459 } 460 461 if (stvp->shader_program) { 462 struct gl_program *prog = stvp->shader_program->last_vert_prog; 463 if (prog) { 464 st_translate_stream_output_info2(prog->sh.LinkedTransformFeedback, 465 stvp->result_to_output, 466 &stvp->tgsi.stream_output); 467 } 468 469 return true; 470 } 471 472 ureg = ureg_create_with_screen(PIPE_SHADER_VERTEX, st->pipe->screen); 473 if (ureg == NULL) 474 return false; 475 476 if (stvp->Base.info.clip_distance_array_size) 477 ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED, 478 stvp->Base.info.clip_distance_array_size); 479 if (stvp->Base.info.cull_distance_array_size) 480 ureg_property(ureg, TGSI_PROPERTY_NUM_CULLDIST_ENABLED, 481 stvp->Base.info.cull_distance_array_size); 482 483 if (ST_DEBUG & DEBUG_MESA) { 484 _mesa_print_program(&stvp->Base); 485 _mesa_print_program_parameters(st->ctx, &stvp->Base); 486 debug_printf("\n"); 487 } 488 489 if (stvp->glsl_to_tgsi) { 490 error = st_translate_program(st->ctx, 491 PIPE_SHADER_VERTEX, 492 ureg, 493 stvp->glsl_to_tgsi, 494 &stvp->Base, 495 /* inputs */ 496 stvp->num_inputs, 497 input_to_index, 498 NULL, /* inputSlotToAttr */ 499 NULL, /* input semantic name */ 500 NULL, /* input semantic index */ 501 NULL, /* interp mode */ 502 /* outputs */ 503 num_outputs, 504 stvp->result_to_output, 505 output_semantic_name, 506 output_semantic_index); 507 508 st_translate_stream_output_info(stvp->glsl_to_tgsi, 509 stvp->result_to_output, 510 &stvp->tgsi.stream_output); 511 512 free_glsl_to_tgsi_visitor(stvp->glsl_to_tgsi); 513 } else 514 error = st_translate_mesa_program(st->ctx, 515 PIPE_SHADER_VERTEX, 516 ureg, 517 &stvp->Base, 518 /* inputs */ 519 stvp->num_inputs, 520 input_to_index, 521 NULL, /* input semantic name */ 522 NULL, /* input semantic index */ 523 NULL, 524 /* outputs */ 525 num_outputs, 526 stvp->result_to_output, 527 output_semantic_name, 528 output_semantic_index); 529 530 if (error) { 531 debug_printf("%s: failed to translate Mesa program:\n", __func__); 532 _mesa_print_program(&stvp->Base); 533 debug_assert(0); 534 return false; 535 } 536 537 stvp->tgsi.tokens = ureg_get_tokens(ureg, &stvp->num_tgsi_tokens); 538 ureg_destroy(ureg); 539 540 if (stvp->glsl_to_tgsi) { 541 stvp->glsl_to_tgsi = NULL; 542 st_store_tgsi_in_disk_cache(st, &stvp->Base); 543 } 544 545 return stvp->tgsi.tokens != NULL; 546 } 547 548 static struct st_vp_variant * 549 st_create_vp_variant(struct st_context *st, 550 struct st_vertex_program *stvp, 551 const struct st_vp_variant_key *key) 552 { 553 struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant); 554 struct pipe_context *pipe = st->pipe; 555 556 vpv->key = *key; 557 vpv->tgsi.stream_output = stvp->tgsi.stream_output; 558 vpv->num_inputs = stvp->num_inputs; 559 560 if (stvp->tgsi.type == PIPE_SHADER_IR_NIR) { 561 vpv->tgsi.type = PIPE_SHADER_IR_NIR; 562 vpv->tgsi.ir.nir = nir_shader_clone(NULL, stvp->tgsi.ir.nir); 563 if (key->clamp_color) 564 NIR_PASS_V(vpv->tgsi.ir.nir, nir_lower_clamp_color_outputs); 565 if (key->passthrough_edgeflags) { 566 NIR_PASS_V(vpv->tgsi.ir.nir, nir_lower_passthrough_edgeflags); 567 vpv->num_inputs++; 568 } 569 570 st_finalize_nir(st, &stvp->Base, stvp->shader_program, 571 vpv->tgsi.ir.nir); 572 573 vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi); 574 /* driver takes ownership of IR: */ 575 vpv->tgsi.ir.nir = NULL; 576 return vpv; 577 } 578 579 vpv->tgsi.tokens = tgsi_dup_tokens(stvp->tgsi.tokens); 580 581 /* Emulate features. */ 582 if (key->clamp_color || key->passthrough_edgeflags) { 583 const struct tgsi_token *tokens; 584 unsigned flags = 585 (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) | 586 (key->passthrough_edgeflags ? TGSI_EMU_PASSTHROUGH_EDGEFLAG : 0); 587 588 tokens = tgsi_emulate(vpv->tgsi.tokens, flags); 589 590 if (tokens) { 591 tgsi_free_tokens(vpv->tgsi.tokens); 592 vpv->tgsi.tokens = tokens; 593 594 if (key->passthrough_edgeflags) 595 vpv->num_inputs++; 596 } else 597 fprintf(stderr, "mesa: cannot emulate deprecated features\n"); 598 } 599 600 if (ST_DEBUG & DEBUG_TGSI) { 601 tgsi_dump(vpv->tgsi.tokens, 0); 602 debug_printf("\n"); 603 } 604 605 vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi); 606 return vpv; 607 } 608 609 610 /** 611 * Find/create a vertex program variant. 612 */ 613 struct st_vp_variant * 614 st_get_vp_variant(struct st_context *st, 615 struct st_vertex_program *stvp, 616 const struct st_vp_variant_key *key) 617 { 618 struct st_vp_variant *vpv; 619 620 /* Search for existing variant */ 621 for (vpv = stvp->variants; vpv; vpv = vpv->next) { 622 if (memcmp(&vpv->key, key, sizeof(*key)) == 0) { 623 break; 624 } 625 } 626 627 if (!vpv) { 628 /* create now */ 629 vpv = st_create_vp_variant(st, stvp, key); 630 if (vpv) { 631 /* insert into list */ 632 vpv->next = stvp->variants; 633 stvp->variants = vpv; 634 } 635 } 636 637 return vpv; 638 } 639 640 641 /** 642 * Translate a Mesa fragment shader into a TGSI shader. 643 */ 644 bool 645 st_translate_fragment_program(struct st_context *st, 646 struct st_fragment_program *stfp) 647 { 648 ubyte outputMapping[2 * FRAG_RESULT_MAX]; 649 ubyte inputMapping[VARYING_SLOT_MAX]; 650 ubyte inputSlotToAttr[VARYING_SLOT_MAX]; 651 ubyte interpMode[PIPE_MAX_SHADER_INPUTS]; /* XXX size? */ 652 GLuint attr; 653 GLbitfield64 inputsRead; 654 struct ureg_program *ureg; 655 656 GLboolean write_all = GL_FALSE; 657 658 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS]; 659 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS]; 660 uint fs_num_inputs = 0; 661 662 ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS]; 663 ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS]; 664 uint fs_num_outputs = 0; 665 666 memset(inputSlotToAttr, ~0, sizeof(inputSlotToAttr)); 667 668 /* Non-GLSL programs: */ 669 if (!stfp->glsl_to_tgsi && !stfp->shader_program) { 670 _mesa_remove_output_reads(&stfp->Base, PROGRAM_OUTPUT); 671 if (st->ctx->Const.GLSLFragCoordIsSysVal) 672 _mesa_program_fragment_position_to_sysval(&stfp->Base); 673 674 /* This determines which states will be updated when the assembly 675 * shader is bound. 676 * 677 * fragment.position and glDrawPixels always use constants. 678 */ 679 stfp->affected_states = ST_NEW_FS_STATE | 680 ST_NEW_SAMPLE_SHADING | 681 ST_NEW_FS_CONSTANTS; 682 683 if (stfp->ati_fs) { 684 /* Just set them for ATI_fs unconditionally. */ 685 stfp->affected_states |= ST_NEW_FS_SAMPLER_VIEWS | 686 ST_NEW_FS_SAMPLERS; 687 } else { 688 /* ARB_fp */ 689 if (stfp->Base.SamplersUsed) 690 stfp->affected_states |= ST_NEW_FS_SAMPLER_VIEWS | 691 ST_NEW_FS_SAMPLERS; 692 } 693 } 694 695 /* 696 * Convert Mesa program inputs to TGSI input register semantics. 697 */ 698 inputsRead = stfp->Base.info.inputs_read; 699 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) { 700 if ((inputsRead & BITFIELD64_BIT(attr)) != 0) { 701 const GLuint slot = fs_num_inputs++; 702 703 inputMapping[attr] = slot; 704 inputSlotToAttr[slot] = attr; 705 706 switch (attr) { 707 case VARYING_SLOT_POS: 708 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION; 709 input_semantic_index[slot] = 0; 710 interpMode[slot] = TGSI_INTERPOLATE_LINEAR; 711 break; 712 case VARYING_SLOT_COL0: 713 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR; 714 input_semantic_index[slot] = 0; 715 interpMode[slot] = stfp->glsl_to_tgsi ? 716 TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_COLOR; 717 break; 718 case VARYING_SLOT_COL1: 719 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR; 720 input_semantic_index[slot] = 1; 721 interpMode[slot] = stfp->glsl_to_tgsi ? 722 TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_COLOR; 723 break; 724 case VARYING_SLOT_FOGC: 725 input_semantic_name[slot] = TGSI_SEMANTIC_FOG; 726 input_semantic_index[slot] = 0; 727 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE; 728 break; 729 case VARYING_SLOT_FACE: 730 input_semantic_name[slot] = TGSI_SEMANTIC_FACE; 731 input_semantic_index[slot] = 0; 732 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT; 733 break; 734 case VARYING_SLOT_PRIMITIVE_ID: 735 input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID; 736 input_semantic_index[slot] = 0; 737 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT; 738 break; 739 case VARYING_SLOT_LAYER: 740 input_semantic_name[slot] = TGSI_SEMANTIC_LAYER; 741 input_semantic_index[slot] = 0; 742 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT; 743 break; 744 case VARYING_SLOT_VIEWPORT: 745 input_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX; 746 input_semantic_index[slot] = 0; 747 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT; 748 break; 749 case VARYING_SLOT_CLIP_DIST0: 750 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST; 751 input_semantic_index[slot] = 0; 752 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE; 753 break; 754 case VARYING_SLOT_CLIP_DIST1: 755 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST; 756 input_semantic_index[slot] = 1; 757 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE; 758 break; 759 case VARYING_SLOT_CULL_DIST0: 760 case VARYING_SLOT_CULL_DIST1: 761 /* these should have been lowered by GLSL */ 762 assert(0); 763 break; 764 /* In most cases, there is nothing special about these 765 * inputs, so adopt a convention to use the generic 766 * semantic name and the mesa VARYING_SLOT_ number as the 767 * index. 768 * 769 * All that is required is that the vertex shader labels 770 * its own outputs similarly, and that the vertex shader 771 * generates at least every output required by the 772 * fragment shader plus fixed-function hardware (such as 773 * BFC). 774 * 775 * However, some drivers may need us to identify the PNTC and TEXi 776 * varyings if, for example, their capability to replace them with 777 * sprite coordinates is limited. 778 */ 779 case VARYING_SLOT_PNTC: 780 if (st->needs_texcoord_semantic) { 781 input_semantic_name[slot] = TGSI_SEMANTIC_PCOORD; 782 input_semantic_index[slot] = 0; 783 interpMode[slot] = TGSI_INTERPOLATE_LINEAR; 784 break; 785 } 786 /* fall through */ 787 case VARYING_SLOT_TEX0: 788 case VARYING_SLOT_TEX1: 789 case VARYING_SLOT_TEX2: 790 case VARYING_SLOT_TEX3: 791 case VARYING_SLOT_TEX4: 792 case VARYING_SLOT_TEX5: 793 case VARYING_SLOT_TEX6: 794 case VARYING_SLOT_TEX7: 795 if (st->needs_texcoord_semantic) { 796 input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD; 797 input_semantic_index[slot] = attr - VARYING_SLOT_TEX0; 798 interpMode[slot] = stfp->glsl_to_tgsi ? 799 TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_PERSPECTIVE; 800 break; 801 } 802 /* fall through */ 803 case VARYING_SLOT_VAR0: 804 default: 805 /* Semantic indices should be zero-based because drivers may choose 806 * to assign a fixed slot determined by that index. 807 * This is useful because ARB_separate_shader_objects uses location 808 * qualifiers for linkage, and if the semantic index corresponds to 809 * these locations, linkage passes in the driver become unecessary. 810 * 811 * If needs_texcoord_semantic is true, no semantic indices will be 812 * consumed for the TEXi varyings, and we can base the locations of 813 * the user varyings on VAR0. Otherwise, we use TEX0 as base index. 814 */ 815 assert(attr >= VARYING_SLOT_VAR0 || attr == VARYING_SLOT_PNTC || 816 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7)); 817 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; 818 input_semantic_index[slot] = st_get_generic_varying_index(st, attr); 819 if (attr == VARYING_SLOT_PNTC) 820 interpMode[slot] = TGSI_INTERPOLATE_LINEAR; 821 else { 822 interpMode[slot] = stfp->glsl_to_tgsi ? 823 TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_PERSPECTIVE; 824 } 825 break; 826 } 827 } 828 else { 829 inputMapping[attr] = -1; 830 } 831 } 832 833 /* 834 * Semantics and mapping for outputs 835 */ 836 GLbitfield64 outputsWritten = stfp->Base.info.outputs_written; 837 838 /* if z is written, emit that first */ 839 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) { 840 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION; 841 fs_output_semantic_index[fs_num_outputs] = 0; 842 outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs; 843 fs_num_outputs++; 844 outputsWritten &= ~(1 << FRAG_RESULT_DEPTH); 845 } 846 847 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) { 848 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL; 849 fs_output_semantic_index[fs_num_outputs] = 0; 850 outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs; 851 fs_num_outputs++; 852 outputsWritten &= ~(1 << FRAG_RESULT_STENCIL); 853 } 854 855 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK)) { 856 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_SAMPLEMASK; 857 fs_output_semantic_index[fs_num_outputs] = 0; 858 outputMapping[FRAG_RESULT_SAMPLE_MASK] = fs_num_outputs; 859 fs_num_outputs++; 860 outputsWritten &= ~(1 << FRAG_RESULT_SAMPLE_MASK); 861 } 862 863 /* handle remaining outputs (color) */ 864 for (attr = 0; attr < ARRAY_SIZE(outputMapping); attr++) { 865 const GLbitfield64 written = attr < FRAG_RESULT_MAX ? outputsWritten : 866 stfp->Base.SecondaryOutputsWritten; 867 const unsigned loc = attr % FRAG_RESULT_MAX; 868 869 if (written & BITFIELD64_BIT(loc)) { 870 switch (loc) { 871 case FRAG_RESULT_DEPTH: 872 case FRAG_RESULT_STENCIL: 873 case FRAG_RESULT_SAMPLE_MASK: 874 /* handled above */ 875 assert(0); 876 break; 877 case FRAG_RESULT_COLOR: 878 write_all = GL_TRUE; /* fallthrough */ 879 default: { 880 int index; 881 assert(loc == FRAG_RESULT_COLOR || 882 (FRAG_RESULT_DATA0 <= loc && loc < FRAG_RESULT_MAX)); 883 884 index = (loc == FRAG_RESULT_COLOR) ? 0 : (loc - FRAG_RESULT_DATA0); 885 886 if (attr >= FRAG_RESULT_MAX) { 887 /* Secondary color for dual source blending. */ 888 assert(index == 0); 889 index++; 890 } 891 892 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR; 893 fs_output_semantic_index[fs_num_outputs] = index; 894 outputMapping[attr] = fs_num_outputs; 895 break; 896 } 897 } 898 899 fs_num_outputs++; 900 } 901 } 902 903 /* We have already compiler to NIR so just return */ 904 if (stfp->shader_program) 905 return true; 906 907 ureg = ureg_create_with_screen(PIPE_SHADER_FRAGMENT, st->pipe->screen); 908 if (ureg == NULL) 909 return false; 910 911 if (ST_DEBUG & DEBUG_MESA) { 912 _mesa_print_program(&stfp->Base); 913 _mesa_print_program_parameters(st->ctx, &stfp->Base); 914 debug_printf("\n"); 915 } 916 if (write_all == GL_TRUE) 917 ureg_property(ureg, TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS, 1); 918 919 if (stfp->Base.info.fs.depth_layout != FRAG_DEPTH_LAYOUT_NONE) { 920 switch (stfp->Base.info.fs.depth_layout) { 921 case FRAG_DEPTH_LAYOUT_ANY: 922 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT, 923 TGSI_FS_DEPTH_LAYOUT_ANY); 924 break; 925 case FRAG_DEPTH_LAYOUT_GREATER: 926 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT, 927 TGSI_FS_DEPTH_LAYOUT_GREATER); 928 break; 929 case FRAG_DEPTH_LAYOUT_LESS: 930 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT, 931 TGSI_FS_DEPTH_LAYOUT_LESS); 932 break; 933 case FRAG_DEPTH_LAYOUT_UNCHANGED: 934 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT, 935 TGSI_FS_DEPTH_LAYOUT_UNCHANGED); 936 break; 937 default: 938 assert(0); 939 } 940 } 941 942 if (stfp->glsl_to_tgsi) { 943 st_translate_program(st->ctx, 944 PIPE_SHADER_FRAGMENT, 945 ureg, 946 stfp->glsl_to_tgsi, 947 &stfp->Base, 948 /* inputs */ 949 fs_num_inputs, 950 inputMapping, 951 inputSlotToAttr, 952 input_semantic_name, 953 input_semantic_index, 954 interpMode, 955 /* outputs */ 956 fs_num_outputs, 957 outputMapping, 958 fs_output_semantic_name, 959 fs_output_semantic_index); 960 961 free_glsl_to_tgsi_visitor(stfp->glsl_to_tgsi); 962 } else if (stfp->ati_fs) 963 st_translate_atifs_program(ureg, 964 stfp->ati_fs, 965 &stfp->Base, 966 /* inputs */ 967 fs_num_inputs, 968 inputMapping, 969 input_semantic_name, 970 input_semantic_index, 971 interpMode, 972 /* outputs */ 973 fs_num_outputs, 974 outputMapping, 975 fs_output_semantic_name, 976 fs_output_semantic_index); 977 else 978 st_translate_mesa_program(st->ctx, 979 PIPE_SHADER_FRAGMENT, 980 ureg, 981 &stfp->Base, 982 /* inputs */ 983 fs_num_inputs, 984 inputMapping, 985 input_semantic_name, 986 input_semantic_index, 987 interpMode, 988 /* outputs */ 989 fs_num_outputs, 990 outputMapping, 991 fs_output_semantic_name, 992 fs_output_semantic_index); 993 994 stfp->tgsi.tokens = ureg_get_tokens(ureg, &stfp->num_tgsi_tokens); 995 ureg_destroy(ureg); 996 997 if (stfp->glsl_to_tgsi) { 998 stfp->glsl_to_tgsi = NULL; 999 st_store_tgsi_in_disk_cache(st, &stfp->Base); 1000 } 1001 1002 return stfp->tgsi.tokens != NULL; 1003 } 1004 1005 static struct st_fp_variant * 1006 st_create_fp_variant(struct st_context *st, 1007 struct st_fragment_program *stfp, 1008 const struct st_fp_variant_key *key) 1009 { 1010 struct pipe_context *pipe = st->pipe; 1011 struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant); 1012 struct pipe_shader_state tgsi = {0}; 1013 struct gl_program_parameter_list *params = stfp->Base.Parameters; 1014 static const gl_state_index texcoord_state[STATE_LENGTH] = 1015 { STATE_INTERNAL, STATE_CURRENT_ATTRIB, VERT_ATTRIB_TEX0 }; 1016 static const gl_state_index scale_state[STATE_LENGTH] = 1017 { STATE_INTERNAL, STATE_PT_SCALE }; 1018 static const gl_state_index bias_state[STATE_LENGTH] = 1019 { STATE_INTERNAL, STATE_PT_BIAS }; 1020 1021 if (!variant) 1022 return NULL; 1023 1024 if (stfp->tgsi.type == PIPE_SHADER_IR_NIR) { 1025 tgsi.type = PIPE_SHADER_IR_NIR; 1026 tgsi.ir.nir = nir_shader_clone(NULL, stfp->tgsi.ir.nir); 1027 1028 if (key->clamp_color) 1029 NIR_PASS_V(tgsi.ir.nir, nir_lower_clamp_color_outputs); 1030 1031 if (key->persample_shading) { 1032 nir_shader *shader = tgsi.ir.nir; 1033 nir_foreach_variable(var, &shader->inputs) 1034 var->data.sample = true; 1035 } 1036 1037 assert(!(key->bitmap && key->drawpixels)); 1038 1039 /* glBitmap */ 1040 if (key->bitmap) { 1041 nir_lower_bitmap_options options = {0}; 1042 1043 variant->bitmap_sampler = ffs(~stfp->Base.SamplersUsed) - 1; 1044 options.sampler = variant->bitmap_sampler; 1045 options.swizzle_xxxx = (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM); 1046 1047 NIR_PASS_V(tgsi.ir.nir, nir_lower_bitmap, &options); 1048 } 1049 1050 /* glDrawPixels (color only) */ 1051 if (key->drawpixels) { 1052 nir_lower_drawpixels_options options = {{0}}; 1053 unsigned samplers_used = stfp->Base.SamplersUsed; 1054 1055 /* Find the first unused slot. */ 1056 variant->drawpix_sampler = ffs(~samplers_used) - 1; 1057 options.drawpix_sampler = variant->drawpix_sampler; 1058 samplers_used |= (1 << variant->drawpix_sampler); 1059 1060 options.pixel_maps = key->pixelMaps; 1061 if (key->pixelMaps) { 1062 variant->pixelmap_sampler = ffs(~samplers_used) - 1; 1063 options.pixelmap_sampler = variant->pixelmap_sampler; 1064 } 1065 1066 options.scale_and_bias = key->scaleAndBias; 1067 if (key->scaleAndBias) { 1068 _mesa_add_state_reference(params, scale_state); 1069 memcpy(options.scale_state_tokens, scale_state, 1070 sizeof(options.scale_state_tokens)); 1071 _mesa_add_state_reference(params, bias_state); 1072 memcpy(options.bias_state_tokens, bias_state, 1073 sizeof(options.bias_state_tokens)); 1074 } 1075 1076 _mesa_add_state_reference(params, texcoord_state); 1077 memcpy(options.texcoord_state_tokens, texcoord_state, 1078 sizeof(options.texcoord_state_tokens)); 1079 1080 NIR_PASS_V(tgsi.ir.nir, nir_lower_drawpixels, &options); 1081 } 1082 1083 if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) { 1084 nir_lower_tex_options options = {0}; 1085 options.lower_y_uv_external = key->external.lower_nv12; 1086 options.lower_y_u_v_external = key->external.lower_iyuv; 1087 NIR_PASS_V(tgsi.ir.nir, nir_lower_tex, &options); 1088 } 1089 1090 st_finalize_nir(st, &stfp->Base, stfp->shader_program, tgsi.ir.nir); 1091 1092 if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) { 1093 /* This pass needs to happen *after* nir_lower_sampler */ 1094 NIR_PASS_V(tgsi.ir.nir, st_nir_lower_tex_src_plane, 1095 ~stfp->Base.SamplersUsed, 1096 key->external.lower_nv12, 1097 key->external.lower_iyuv); 1098 } 1099 1100 variant->driver_shader = pipe->create_fs_state(pipe, &tgsi); 1101 variant->key = *key; 1102 1103 return variant; 1104 } 1105 1106 tgsi.tokens = stfp->tgsi.tokens; 1107 1108 assert(!(key->bitmap && key->drawpixels)); 1109 1110 /* Fix texture targets and add fog for ATI_fs */ 1111 if (stfp->ati_fs) { 1112 const struct tgsi_token *tokens = st_fixup_atifs(tgsi.tokens, key); 1113 1114 if (tokens) 1115 tgsi.tokens = tokens; 1116 else 1117 fprintf(stderr, "mesa: cannot post-process ATI_fs\n"); 1118 } 1119 1120 /* Emulate features. */ 1121 if (key->clamp_color || key->persample_shading) { 1122 const struct tgsi_token *tokens; 1123 unsigned flags = 1124 (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) | 1125 (key->persample_shading ? TGSI_EMU_FORCE_PERSAMPLE_INTERP : 0); 1126 1127 tokens = tgsi_emulate(tgsi.tokens, flags); 1128 1129 if (tokens) { 1130 if (tgsi.tokens != stfp->tgsi.tokens) 1131 tgsi_free_tokens(tgsi.tokens); 1132 tgsi.tokens = tokens; 1133 } else 1134 fprintf(stderr, "mesa: cannot emulate deprecated features\n"); 1135 } 1136 1137 /* glBitmap */ 1138 if (key->bitmap) { 1139 const struct tgsi_token *tokens; 1140 1141 variant->bitmap_sampler = ffs(~stfp->Base.SamplersUsed) - 1; 1142 1143 tokens = st_get_bitmap_shader(tgsi.tokens, 1144 st->internal_target, 1145 variant->bitmap_sampler, 1146 st->needs_texcoord_semantic, 1147 st->bitmap.tex_format == 1148 PIPE_FORMAT_L8_UNORM); 1149 1150 if (tokens) { 1151 if (tgsi.tokens != stfp->tgsi.tokens) 1152 tgsi_free_tokens(tgsi.tokens); 1153 tgsi.tokens = tokens; 1154 } else 1155 fprintf(stderr, "mesa: cannot create a shader for glBitmap\n"); 1156 } 1157 1158 /* glDrawPixels (color only) */ 1159 if (key->drawpixels) { 1160 const struct tgsi_token *tokens; 1161 unsigned scale_const = 0, bias_const = 0, texcoord_const = 0; 1162 1163 /* Find the first unused slot. */ 1164 variant->drawpix_sampler = ffs(~stfp->Base.SamplersUsed) - 1; 1165 1166 if (key->pixelMaps) { 1167 unsigned samplers_used = stfp->Base.SamplersUsed | 1168 (1 << variant->drawpix_sampler); 1169 1170 variant->pixelmap_sampler = ffs(~samplers_used) - 1; 1171 } 1172 1173 if (key->scaleAndBias) { 1174 scale_const = _mesa_add_state_reference(params, scale_state); 1175 bias_const = _mesa_add_state_reference(params, bias_state); 1176 } 1177 1178 texcoord_const = _mesa_add_state_reference(params, texcoord_state); 1179 1180 tokens = st_get_drawpix_shader(tgsi.tokens, 1181 st->needs_texcoord_semantic, 1182 key->scaleAndBias, scale_const, 1183 bias_const, key->pixelMaps, 1184 variant->drawpix_sampler, 1185 variant->pixelmap_sampler, 1186 texcoord_const, st->internal_target); 1187 1188 if (tokens) { 1189 if (tgsi.tokens != stfp->tgsi.tokens) 1190 tgsi_free_tokens(tgsi.tokens); 1191 tgsi.tokens = tokens; 1192 } else 1193 fprintf(stderr, "mesa: cannot create a shader for glDrawPixels\n"); 1194 } 1195 1196 if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) { 1197 const struct tgsi_token *tokens; 1198 1199 /* samplers inserted would conflict, but this should be unpossible: */ 1200 assert(!(key->bitmap || key->drawpixels)); 1201 1202 tokens = st_tgsi_lower_yuv(tgsi.tokens, 1203 ~stfp->Base.SamplersUsed, 1204 key->external.lower_nv12, 1205 key->external.lower_iyuv); 1206 if (tokens) { 1207 if (tgsi.tokens != stfp->tgsi.tokens) 1208 tgsi_free_tokens(tgsi.tokens); 1209 tgsi.tokens = tokens; 1210 } else { 1211 fprintf(stderr, "mesa: cannot create a shader for samplerExternalOES\n"); 1212 } 1213 } 1214 1215 if (ST_DEBUG & DEBUG_TGSI) { 1216 tgsi_dump(tgsi.tokens, 0); 1217 debug_printf("\n"); 1218 } 1219 1220 /* fill in variant */ 1221 variant->driver_shader = pipe->create_fs_state(pipe, &tgsi); 1222 variant->key = *key; 1223 1224 if (tgsi.tokens != stfp->tgsi.tokens) 1225 tgsi_free_tokens(tgsi.tokens); 1226 return variant; 1227 } 1228 1229 /** 1230 * Translate fragment program if needed. 1231 */ 1232 struct st_fp_variant * 1233 st_get_fp_variant(struct st_context *st, 1234 struct st_fragment_program *stfp, 1235 const struct st_fp_variant_key *key) 1236 { 1237 struct st_fp_variant *fpv; 1238 1239 /* Search for existing variant */ 1240 for (fpv = stfp->variants; fpv; fpv = fpv->next) { 1241 if (memcmp(&fpv->key, key, sizeof(*key)) == 0) { 1242 break; 1243 } 1244 } 1245 1246 if (!fpv) { 1247 /* create new */ 1248 fpv = st_create_fp_variant(st, stfp, key); 1249 if (fpv) { 1250 if (key->bitmap || key->drawpixels) { 1251 /* Regular variants should always come before the 1252 * bitmap & drawpixels variants, (unless there 1253 * are no regular variants) so that 1254 * st_update_fp can take a fast path when 1255 * shader_has_one_variant is set. 1256 */ 1257 if (!stfp->variants) { 1258 stfp->variants = fpv; 1259 } else { 1260 /* insert into list after the first one */ 1261 fpv->next = stfp->variants->next; 1262 stfp->variants->next = fpv; 1263 } 1264 } else { 1265 /* insert into list */ 1266 fpv->next = stfp->variants; 1267 stfp->variants = fpv; 1268 } 1269 } 1270 } 1271 1272 return fpv; 1273 } 1274 1275 1276 /** 1277 * Translate a program. This is common code for geometry and tessellation 1278 * shaders. 1279 */ 1280 static void 1281 st_translate_program_common(struct st_context *st, 1282 struct gl_program *prog, 1283 struct glsl_to_tgsi_visitor *glsl_to_tgsi, 1284 struct ureg_program *ureg, 1285 unsigned tgsi_processor, 1286 struct pipe_shader_state *out_state) 1287 { 1288 ubyte inputSlotToAttr[VARYING_SLOT_TESS_MAX]; 1289 ubyte inputMapping[VARYING_SLOT_TESS_MAX]; 1290 ubyte outputMapping[VARYING_SLOT_TESS_MAX]; 1291 GLuint attr; 1292 1293 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS]; 1294 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS]; 1295 uint num_inputs = 0; 1296 1297 ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS]; 1298 ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS]; 1299 uint num_outputs = 0; 1300 1301 GLint i; 1302 1303 memset(inputSlotToAttr, 0, sizeof(inputSlotToAttr)); 1304 memset(inputMapping, 0, sizeof(inputMapping)); 1305 memset(outputMapping, 0, sizeof(outputMapping)); 1306 memset(out_state, 0, sizeof(*out_state)); 1307 1308 if (prog->info.clip_distance_array_size) 1309 ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED, 1310 prog->info.clip_distance_array_size); 1311 if (prog->info.cull_distance_array_size) 1312 ureg_property(ureg, TGSI_PROPERTY_NUM_CULLDIST_ENABLED, 1313 prog->info.cull_distance_array_size); 1314 1315 /* 1316 * Convert Mesa program inputs to TGSI input register semantics. 1317 */ 1318 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) { 1319 if ((prog->info.inputs_read & BITFIELD64_BIT(attr)) == 0) 1320 continue; 1321 1322 unsigned slot = num_inputs++; 1323 1324 inputMapping[attr] = slot; 1325 inputSlotToAttr[slot] = attr; 1326 1327 unsigned semantic_name, semantic_index; 1328 tgsi_get_gl_varying_semantic(attr, st->needs_texcoord_semantic, 1329 &semantic_name, &semantic_index); 1330 input_semantic_name[slot] = semantic_name; 1331 input_semantic_index[slot] = semantic_index; 1332 } 1333 1334 /* Also add patch inputs. */ 1335 for (attr = 0; attr < 32; attr++) { 1336 if (prog->info.patch_inputs_read & (1u << attr)) { 1337 GLuint slot = num_inputs++; 1338 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr; 1339 1340 inputMapping[patch_attr] = slot; 1341 inputSlotToAttr[slot] = patch_attr; 1342 input_semantic_name[slot] = TGSI_SEMANTIC_PATCH; 1343 input_semantic_index[slot] = attr; 1344 } 1345 } 1346 1347 /* initialize output semantics to defaults */ 1348 for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) { 1349 output_semantic_name[i] = TGSI_SEMANTIC_GENERIC; 1350 output_semantic_index[i] = 0; 1351 } 1352 1353 /* 1354 * Determine number of outputs, the (default) output register 1355 * mapping and the semantic information for each output. 1356 */ 1357 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) { 1358 if (prog->info.outputs_written & BITFIELD64_BIT(attr)) { 1359 GLuint slot = num_outputs++; 1360 1361 outputMapping[attr] = slot; 1362 1363 unsigned semantic_name, semantic_index; 1364 tgsi_get_gl_varying_semantic(attr, st->needs_texcoord_semantic, 1365 &semantic_name, &semantic_index); 1366 output_semantic_name[slot] = semantic_name; 1367 output_semantic_index[slot] = semantic_index; 1368 } 1369 } 1370 1371 /* Also add patch outputs. */ 1372 for (attr = 0; attr < 32; attr++) { 1373 if (prog->info.patch_outputs_written & (1u << attr)) { 1374 GLuint slot = num_outputs++; 1375 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr; 1376 1377 outputMapping[patch_attr] = slot; 1378 output_semantic_name[slot] = TGSI_SEMANTIC_PATCH; 1379 output_semantic_index[slot] = attr; 1380 } 1381 } 1382 1383 st_translate_program(st->ctx, 1384 tgsi_processor, 1385 ureg, 1386 glsl_to_tgsi, 1387 prog, 1388 /* inputs */ 1389 num_inputs, 1390 inputMapping, 1391 inputSlotToAttr, 1392 input_semantic_name, 1393 input_semantic_index, 1394 NULL, 1395 /* outputs */ 1396 num_outputs, 1397 outputMapping, 1398 output_semantic_name, 1399 output_semantic_index); 1400 1401 if (tgsi_processor == PIPE_SHADER_COMPUTE) { 1402 struct st_compute_program *stcp = (struct st_compute_program *) prog; 1403 out_state->tokens = ureg_get_tokens(ureg, &stcp->num_tgsi_tokens); 1404 stcp->tgsi.prog = out_state->tokens; 1405 } else { 1406 struct st_common_program *stcp = (struct st_common_program *) prog; 1407 out_state->tokens = ureg_get_tokens(ureg, &stcp->num_tgsi_tokens); 1408 } 1409 ureg_destroy(ureg); 1410 1411 st_translate_stream_output_info(glsl_to_tgsi, 1412 outputMapping, 1413 &out_state->stream_output); 1414 1415 st_store_tgsi_in_disk_cache(st, prog); 1416 1417 if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) { 1418 _mesa_print_program(prog); 1419 debug_printf("\n"); 1420 } 1421 1422 if (ST_DEBUG & DEBUG_TGSI) { 1423 tgsi_dump(out_state->tokens, 0); 1424 debug_printf("\n"); 1425 } 1426 } 1427 1428 /** 1429 * Update stream-output info for GS/TCS/TES. Normally this is done in 1430 * st_translate_program_common() but that is not called for glsl_to_nir 1431 * case. 1432 */ 1433 static void 1434 st_translate_program_stream_output(struct gl_program *prog, 1435 struct pipe_stream_output_info *stream_output) 1436 { 1437 if (!prog->sh.LinkedTransformFeedback) 1438 return; 1439 1440 ubyte outputMapping[VARYING_SLOT_TESS_MAX]; 1441 GLuint attr; 1442 uint num_outputs = 0; 1443 1444 memset(outputMapping, 0, sizeof(outputMapping)); 1445 1446 /* 1447 * Determine number of outputs, the (default) output register 1448 * mapping and the semantic information for each output. 1449 */ 1450 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) { 1451 if (prog->info.outputs_written & BITFIELD64_BIT(attr)) { 1452 GLuint slot = num_outputs++; 1453 1454 outputMapping[attr] = slot; 1455 } 1456 } 1457 1458 st_translate_stream_output_info2(prog->sh.LinkedTransformFeedback, 1459 outputMapping, 1460 stream_output); 1461 } 1462 1463 /** 1464 * Translate a geometry program to create a new variant. 1465 */ 1466 bool 1467 st_translate_geometry_program(struct st_context *st, 1468 struct st_common_program *stgp) 1469 { 1470 struct ureg_program *ureg; 1471 1472 /* We have already compiled to NIR so just return */ 1473 if (stgp->shader_program) { 1474 st_translate_program_stream_output(&stgp->Base, &stgp->tgsi.stream_output); 1475 return true; 1476 } 1477 1478 ureg = ureg_create_with_screen(PIPE_SHADER_GEOMETRY, st->pipe->screen); 1479 if (ureg == NULL) 1480 return false; 1481 1482 ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, 1483 stgp->Base.info.gs.input_primitive); 1484 ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, 1485 stgp->Base.info.gs.output_primitive); 1486 ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES, 1487 stgp->Base.info.gs.vertices_out); 1488 ureg_property(ureg, TGSI_PROPERTY_GS_INVOCATIONS, 1489 stgp->Base.info.gs.invocations); 1490 1491 st_translate_program_common(st, &stgp->Base, stgp->glsl_to_tgsi, ureg, 1492 PIPE_SHADER_GEOMETRY, &stgp->tgsi); 1493 1494 free_glsl_to_tgsi_visitor(stgp->glsl_to_tgsi); 1495 stgp->glsl_to_tgsi = NULL; 1496 return true; 1497 } 1498 1499 1500 /** 1501 * Get/create a basic program variant. 1502 */ 1503 struct st_basic_variant * 1504 st_get_basic_variant(struct st_context *st, 1505 unsigned pipe_shader, 1506 struct st_common_program *prog) 1507 { 1508 struct pipe_context *pipe = st->pipe; 1509 struct st_basic_variant *v; 1510 struct st_basic_variant_key key; 1511 struct pipe_shader_state tgsi = {0}; 1512 memset(&key, 0, sizeof(key)); 1513 key.st = st->has_shareable_shaders ? NULL : st; 1514 1515 /* Search for existing variant */ 1516 for (v = prog->variants; v; v = v->next) { 1517 if (memcmp(&v->key, &key, sizeof(key)) == 0) { 1518 break; 1519 } 1520 } 1521 1522 if (!v) { 1523 /* create new */ 1524 v = CALLOC_STRUCT(st_basic_variant); 1525 if (v) { 1526 1527 if (prog->tgsi.type == PIPE_SHADER_IR_NIR) { 1528 tgsi.type = PIPE_SHADER_IR_NIR; 1529 tgsi.ir.nir = nir_shader_clone(NULL, prog->tgsi.ir.nir); 1530 st_finalize_nir(st, &prog->Base, prog->shader_program, 1531 tgsi.ir.nir); 1532 tgsi.stream_output = prog->tgsi.stream_output; 1533 } else 1534 tgsi = prog->tgsi; 1535 /* fill in new variant */ 1536 switch (pipe_shader) { 1537 case PIPE_SHADER_TESS_CTRL: 1538 v->driver_shader = pipe->create_tcs_state(pipe, &tgsi); 1539 break; 1540 case PIPE_SHADER_TESS_EVAL: 1541 v->driver_shader = pipe->create_tes_state(pipe, &tgsi); 1542 break; 1543 case PIPE_SHADER_GEOMETRY: 1544 v->driver_shader = pipe->create_gs_state(pipe, &tgsi); 1545 break; 1546 default: 1547 assert(!"unhandled shader type"); 1548 free(v); 1549 return NULL; 1550 } 1551 1552 v->key = key; 1553 1554 /* insert into list */ 1555 v->next = prog->variants; 1556 prog->variants = v; 1557 } 1558 } 1559 1560 return v; 1561 } 1562 1563 1564 /** 1565 * Translate a tessellation control program to create a new variant. 1566 */ 1567 bool 1568 st_translate_tessctrl_program(struct st_context *st, 1569 struct st_common_program *sttcp) 1570 { 1571 struct ureg_program *ureg; 1572 1573 /* We have already compiled to NIR so just return */ 1574 if (sttcp->shader_program) 1575 return true; 1576 1577 ureg = ureg_create_with_screen(PIPE_SHADER_TESS_CTRL, st->pipe->screen); 1578 if (ureg == NULL) 1579 return false; 1580 1581 ureg_property(ureg, TGSI_PROPERTY_TCS_VERTICES_OUT, 1582 sttcp->Base.info.tess.tcs_vertices_out); 1583 1584 st_translate_program_common(st, &sttcp->Base, sttcp->glsl_to_tgsi, ureg, 1585 PIPE_SHADER_TESS_CTRL, &sttcp->tgsi); 1586 1587 free_glsl_to_tgsi_visitor(sttcp->glsl_to_tgsi); 1588 sttcp->glsl_to_tgsi = NULL; 1589 return true; 1590 } 1591 1592 1593 /** 1594 * Translate a tessellation evaluation program to create a new variant. 1595 */ 1596 bool 1597 st_translate_tesseval_program(struct st_context *st, 1598 struct st_common_program *sttep) 1599 { 1600 struct ureg_program *ureg; 1601 1602 /* We have already compiled to NIR so just return */ 1603 if (sttep->shader_program) { 1604 st_translate_program_stream_output(&sttep->Base, &sttep->tgsi.stream_output); 1605 return true; 1606 } 1607 1608 ureg = ureg_create_with_screen(PIPE_SHADER_TESS_EVAL, st->pipe->screen); 1609 if (ureg == NULL) 1610 return false; 1611 1612 if (sttep->Base.info.tess.primitive_mode == GL_ISOLINES) 1613 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, GL_LINES); 1614 else 1615 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, 1616 sttep->Base.info.tess.primitive_mode); 1617 1618 STATIC_ASSERT((TESS_SPACING_EQUAL + 1) % 3 == PIPE_TESS_SPACING_EQUAL); 1619 STATIC_ASSERT((TESS_SPACING_FRACTIONAL_ODD + 1) % 3 == 1620 PIPE_TESS_SPACING_FRACTIONAL_ODD); 1621 STATIC_ASSERT((TESS_SPACING_FRACTIONAL_EVEN + 1) % 3 == 1622 PIPE_TESS_SPACING_FRACTIONAL_EVEN); 1623 1624 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING, 1625 (sttep->Base.info.tess.spacing + 1) % 3); 1626 1627 ureg_property(ureg, TGSI_PROPERTY_TES_VERTEX_ORDER_CW, 1628 !sttep->Base.info.tess.ccw); 1629 ureg_property(ureg, TGSI_PROPERTY_TES_POINT_MODE, 1630 sttep->Base.info.tess.point_mode); 1631 1632 st_translate_program_common(st, &sttep->Base, sttep->glsl_to_tgsi, 1633 ureg, PIPE_SHADER_TESS_EVAL, &sttep->tgsi); 1634 1635 free_glsl_to_tgsi_visitor(sttep->glsl_to_tgsi); 1636 sttep->glsl_to_tgsi = NULL; 1637 return true; 1638 } 1639 1640 1641 /** 1642 * Translate a compute program to create a new variant. 1643 */ 1644 bool 1645 st_translate_compute_program(struct st_context *st, 1646 struct st_compute_program *stcp) 1647 { 1648 struct ureg_program *ureg; 1649 struct pipe_shader_state prog; 1650 1651 if (stcp->shader_program) { 1652 /* no compute variants: */ 1653 st_finalize_nir(st, &stcp->Base, stcp->shader_program, 1654 (struct nir_shader *) stcp->tgsi.prog); 1655 1656 return true; 1657 } 1658 1659 ureg = ureg_create_with_screen(PIPE_SHADER_COMPUTE, st->pipe->screen); 1660 if (ureg == NULL) 1661 return false; 1662 1663 st_translate_program_common(st, &stcp->Base, stcp->glsl_to_tgsi, ureg, 1664 PIPE_SHADER_COMPUTE, &prog); 1665 1666 stcp->tgsi.ir_type = PIPE_SHADER_IR_TGSI; 1667 stcp->tgsi.req_local_mem = stcp->Base.info.cs.shared_size; 1668 stcp->tgsi.req_private_mem = 0; 1669 stcp->tgsi.req_input_mem = 0; 1670 1671 free_glsl_to_tgsi_visitor(stcp->glsl_to_tgsi); 1672 stcp->glsl_to_tgsi = NULL; 1673 return true; 1674 } 1675 1676 1677 /** 1678 * Get/create compute program variant. 1679 */ 1680 struct st_basic_variant * 1681 st_get_cp_variant(struct st_context *st, 1682 struct pipe_compute_state *tgsi, 1683 struct st_basic_variant **variants) 1684 { 1685 struct pipe_context *pipe = st->pipe; 1686 struct st_basic_variant *v; 1687 struct st_basic_variant_key key; 1688 1689 memset(&key, 0, sizeof(key)); 1690 key.st = st->has_shareable_shaders ? NULL : st; 1691 1692 /* Search for existing variant */ 1693 for (v = *variants; v; v = v->next) { 1694 if (memcmp(&v->key, &key, sizeof(key)) == 0) { 1695 break; 1696 } 1697 } 1698 1699 if (!v) { 1700 /* create new */ 1701 v = CALLOC_STRUCT(st_basic_variant); 1702 if (v) { 1703 /* fill in new variant */ 1704 struct pipe_compute_state cs = *tgsi; 1705 if (tgsi->ir_type == PIPE_SHADER_IR_NIR) 1706 cs.prog = nir_shader_clone(NULL, tgsi->prog); 1707 v->driver_shader = pipe->create_compute_state(pipe, &cs); 1708 v->key = key; 1709 1710 /* insert into list */ 1711 v->next = *variants; 1712 *variants = v; 1713 } 1714 } 1715 1716 return v; 1717 } 1718 1719 1720 /** 1721 * Vert/Geom/Frag programs have per-context variants. Free all the 1722 * variants attached to the given program which match the given context. 1723 */ 1724 static void 1725 destroy_program_variants(struct st_context *st, struct gl_program *target) 1726 { 1727 if (!target || target == &_mesa_DummyProgram) 1728 return; 1729 1730 switch (target->Target) { 1731 case GL_VERTEX_PROGRAM_ARB: 1732 { 1733 struct st_vertex_program *stvp = (struct st_vertex_program *) target; 1734 struct st_vp_variant *vpv, **prevPtr = &stvp->variants; 1735 1736 for (vpv = stvp->variants; vpv; ) { 1737 struct st_vp_variant *next = vpv->next; 1738 if (vpv->key.st == st) { 1739 /* unlink from list */ 1740 *prevPtr = next; 1741 /* destroy this variant */ 1742 delete_vp_variant(st, vpv); 1743 } 1744 else { 1745 prevPtr = &vpv->next; 1746 } 1747 vpv = next; 1748 } 1749 } 1750 break; 1751 case GL_FRAGMENT_PROGRAM_ARB: 1752 { 1753 struct st_fragment_program *stfp = 1754 (struct st_fragment_program *) target; 1755 struct st_fp_variant *fpv, **prevPtr = &stfp->variants; 1756 1757 for (fpv = stfp->variants; fpv; ) { 1758 struct st_fp_variant *next = fpv->next; 1759 if (fpv->key.st == st) { 1760 /* unlink from list */ 1761 *prevPtr = next; 1762 /* destroy this variant */ 1763 delete_fp_variant(st, fpv); 1764 } 1765 else { 1766 prevPtr = &fpv->next; 1767 } 1768 fpv = next; 1769 } 1770 } 1771 break; 1772 case GL_GEOMETRY_PROGRAM_NV: 1773 case GL_TESS_CONTROL_PROGRAM_NV: 1774 case GL_TESS_EVALUATION_PROGRAM_NV: 1775 case GL_COMPUTE_PROGRAM_NV: 1776 { 1777 struct st_common_program *p = st_common_program(target); 1778 struct st_compute_program *cp = (struct st_compute_program*)target; 1779 struct st_basic_variant **variants = 1780 target->Target == GL_COMPUTE_PROGRAM_NV ? &cp->variants : 1781 &p->variants; 1782 struct st_basic_variant *v, **prevPtr = variants; 1783 1784 for (v = *variants; v; ) { 1785 struct st_basic_variant *next = v->next; 1786 if (v->key.st == st) { 1787 /* unlink from list */ 1788 *prevPtr = next; 1789 /* destroy this variant */ 1790 delete_basic_variant(st, v, target->Target); 1791 } 1792 else { 1793 prevPtr = &v->next; 1794 } 1795 v = next; 1796 } 1797 } 1798 break; 1799 default: 1800 _mesa_problem(NULL, "Unexpected program target 0x%x in " 1801 "destroy_program_variants_cb()", target->Target); 1802 } 1803 } 1804 1805 1806 /** 1807 * Callback for _mesa_HashWalk. Free all the shader's program variants 1808 * which match the given context. 1809 */ 1810 static void 1811 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData) 1812 { 1813 struct st_context *st = (struct st_context *) userData; 1814 struct gl_shader *shader = (struct gl_shader *) data; 1815 1816 switch (shader->Type) { 1817 case GL_SHADER_PROGRAM_MESA: 1818 { 1819 struct gl_shader_program *shProg = (struct gl_shader_program *) data; 1820 GLuint i; 1821 1822 for (i = 0; i < ARRAY_SIZE(shProg->_LinkedShaders); i++) { 1823 if (shProg->_LinkedShaders[i]) 1824 destroy_program_variants(st, shProg->_LinkedShaders[i]->Program); 1825 } 1826 } 1827 break; 1828 case GL_VERTEX_SHADER: 1829 case GL_FRAGMENT_SHADER: 1830 case GL_GEOMETRY_SHADER: 1831 case GL_TESS_CONTROL_SHADER: 1832 case GL_TESS_EVALUATION_SHADER: 1833 case GL_COMPUTE_SHADER: 1834 break; 1835 default: 1836 assert(0); 1837 } 1838 } 1839 1840 1841 /** 1842 * Callback for _mesa_HashWalk. Free all the program variants which match 1843 * the given context. 1844 */ 1845 static void 1846 destroy_program_variants_cb(GLuint key, void *data, void *userData) 1847 { 1848 struct st_context *st = (struct st_context *) userData; 1849 struct gl_program *program = (struct gl_program *) data; 1850 destroy_program_variants(st, program); 1851 } 1852 1853 1854 /** 1855 * Walk over all shaders and programs to delete any variants which 1856 * belong to the given context. 1857 * This is called during context tear-down. 1858 */ 1859 void 1860 st_destroy_program_variants(struct st_context *st) 1861 { 1862 /* If shaders can be shared with other contexts, the last context will 1863 * call DeleteProgram on all shaders, releasing everything. 1864 */ 1865 if (st->has_shareable_shaders) 1866 return; 1867 1868 /* ARB vert/frag program */ 1869 _mesa_HashWalk(st->ctx->Shared->Programs, 1870 destroy_program_variants_cb, st); 1871 1872 /* GLSL vert/frag/geom shaders */ 1873 _mesa_HashWalk(st->ctx->Shared->ShaderObjects, 1874 destroy_shader_program_variants_cb, st); 1875 } 1876 1877 1878 /** 1879 * For debugging, print/dump the current vertex program. 1880 */ 1881 void 1882 st_print_current_vertex_program(void) 1883 { 1884 GET_CURRENT_CONTEXT(ctx); 1885 1886 if (ctx->VertexProgram._Current) { 1887 struct st_vertex_program *stvp = 1888 (struct st_vertex_program *) ctx->VertexProgram._Current; 1889 struct st_vp_variant *stv; 1890 1891 debug_printf("Vertex program %u\n", stvp->Base.Id); 1892 1893 for (stv = stvp->variants; stv; stv = stv->next) { 1894 debug_printf("variant %p\n", stv); 1895 tgsi_dump(stv->tgsi.tokens, 0); 1896 } 1897 } 1898 } 1899 1900 1901 /** 1902 * Compile one shader variant. 1903 */ 1904 void 1905 st_precompile_shader_variant(struct st_context *st, 1906 struct gl_program *prog) 1907 { 1908 switch (prog->Target) { 1909 case GL_VERTEX_PROGRAM_ARB: { 1910 struct st_vertex_program *p = (struct st_vertex_program *)prog; 1911 struct st_vp_variant_key key; 1912 1913 memset(&key, 0, sizeof(key)); 1914 key.st = st->has_shareable_shaders ? NULL : st; 1915 st_get_vp_variant(st, p, &key); 1916 break; 1917 } 1918 1919 case GL_TESS_CONTROL_PROGRAM_NV: { 1920 struct st_common_program *p = st_common_program(prog); 1921 st_get_basic_variant(st, PIPE_SHADER_TESS_CTRL, p); 1922 break; 1923 } 1924 1925 case GL_TESS_EVALUATION_PROGRAM_NV: { 1926 struct st_common_program *p = st_common_program(prog); 1927 st_get_basic_variant(st, PIPE_SHADER_TESS_EVAL, p); 1928 break; 1929 } 1930 1931 case GL_GEOMETRY_PROGRAM_NV: { 1932 struct st_common_program *p = st_common_program(prog); 1933 st_get_basic_variant(st, PIPE_SHADER_GEOMETRY, p); 1934 break; 1935 } 1936 1937 case GL_FRAGMENT_PROGRAM_ARB: { 1938 struct st_fragment_program *p = (struct st_fragment_program *)prog; 1939 struct st_fp_variant_key key; 1940 1941 memset(&key, 0, sizeof(key)); 1942 key.st = st->has_shareable_shaders ? NULL : st; 1943 st_get_fp_variant(st, p, &key); 1944 break; 1945 } 1946 1947 case GL_COMPUTE_PROGRAM_NV: { 1948 struct st_compute_program *p = (struct st_compute_program *)prog; 1949 st_get_cp_variant(st, &p->tgsi, &p->variants); 1950 break; 1951 } 1952 1953 default: 1954 assert(0); 1955 } 1956 } 1957
