1 /************************************************************************** 2 * 3 * Copyright 2009-2010 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, INC 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 29 #include "pipe/p_screen.h" 30 #include "pipe/p_context.h" 31 #include "pipe/p_state.h" 32 #include "tgsi/tgsi_ureg.h" 33 #include "tgsi/tgsi_build.h" 34 #include "tgsi/tgsi_info.h" 35 #include "tgsi/tgsi_dump.h" 36 #include "tgsi/tgsi_sanity.h" 37 #include "util/u_debug.h" 38 #include "util/u_inlines.h" 39 #include "util/u_memory.h" 40 #include "util/u_math.h" 41 #include "util/u_bitmask.h" 42 43 union tgsi_any_token { 44 struct tgsi_header header; 45 struct tgsi_processor processor; 46 struct tgsi_token token; 47 struct tgsi_property prop; 48 struct tgsi_property_data prop_data; 49 struct tgsi_declaration decl; 50 struct tgsi_declaration_range decl_range; 51 struct tgsi_declaration_dimension decl_dim; 52 struct tgsi_declaration_interp decl_interp; 53 struct tgsi_declaration_image decl_image; 54 struct tgsi_declaration_semantic decl_semantic; 55 struct tgsi_declaration_sampler_view decl_sampler_view; 56 struct tgsi_declaration_array array; 57 struct tgsi_immediate imm; 58 union tgsi_immediate_data imm_data; 59 struct tgsi_instruction insn; 60 struct tgsi_instruction_predicate insn_predicate; 61 struct tgsi_instruction_label insn_label; 62 struct tgsi_instruction_texture insn_texture; 63 struct tgsi_instruction_memory insn_memory; 64 struct tgsi_texture_offset insn_texture_offset; 65 struct tgsi_src_register src; 66 struct tgsi_ind_register ind; 67 struct tgsi_dimension dim; 68 struct tgsi_dst_register dst; 69 unsigned value; 70 }; 71 72 73 struct ureg_tokens { 74 union tgsi_any_token *tokens; 75 unsigned size; 76 unsigned order; 77 unsigned count; 78 }; 79 80 #define UREG_MAX_INPUT (4 * PIPE_MAX_SHADER_INPUTS) 81 #define UREG_MAX_SYSTEM_VALUE PIPE_MAX_ATTRIBS 82 #define UREG_MAX_OUTPUT (4 * PIPE_MAX_SHADER_OUTPUTS) 83 #define UREG_MAX_CONSTANT_RANGE 32 84 #define UREG_MAX_IMMEDIATE 4096 85 #define UREG_MAX_ADDR 3 86 #define UREG_MAX_PRED 1 87 #define UREG_MAX_ARRAY_TEMPS 256 88 89 struct const_decl { 90 struct { 91 unsigned first; 92 unsigned last; 93 } constant_range[UREG_MAX_CONSTANT_RANGE]; 94 unsigned nr_constant_ranges; 95 }; 96 97 #define DOMAIN_DECL 0 98 #define DOMAIN_INSN 1 99 100 struct ureg_program 101 { 102 unsigned processor; 103 bool supports_any_inout_decl_range; 104 int next_shader_processor; 105 106 struct { 107 unsigned semantic_name; 108 unsigned semantic_index; 109 unsigned interp; 110 unsigned char cylindrical_wrap; 111 unsigned char usage_mask; 112 unsigned interp_location; 113 unsigned first; 114 unsigned last; 115 unsigned array_id; 116 } input[UREG_MAX_INPUT]; 117 unsigned nr_inputs, nr_input_regs; 118 119 unsigned vs_inputs[PIPE_MAX_ATTRIBS/32]; 120 121 struct { 122 unsigned semantic_name; 123 unsigned semantic_index; 124 } system_value[UREG_MAX_SYSTEM_VALUE]; 125 unsigned nr_system_values; 126 127 struct { 128 unsigned semantic_name; 129 unsigned semantic_index; 130 unsigned streams; 131 unsigned usage_mask; /* = TGSI_WRITEMASK_* */ 132 unsigned first; 133 unsigned last; 134 unsigned array_id; 135 } output[UREG_MAX_OUTPUT]; 136 unsigned nr_outputs, nr_output_regs; 137 138 struct { 139 union { 140 float f[4]; 141 unsigned u[4]; 142 int i[4]; 143 } value; 144 unsigned nr; 145 unsigned type; 146 } immediate[UREG_MAX_IMMEDIATE]; 147 unsigned nr_immediates; 148 149 struct ureg_src sampler[PIPE_MAX_SAMPLERS]; 150 unsigned nr_samplers; 151 152 struct { 153 unsigned index; 154 unsigned target; 155 unsigned return_type_x; 156 unsigned return_type_y; 157 unsigned return_type_z; 158 unsigned return_type_w; 159 } sampler_view[PIPE_MAX_SHADER_SAMPLER_VIEWS]; 160 unsigned nr_sampler_views; 161 162 struct { 163 unsigned index; 164 unsigned target; 165 unsigned format; 166 boolean wr; 167 boolean raw; 168 } image[PIPE_MAX_SHADER_IMAGES]; 169 unsigned nr_images; 170 171 struct { 172 unsigned index; 173 bool atomic; 174 } buffer[PIPE_MAX_SHADER_BUFFERS]; 175 unsigned nr_buffers; 176 177 struct util_bitmask *free_temps; 178 struct util_bitmask *local_temps; 179 struct util_bitmask *decl_temps; 180 unsigned nr_temps; 181 182 unsigned array_temps[UREG_MAX_ARRAY_TEMPS]; 183 unsigned nr_array_temps; 184 185 struct const_decl const_decls; 186 struct const_decl const_decls2D[PIPE_MAX_CONSTANT_BUFFERS]; 187 188 unsigned properties[TGSI_PROPERTY_COUNT]; 189 190 unsigned nr_addrs; 191 unsigned nr_preds; 192 unsigned nr_instructions; 193 194 struct ureg_tokens domain[2]; 195 196 bool use_memory[TGSI_MEMORY_TYPE_COUNT]; 197 }; 198 199 static union tgsi_any_token error_tokens[32]; 200 201 static void tokens_error( struct ureg_tokens *tokens ) 202 { 203 if (tokens->tokens && tokens->tokens != error_tokens) 204 FREE(tokens->tokens); 205 206 tokens->tokens = error_tokens; 207 tokens->size = ARRAY_SIZE(error_tokens); 208 tokens->count = 0; 209 } 210 211 212 static void tokens_expand( struct ureg_tokens *tokens, 213 unsigned count ) 214 { 215 unsigned old_size = tokens->size * sizeof(unsigned); 216 217 if (tokens->tokens == error_tokens) { 218 return; 219 } 220 221 while (tokens->count + count > tokens->size) { 222 tokens->size = (1 << ++tokens->order); 223 } 224 225 tokens->tokens = REALLOC(tokens->tokens, 226 old_size, 227 tokens->size * sizeof(unsigned)); 228 if (tokens->tokens == NULL) { 229 tokens_error(tokens); 230 } 231 } 232 233 static void set_bad( struct ureg_program *ureg ) 234 { 235 tokens_error(&ureg->domain[0]); 236 } 237 238 239 240 static union tgsi_any_token *get_tokens( struct ureg_program *ureg, 241 unsigned domain, 242 unsigned count ) 243 { 244 struct ureg_tokens *tokens = &ureg->domain[domain]; 245 union tgsi_any_token *result; 246 247 if (tokens->count + count > tokens->size) 248 tokens_expand(tokens, count); 249 250 result = &tokens->tokens[tokens->count]; 251 tokens->count += count; 252 return result; 253 } 254 255 256 static union tgsi_any_token *retrieve_token( struct ureg_program *ureg, 257 unsigned domain, 258 unsigned nr ) 259 { 260 if (ureg->domain[domain].tokens == error_tokens) 261 return &error_tokens[0]; 262 263 return &ureg->domain[domain].tokens[nr]; 264 } 265 266 void 267 ureg_property(struct ureg_program *ureg, unsigned name, unsigned value) 268 { 269 assert(name < ARRAY_SIZE(ureg->properties)); 270 ureg->properties[name] = value; 271 } 272 273 struct ureg_src 274 ureg_DECL_fs_input_cyl_centroid_layout(struct ureg_program *ureg, 275 unsigned semantic_name, 276 unsigned semantic_index, 277 unsigned interp_mode, 278 unsigned cylindrical_wrap, 279 unsigned interp_location, 280 unsigned index, 281 unsigned usage_mask, 282 unsigned array_id, 283 unsigned array_size) 284 { 285 unsigned i; 286 287 assert(usage_mask != 0); 288 assert(usage_mask <= TGSI_WRITEMASK_XYZW); 289 290 for (i = 0; i < ureg->nr_inputs; i++) { 291 if (ureg->input[i].semantic_name == semantic_name && 292 ureg->input[i].semantic_index == semantic_index) { 293 assert(ureg->input[i].interp == interp_mode); 294 assert(ureg->input[i].cylindrical_wrap == cylindrical_wrap); 295 assert(ureg->input[i].interp_location == interp_location); 296 if (ureg->input[i].array_id == array_id) { 297 ureg->input[i].usage_mask |= usage_mask; 298 goto out; 299 } 300 assert((ureg->input[i].usage_mask & usage_mask) == 0); 301 } 302 } 303 304 if (ureg->nr_inputs < UREG_MAX_INPUT) { 305 assert(array_size >= 1); 306 ureg->input[i].semantic_name = semantic_name; 307 ureg->input[i].semantic_index = semantic_index; 308 ureg->input[i].interp = interp_mode; 309 ureg->input[i].cylindrical_wrap = cylindrical_wrap; 310 ureg->input[i].interp_location = interp_location; 311 ureg->input[i].first = index; 312 ureg->input[i].last = index + array_size - 1; 313 ureg->input[i].array_id = array_id; 314 ureg->input[i].usage_mask = usage_mask; 315 ureg->nr_input_regs = MAX2(ureg->nr_input_regs, index + array_size); 316 ureg->nr_inputs++; 317 } else { 318 set_bad(ureg); 319 } 320 321 out: 322 return ureg_src_array_register(TGSI_FILE_INPUT, ureg->input[i].first, 323 array_id); 324 } 325 326 struct ureg_src 327 ureg_DECL_fs_input_cyl_centroid(struct ureg_program *ureg, 328 unsigned semantic_name, 329 unsigned semantic_index, 330 unsigned interp_mode, 331 unsigned cylindrical_wrap, 332 unsigned interp_location, 333 unsigned array_id, 334 unsigned array_size) 335 { 336 return ureg_DECL_fs_input_cyl_centroid_layout(ureg, 337 semantic_name, semantic_index, interp_mode, cylindrical_wrap, interp_location, 338 ureg->nr_input_regs, TGSI_WRITEMASK_XYZW, array_id, array_size); 339 } 340 341 342 struct ureg_src 343 ureg_DECL_vs_input( struct ureg_program *ureg, 344 unsigned index ) 345 { 346 assert(ureg->processor == PIPE_SHADER_VERTEX); 347 assert(index / 32 < ARRAY_SIZE(ureg->vs_inputs)); 348 349 ureg->vs_inputs[index/32] |= 1 << (index % 32); 350 return ureg_src_register( TGSI_FILE_INPUT, index ); 351 } 352 353 354 struct ureg_src 355 ureg_DECL_input_layout(struct ureg_program *ureg, 356 unsigned semantic_name, 357 unsigned semantic_index, 358 unsigned index, 359 unsigned usage_mask, 360 unsigned array_id, 361 unsigned array_size) 362 { 363 return ureg_DECL_fs_input_cyl_centroid_layout(ureg, 364 semantic_name, semantic_index, 0, 0, 0, 365 index, usage_mask, array_id, array_size); 366 } 367 368 369 struct ureg_src 370 ureg_DECL_input(struct ureg_program *ureg, 371 unsigned semantic_name, 372 unsigned semantic_index, 373 unsigned array_id, 374 unsigned array_size) 375 { 376 return ureg_DECL_fs_input_cyl_centroid(ureg, semantic_name, semantic_index, 377 0, 0, 0, array_id, array_size); 378 } 379 380 381 struct ureg_src 382 ureg_DECL_system_value(struct ureg_program *ureg, 383 unsigned semantic_name, 384 unsigned semantic_index) 385 { 386 unsigned i; 387 388 for (i = 0; i < ureg->nr_system_values; i++) { 389 if (ureg->system_value[i].semantic_name == semantic_name && 390 ureg->system_value[i].semantic_index == semantic_index) { 391 goto out; 392 } 393 } 394 395 if (ureg->nr_system_values < UREG_MAX_SYSTEM_VALUE) { 396 ureg->system_value[ureg->nr_system_values].semantic_name = semantic_name; 397 ureg->system_value[ureg->nr_system_values].semantic_index = semantic_index; 398 i = ureg->nr_system_values; 399 ureg->nr_system_values++; 400 } else { 401 set_bad(ureg); 402 } 403 404 out: 405 return ureg_src_register(TGSI_FILE_SYSTEM_VALUE, i); 406 } 407 408 409 struct ureg_dst 410 ureg_DECL_output_layout(struct ureg_program *ureg, 411 unsigned semantic_name, 412 unsigned semantic_index, 413 unsigned streams, 414 unsigned index, 415 unsigned usage_mask, 416 unsigned array_id, 417 unsigned array_size) 418 { 419 unsigned i; 420 421 assert(usage_mask != 0); 422 assert(!(streams & 0x03) || (usage_mask & 1)); 423 assert(!(streams & 0x0c) || (usage_mask & 2)); 424 assert(!(streams & 0x30) || (usage_mask & 4)); 425 assert(!(streams & 0xc0) || (usage_mask & 8)); 426 427 for (i = 0; i < ureg->nr_outputs; i++) { 428 if (ureg->output[i].semantic_name == semantic_name && 429 ureg->output[i].semantic_index == semantic_index) { 430 if (ureg->output[i].array_id == array_id) { 431 ureg->output[i].usage_mask |= usage_mask; 432 goto out; 433 } 434 assert((ureg->output[i].usage_mask & usage_mask) == 0); 435 } 436 } 437 438 if (ureg->nr_outputs < UREG_MAX_OUTPUT) { 439 ureg->output[i].semantic_name = semantic_name; 440 ureg->output[i].semantic_index = semantic_index; 441 ureg->output[i].usage_mask = usage_mask; 442 ureg->output[i].first = index; 443 ureg->output[i].last = index + array_size - 1; 444 ureg->output[i].array_id = array_id; 445 ureg->nr_output_regs = MAX2(ureg->nr_output_regs, index + array_size); 446 ureg->nr_outputs++; 447 } 448 else { 449 set_bad( ureg ); 450 i = 0; 451 } 452 453 out: 454 ureg->output[i].streams |= streams; 455 456 return ureg_dst_array_register(TGSI_FILE_OUTPUT, ureg->output[i].first, 457 array_id); 458 } 459 460 461 struct ureg_dst 462 ureg_DECL_output_masked(struct ureg_program *ureg, 463 unsigned name, 464 unsigned index, 465 unsigned usage_mask, 466 unsigned array_id, 467 unsigned array_size) 468 { 469 return ureg_DECL_output_layout(ureg, name, index, 0, 470 ureg->nr_output_regs, usage_mask, array_id, array_size); 471 } 472 473 474 struct ureg_dst 475 ureg_DECL_output(struct ureg_program *ureg, 476 unsigned name, 477 unsigned index) 478 { 479 return ureg_DECL_output_masked(ureg, name, index, TGSI_WRITEMASK_XYZW, 480 0, 1); 481 } 482 483 struct ureg_dst 484 ureg_DECL_output_array(struct ureg_program *ureg, 485 unsigned semantic_name, 486 unsigned semantic_index, 487 unsigned array_id, 488 unsigned array_size) 489 { 490 return ureg_DECL_output_masked(ureg, semantic_name, semantic_index, 491 TGSI_WRITEMASK_XYZW, 492 array_id, array_size); 493 } 494 495 496 /* Returns a new constant register. Keep track of which have been 497 * referred to so that we can emit decls later. 498 * 499 * Constant operands declared with this function must be addressed 500 * with a two-dimensional index. 501 * 502 * There is nothing in this code to bind this constant to any tracked 503 * value or manage any constant_buffer contents -- that's the 504 * resposibility of the calling code. 505 */ 506 void 507 ureg_DECL_constant2D(struct ureg_program *ureg, 508 unsigned first, 509 unsigned last, 510 unsigned index2D) 511 { 512 struct const_decl *decl = &ureg->const_decls2D[index2D]; 513 514 assert(index2D < PIPE_MAX_CONSTANT_BUFFERS); 515 516 if (decl->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) { 517 uint i = decl->nr_constant_ranges++; 518 519 decl->constant_range[i].first = first; 520 decl->constant_range[i].last = last; 521 } 522 } 523 524 525 /* A one-dimensional, deprecated version of ureg_DECL_constant2D(). 526 * 527 * Constant operands declared with this function must be addressed 528 * with a one-dimensional index. 529 */ 530 struct ureg_src 531 ureg_DECL_constant(struct ureg_program *ureg, 532 unsigned index) 533 { 534 struct const_decl *decl = &ureg->const_decls; 535 unsigned minconst = index, maxconst = index; 536 unsigned i; 537 538 /* Inside existing range? 539 */ 540 for (i = 0; i < decl->nr_constant_ranges; i++) { 541 if (decl->constant_range[i].first <= index && 542 decl->constant_range[i].last >= index) { 543 goto out; 544 } 545 } 546 547 /* Extend existing range? 548 */ 549 for (i = 0; i < decl->nr_constant_ranges; i++) { 550 if (decl->constant_range[i].last == index - 1) { 551 decl->constant_range[i].last = index; 552 goto out; 553 } 554 555 if (decl->constant_range[i].first == index + 1) { 556 decl->constant_range[i].first = index; 557 goto out; 558 } 559 560 minconst = MIN2(minconst, decl->constant_range[i].first); 561 maxconst = MAX2(maxconst, decl->constant_range[i].last); 562 } 563 564 /* Create new range? 565 */ 566 if (decl->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) { 567 i = decl->nr_constant_ranges++; 568 decl->constant_range[i].first = index; 569 decl->constant_range[i].last = index; 570 goto out; 571 } 572 573 /* Collapse all ranges down to one: 574 */ 575 i = 0; 576 decl->constant_range[0].first = minconst; 577 decl->constant_range[0].last = maxconst; 578 decl->nr_constant_ranges = 1; 579 580 out: 581 assert(i < decl->nr_constant_ranges); 582 assert(decl->constant_range[i].first <= index); 583 assert(decl->constant_range[i].last >= index); 584 return ureg_src_register(TGSI_FILE_CONSTANT, index); 585 } 586 587 static struct ureg_dst alloc_temporary( struct ureg_program *ureg, 588 boolean local ) 589 { 590 unsigned i; 591 592 /* Look for a released temporary. 593 */ 594 for (i = util_bitmask_get_first_index(ureg->free_temps); 595 i != UTIL_BITMASK_INVALID_INDEX; 596 i = util_bitmask_get_next_index(ureg->free_temps, i + 1)) { 597 if (util_bitmask_get(ureg->local_temps, i) == local) 598 break; 599 } 600 601 /* Or allocate a new one. 602 */ 603 if (i == UTIL_BITMASK_INVALID_INDEX) { 604 i = ureg->nr_temps++; 605 606 if (local) 607 util_bitmask_set(ureg->local_temps, i); 608 609 /* Start a new declaration when the local flag changes */ 610 if (!i || util_bitmask_get(ureg->local_temps, i - 1) != local) 611 util_bitmask_set(ureg->decl_temps, i); 612 } 613 614 util_bitmask_clear(ureg->free_temps, i); 615 616 return ureg_dst_register( TGSI_FILE_TEMPORARY, i ); 617 } 618 619 struct ureg_dst ureg_DECL_temporary( struct ureg_program *ureg ) 620 { 621 return alloc_temporary(ureg, FALSE); 622 } 623 624 struct ureg_dst ureg_DECL_local_temporary( struct ureg_program *ureg ) 625 { 626 return alloc_temporary(ureg, TRUE); 627 } 628 629 struct ureg_dst ureg_DECL_array_temporary( struct ureg_program *ureg, 630 unsigned size, 631 boolean local ) 632 { 633 unsigned i = ureg->nr_temps; 634 struct ureg_dst dst = ureg_dst_register( TGSI_FILE_TEMPORARY, i ); 635 636 if (local) 637 util_bitmask_set(ureg->local_temps, i); 638 639 /* Always start a new declaration at the start */ 640 util_bitmask_set(ureg->decl_temps, i); 641 642 ureg->nr_temps += size; 643 644 /* and also at the end of the array */ 645 util_bitmask_set(ureg->decl_temps, ureg->nr_temps); 646 647 if (ureg->nr_array_temps < UREG_MAX_ARRAY_TEMPS) { 648 ureg->array_temps[ureg->nr_array_temps++] = i; 649 dst.ArrayID = ureg->nr_array_temps; 650 } 651 652 return dst; 653 } 654 655 void ureg_release_temporary( struct ureg_program *ureg, 656 struct ureg_dst tmp ) 657 { 658 if(tmp.File == TGSI_FILE_TEMPORARY) 659 util_bitmask_set(ureg->free_temps, tmp.Index); 660 } 661 662 663 /* Allocate a new address register. 664 */ 665 struct ureg_dst ureg_DECL_address( struct ureg_program *ureg ) 666 { 667 if (ureg->nr_addrs < UREG_MAX_ADDR) 668 return ureg_dst_register( TGSI_FILE_ADDRESS, ureg->nr_addrs++ ); 669 670 assert( 0 ); 671 return ureg_dst_register( TGSI_FILE_ADDRESS, 0 ); 672 } 673 674 /* Allocate a new predicate register. 675 */ 676 struct ureg_dst 677 ureg_DECL_predicate(struct ureg_program *ureg) 678 { 679 if (ureg->nr_preds < UREG_MAX_PRED) { 680 return ureg_dst_register(TGSI_FILE_PREDICATE, ureg->nr_preds++); 681 } 682 683 assert(0); 684 return ureg_dst_register(TGSI_FILE_PREDICATE, 0); 685 } 686 687 /* Allocate a new sampler. 688 */ 689 struct ureg_src ureg_DECL_sampler( struct ureg_program *ureg, 690 unsigned nr ) 691 { 692 unsigned i; 693 694 for (i = 0; i < ureg->nr_samplers; i++) 695 if (ureg->sampler[i].Index == nr) 696 return ureg->sampler[i]; 697 698 if (i < PIPE_MAX_SAMPLERS) { 699 ureg->sampler[i] = ureg_src_register( TGSI_FILE_SAMPLER, nr ); 700 ureg->nr_samplers++; 701 return ureg->sampler[i]; 702 } 703 704 assert( 0 ); 705 return ureg->sampler[0]; 706 } 707 708 /* 709 * Allocate a new shader sampler view. 710 */ 711 struct ureg_src 712 ureg_DECL_sampler_view(struct ureg_program *ureg, 713 unsigned index, 714 unsigned target, 715 unsigned return_type_x, 716 unsigned return_type_y, 717 unsigned return_type_z, 718 unsigned return_type_w) 719 { 720 struct ureg_src reg = ureg_src_register(TGSI_FILE_SAMPLER_VIEW, index); 721 uint i; 722 723 for (i = 0; i < ureg->nr_sampler_views; i++) { 724 if (ureg->sampler_view[i].index == index) { 725 return reg; 726 } 727 } 728 729 if (i < PIPE_MAX_SHADER_SAMPLER_VIEWS) { 730 ureg->sampler_view[i].index = index; 731 ureg->sampler_view[i].target = target; 732 ureg->sampler_view[i].return_type_x = return_type_x; 733 ureg->sampler_view[i].return_type_y = return_type_y; 734 ureg->sampler_view[i].return_type_z = return_type_z; 735 ureg->sampler_view[i].return_type_w = return_type_w; 736 ureg->nr_sampler_views++; 737 return reg; 738 } 739 740 assert(0); 741 return reg; 742 } 743 744 /* Allocate a new image. 745 */ 746 struct ureg_src 747 ureg_DECL_image(struct ureg_program *ureg, 748 unsigned index, 749 unsigned target, 750 unsigned format, 751 boolean wr, 752 boolean raw) 753 { 754 struct ureg_src reg = ureg_src_register(TGSI_FILE_IMAGE, index); 755 unsigned i; 756 757 for (i = 0; i < ureg->nr_images; i++) 758 if (ureg->image[i].index == index) 759 return reg; 760 761 if (i < PIPE_MAX_SHADER_IMAGES) { 762 ureg->image[i].index = index; 763 ureg->image[i].target = target; 764 ureg->image[i].wr = wr; 765 ureg->image[i].raw = raw; 766 ureg->image[i].format = format; 767 ureg->nr_images++; 768 return reg; 769 } 770 771 assert(0); 772 return reg; 773 } 774 775 /* Allocate a new buffer. 776 */ 777 struct ureg_src ureg_DECL_buffer(struct ureg_program *ureg, unsigned nr, 778 bool atomic) 779 { 780 struct ureg_src reg = ureg_src_register(TGSI_FILE_BUFFER, nr); 781 unsigned i; 782 783 for (i = 0; i < ureg->nr_buffers; i++) 784 if (ureg->buffer[i].index == nr) 785 return reg; 786 787 if (i < PIPE_MAX_SHADER_BUFFERS) { 788 ureg->buffer[i].index = nr; 789 ureg->buffer[i].atomic = atomic; 790 ureg->nr_buffers++; 791 return reg; 792 } 793 794 assert(0); 795 return reg; 796 } 797 798 /* Allocate a memory area. 799 */ 800 struct ureg_src ureg_DECL_memory(struct ureg_program *ureg, 801 unsigned memory_type) 802 { 803 struct ureg_src reg = ureg_src_register(TGSI_FILE_MEMORY, memory_type); 804 805 ureg->use_memory[memory_type] = true; 806 return reg; 807 } 808 809 static int 810 match_or_expand_immediate64( const unsigned *v, 811 int type, 812 unsigned nr, 813 unsigned *v2, 814 unsigned *pnr2, 815 unsigned *swizzle ) 816 { 817 unsigned nr2 = *pnr2; 818 unsigned i, j; 819 *swizzle = 0; 820 821 for (i = 0; i < nr; i += 2) { 822 boolean found = FALSE; 823 824 for (j = 0; j < nr2 && !found; j += 2) { 825 if (v[i] == v2[j] && v[i + 1] == v2[j + 1]) { 826 *swizzle |= (j << (i * 2)) | ((j + 1) << ((i + 1) * 2)); 827 found = TRUE; 828 } 829 } 830 if (!found) { 831 if ((nr2) >= 4) { 832 return FALSE; 833 } 834 835 v2[nr2] = v[i]; 836 v2[nr2 + 1] = v[i + 1]; 837 838 *swizzle |= (nr2 << (i * 2)) | ((nr2 + 1) << ((i + 1) * 2)); 839 nr2 += 2; 840 } 841 } 842 843 /* Actually expand immediate only when fully succeeded. 844 */ 845 *pnr2 = nr2; 846 return TRUE; 847 } 848 849 static int 850 match_or_expand_immediate( const unsigned *v, 851 int type, 852 unsigned nr, 853 unsigned *v2, 854 unsigned *pnr2, 855 unsigned *swizzle ) 856 { 857 unsigned nr2 = *pnr2; 858 unsigned i, j; 859 860 if (type == TGSI_IMM_FLOAT64 || 861 type == TGSI_IMM_UINT64 || 862 type == TGSI_IMM_INT64) 863 return match_or_expand_immediate64(v, type, nr, v2, pnr2, swizzle); 864 865 *swizzle = 0; 866 867 for (i = 0; i < nr; i++) { 868 boolean found = FALSE; 869 870 for (j = 0; j < nr2 && !found; j++) { 871 if (v[i] == v2[j]) { 872 *swizzle |= j << (i * 2); 873 found = TRUE; 874 } 875 } 876 877 if (!found) { 878 if (nr2 >= 4) { 879 return FALSE; 880 } 881 882 v2[nr2] = v[i]; 883 *swizzle |= nr2 << (i * 2); 884 nr2++; 885 } 886 } 887 888 /* Actually expand immediate only when fully succeeded. 889 */ 890 *pnr2 = nr2; 891 return TRUE; 892 } 893 894 895 static struct ureg_src 896 decl_immediate( struct ureg_program *ureg, 897 const unsigned *v, 898 unsigned nr, 899 unsigned type ) 900 { 901 unsigned i, j; 902 unsigned swizzle = 0; 903 904 /* Could do a first pass where we examine all existing immediates 905 * without expanding. 906 */ 907 908 for (i = 0; i < ureg->nr_immediates; i++) { 909 if (ureg->immediate[i].type != type) { 910 continue; 911 } 912 if (match_or_expand_immediate(v, 913 type, 914 nr, 915 ureg->immediate[i].value.u, 916 &ureg->immediate[i].nr, 917 &swizzle)) { 918 goto out; 919 } 920 } 921 922 if (ureg->nr_immediates < UREG_MAX_IMMEDIATE) { 923 i = ureg->nr_immediates++; 924 ureg->immediate[i].type = type; 925 if (match_or_expand_immediate(v, 926 type, 927 nr, 928 ureg->immediate[i].value.u, 929 &ureg->immediate[i].nr, 930 &swizzle)) { 931 goto out; 932 } 933 } 934 935 set_bad(ureg); 936 937 out: 938 /* Make sure that all referenced elements are from this immediate. 939 * Has the effect of making size-one immediates into scalars. 940 */ 941 if (type == TGSI_IMM_FLOAT64 || 942 type == TGSI_IMM_UINT64 || 943 type == TGSI_IMM_INT64) { 944 for (j = nr; j < 4; j+=2) { 945 swizzle |= (swizzle & 0xf) << (j * 2); 946 } 947 } else { 948 for (j = nr; j < 4; j++) { 949 swizzle |= (swizzle & 0x3) << (j * 2); 950 } 951 } 952 return ureg_swizzle(ureg_src_register(TGSI_FILE_IMMEDIATE, i), 953 (swizzle >> 0) & 0x3, 954 (swizzle >> 2) & 0x3, 955 (swizzle >> 4) & 0x3, 956 (swizzle >> 6) & 0x3); 957 } 958 959 960 struct ureg_src 961 ureg_DECL_immediate( struct ureg_program *ureg, 962 const float *v, 963 unsigned nr ) 964 { 965 union { 966 float f[4]; 967 unsigned u[4]; 968 } fu; 969 unsigned int i; 970 971 for (i = 0; i < nr; i++) { 972 fu.f[i] = v[i]; 973 } 974 975 return decl_immediate(ureg, fu.u, nr, TGSI_IMM_FLOAT32); 976 } 977 978 struct ureg_src 979 ureg_DECL_immediate_f64( struct ureg_program *ureg, 980 const double *v, 981 unsigned nr ) 982 { 983 union { 984 unsigned u[4]; 985 double d[2]; 986 } fu; 987 unsigned int i; 988 989 assert((nr / 2) < 3); 990 for (i = 0; i < nr / 2; i++) { 991 fu.d[i] = v[i]; 992 } 993 994 return decl_immediate(ureg, fu.u, nr, TGSI_IMM_FLOAT64); 995 } 996 997 struct ureg_src 998 ureg_DECL_immediate_uint( struct ureg_program *ureg, 999 const unsigned *v, 1000 unsigned nr ) 1001 { 1002 return decl_immediate(ureg, v, nr, TGSI_IMM_UINT32); 1003 } 1004 1005 1006 struct ureg_src 1007 ureg_DECL_immediate_block_uint( struct ureg_program *ureg, 1008 const unsigned *v, 1009 unsigned nr ) 1010 { 1011 uint index; 1012 uint i; 1013 1014 if (ureg->nr_immediates + (nr + 3) / 4 > UREG_MAX_IMMEDIATE) { 1015 set_bad(ureg); 1016 return ureg_src_register(TGSI_FILE_IMMEDIATE, 0); 1017 } 1018 1019 index = ureg->nr_immediates; 1020 ureg->nr_immediates += (nr + 3) / 4; 1021 1022 for (i = index; i < ureg->nr_immediates; i++) { 1023 ureg->immediate[i].type = TGSI_IMM_UINT32; 1024 ureg->immediate[i].nr = nr > 4 ? 4 : nr; 1025 memcpy(ureg->immediate[i].value.u, 1026 &v[(i - index) * 4], 1027 ureg->immediate[i].nr * sizeof(uint)); 1028 nr -= 4; 1029 } 1030 1031 return ureg_src_register(TGSI_FILE_IMMEDIATE, index); 1032 } 1033 1034 1035 struct ureg_src 1036 ureg_DECL_immediate_int( struct ureg_program *ureg, 1037 const int *v, 1038 unsigned nr ) 1039 { 1040 return decl_immediate(ureg, (const unsigned *)v, nr, TGSI_IMM_INT32); 1041 } 1042 1043 struct ureg_src 1044 ureg_DECL_immediate_uint64( struct ureg_program *ureg, 1045 const uint64_t *v, 1046 unsigned nr ) 1047 { 1048 union { 1049 unsigned u[4]; 1050 uint64_t u64[2]; 1051 } fu; 1052 unsigned int i; 1053 1054 assert((nr / 2) < 3); 1055 for (i = 0; i < nr / 2; i++) { 1056 fu.u64[i] = v[i]; 1057 } 1058 1059 return decl_immediate(ureg, fu.u, nr, TGSI_IMM_UINT64); 1060 } 1061 1062 struct ureg_src 1063 ureg_DECL_immediate_int64( struct ureg_program *ureg, 1064 const int64_t *v, 1065 unsigned nr ) 1066 { 1067 union { 1068 unsigned u[4]; 1069 int64_t i64[2]; 1070 } fu; 1071 unsigned int i; 1072 1073 assert((nr / 2) < 3); 1074 for (i = 0; i < nr / 2; i++) { 1075 fu.i64[i] = v[i]; 1076 } 1077 1078 return decl_immediate(ureg, fu.u, nr, TGSI_IMM_INT64); 1079 } 1080 1081 void 1082 ureg_emit_src( struct ureg_program *ureg, 1083 struct ureg_src src ) 1084 { 1085 unsigned size = 1 + (src.Indirect ? 1 : 0) + 1086 (src.Dimension ? (src.DimIndirect ? 2 : 1) : 0); 1087 1088 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size ); 1089 unsigned n = 0; 1090 1091 assert(src.File != TGSI_FILE_NULL); 1092 assert(src.File < TGSI_FILE_COUNT); 1093 1094 out[n].value = 0; 1095 out[n].src.File = src.File; 1096 out[n].src.SwizzleX = src.SwizzleX; 1097 out[n].src.SwizzleY = src.SwizzleY; 1098 out[n].src.SwizzleZ = src.SwizzleZ; 1099 out[n].src.SwizzleW = src.SwizzleW; 1100 out[n].src.Index = src.Index; 1101 out[n].src.Negate = src.Negate; 1102 out[0].src.Absolute = src.Absolute; 1103 n++; 1104 1105 if (src.Indirect) { 1106 out[0].src.Indirect = 1; 1107 out[n].value = 0; 1108 out[n].ind.File = src.IndirectFile; 1109 out[n].ind.Swizzle = src.IndirectSwizzle; 1110 out[n].ind.Index = src.IndirectIndex; 1111 if (!ureg->supports_any_inout_decl_range && 1112 (src.File == TGSI_FILE_INPUT || src.File == TGSI_FILE_OUTPUT)) 1113 out[n].ind.ArrayID = 0; 1114 else 1115 out[n].ind.ArrayID = src.ArrayID; 1116 n++; 1117 } 1118 1119 if (src.Dimension) { 1120 out[0].src.Dimension = 1; 1121 out[n].dim.Dimension = 0; 1122 out[n].dim.Padding = 0; 1123 if (src.DimIndirect) { 1124 out[n].dim.Indirect = 1; 1125 out[n].dim.Index = src.DimensionIndex; 1126 n++; 1127 out[n].value = 0; 1128 out[n].ind.File = src.DimIndFile; 1129 out[n].ind.Swizzle = src.DimIndSwizzle; 1130 out[n].ind.Index = src.DimIndIndex; 1131 if (!ureg->supports_any_inout_decl_range && 1132 (src.File == TGSI_FILE_INPUT || src.File == TGSI_FILE_OUTPUT)) 1133 out[n].ind.ArrayID = 0; 1134 else 1135 out[n].ind.ArrayID = src.ArrayID; 1136 } else { 1137 out[n].dim.Indirect = 0; 1138 out[n].dim.Index = src.DimensionIndex; 1139 } 1140 n++; 1141 } 1142 1143 assert(n == size); 1144 } 1145 1146 1147 void 1148 ureg_emit_dst( struct ureg_program *ureg, 1149 struct ureg_dst dst ) 1150 { 1151 unsigned size = 1 + (dst.Indirect ? 1 : 0) + 1152 (dst.Dimension ? (dst.DimIndirect ? 2 : 1) : 0); 1153 1154 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size ); 1155 unsigned n = 0; 1156 1157 assert(dst.File != TGSI_FILE_NULL); 1158 assert(dst.File != TGSI_FILE_CONSTANT); 1159 assert(dst.File != TGSI_FILE_INPUT); 1160 assert(dst.File != TGSI_FILE_SAMPLER); 1161 assert(dst.File != TGSI_FILE_SAMPLER_VIEW); 1162 assert(dst.File != TGSI_FILE_IMMEDIATE); 1163 assert(dst.File < TGSI_FILE_COUNT); 1164 1165 out[n].value = 0; 1166 out[n].dst.File = dst.File; 1167 out[n].dst.WriteMask = dst.WriteMask; 1168 out[n].dst.Indirect = dst.Indirect; 1169 out[n].dst.Index = dst.Index; 1170 n++; 1171 1172 if (dst.Indirect) { 1173 out[n].value = 0; 1174 out[n].ind.File = dst.IndirectFile; 1175 out[n].ind.Swizzle = dst.IndirectSwizzle; 1176 out[n].ind.Index = dst.IndirectIndex; 1177 if (!ureg->supports_any_inout_decl_range && 1178 (dst.File == TGSI_FILE_INPUT || dst.File == TGSI_FILE_OUTPUT)) 1179 out[n].ind.ArrayID = 0; 1180 else 1181 out[n].ind.ArrayID = dst.ArrayID; 1182 n++; 1183 } 1184 1185 if (dst.Dimension) { 1186 out[0].dst.Dimension = 1; 1187 out[n].dim.Dimension = 0; 1188 out[n].dim.Padding = 0; 1189 if (dst.DimIndirect) { 1190 out[n].dim.Indirect = 1; 1191 out[n].dim.Index = dst.DimensionIndex; 1192 n++; 1193 out[n].value = 0; 1194 out[n].ind.File = dst.DimIndFile; 1195 out[n].ind.Swizzle = dst.DimIndSwizzle; 1196 out[n].ind.Index = dst.DimIndIndex; 1197 if (!ureg->supports_any_inout_decl_range && 1198 (dst.File == TGSI_FILE_INPUT || dst.File == TGSI_FILE_OUTPUT)) 1199 out[n].ind.ArrayID = 0; 1200 else 1201 out[n].ind.ArrayID = dst.ArrayID; 1202 } else { 1203 out[n].dim.Indirect = 0; 1204 out[n].dim.Index = dst.DimensionIndex; 1205 } 1206 n++; 1207 } 1208 1209 assert(n == size); 1210 } 1211 1212 1213 static void validate( unsigned opcode, 1214 unsigned nr_dst, 1215 unsigned nr_src ) 1216 { 1217 #ifdef DEBUG 1218 const struct tgsi_opcode_info *info = tgsi_get_opcode_info( opcode ); 1219 assert(info); 1220 if (info) { 1221 assert(nr_dst == info->num_dst); 1222 assert(nr_src == info->num_src); 1223 } 1224 #endif 1225 } 1226 1227 struct ureg_emit_insn_result 1228 ureg_emit_insn(struct ureg_program *ureg, 1229 unsigned opcode, 1230 boolean saturate, 1231 boolean predicate, 1232 boolean pred_negate, 1233 unsigned pred_swizzle_x, 1234 unsigned pred_swizzle_y, 1235 unsigned pred_swizzle_z, 1236 unsigned pred_swizzle_w, 1237 unsigned num_dst, 1238 unsigned num_src ) 1239 { 1240 union tgsi_any_token *out; 1241 uint count = predicate ? 2 : 1; 1242 struct ureg_emit_insn_result result; 1243 1244 validate( opcode, num_dst, num_src ); 1245 1246 out = get_tokens( ureg, DOMAIN_INSN, count ); 1247 out[0].insn = tgsi_default_instruction(); 1248 out[0].insn.Opcode = opcode; 1249 out[0].insn.Saturate = saturate; 1250 out[0].insn.NumDstRegs = num_dst; 1251 out[0].insn.NumSrcRegs = num_src; 1252 1253 result.insn_token = ureg->domain[DOMAIN_INSN].count - count; 1254 result.extended_token = result.insn_token; 1255 1256 if (predicate) { 1257 out[0].insn.Predicate = 1; 1258 out[1].insn_predicate = tgsi_default_instruction_predicate(); 1259 out[1].insn_predicate.Negate = pred_negate; 1260 out[1].insn_predicate.SwizzleX = pred_swizzle_x; 1261 out[1].insn_predicate.SwizzleY = pred_swizzle_y; 1262 out[1].insn_predicate.SwizzleZ = pred_swizzle_z; 1263 out[1].insn_predicate.SwizzleW = pred_swizzle_w; 1264 } 1265 1266 ureg->nr_instructions++; 1267 1268 return result; 1269 } 1270 1271 1272 /** 1273 * Emit a label token. 1274 * \param label_token returns a token number indicating where the label 1275 * needs to be patched later. Later, this value should be passed to the 1276 * ureg_fixup_label() function. 1277 */ 1278 void 1279 ureg_emit_label(struct ureg_program *ureg, 1280 unsigned extended_token, 1281 unsigned *label_token ) 1282 { 1283 union tgsi_any_token *out, *insn; 1284 1285 if (!label_token) 1286 return; 1287 1288 out = get_tokens( ureg, DOMAIN_INSN, 1 ); 1289 out[0].value = 0; 1290 1291 insn = retrieve_token( ureg, DOMAIN_INSN, extended_token ); 1292 insn->insn.Label = 1; 1293 1294 *label_token = ureg->domain[DOMAIN_INSN].count - 1; 1295 } 1296 1297 /* Will return a number which can be used in a label to point to the 1298 * next instruction to be emitted. 1299 */ 1300 unsigned 1301 ureg_get_instruction_number( struct ureg_program *ureg ) 1302 { 1303 return ureg->nr_instructions; 1304 } 1305 1306 /* Patch a given label (expressed as a token number) to point to a 1307 * given instruction (expressed as an instruction number). 1308 */ 1309 void 1310 ureg_fixup_label(struct ureg_program *ureg, 1311 unsigned label_token, 1312 unsigned instruction_number ) 1313 { 1314 union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, label_token ); 1315 1316 out->insn_label.Label = instruction_number; 1317 } 1318 1319 1320 void 1321 ureg_emit_texture(struct ureg_program *ureg, 1322 unsigned extended_token, 1323 unsigned target, unsigned num_offsets) 1324 { 1325 union tgsi_any_token *out, *insn; 1326 1327 out = get_tokens( ureg, DOMAIN_INSN, 1 ); 1328 insn = retrieve_token( ureg, DOMAIN_INSN, extended_token ); 1329 1330 insn->insn.Texture = 1; 1331 1332 out[0].value = 0; 1333 out[0].insn_texture.Texture = target; 1334 out[0].insn_texture.NumOffsets = num_offsets; 1335 } 1336 1337 void 1338 ureg_emit_texture_offset(struct ureg_program *ureg, 1339 const struct tgsi_texture_offset *offset) 1340 { 1341 union tgsi_any_token *out; 1342 1343 out = get_tokens( ureg, DOMAIN_INSN, 1); 1344 1345 out[0].value = 0; 1346 out[0].insn_texture_offset = *offset; 1347 1348 } 1349 1350 void 1351 ureg_emit_memory(struct ureg_program *ureg, 1352 unsigned extended_token, 1353 unsigned qualifier, 1354 unsigned texture, 1355 unsigned format) 1356 { 1357 union tgsi_any_token *out, *insn; 1358 1359 out = get_tokens( ureg, DOMAIN_INSN, 1 ); 1360 insn = retrieve_token( ureg, DOMAIN_INSN, extended_token ); 1361 1362 insn->insn.Memory = 1; 1363 1364 out[0].value = 0; 1365 out[0].insn_memory.Qualifier = qualifier; 1366 out[0].insn_memory.Texture = texture; 1367 out[0].insn_memory.Format = format; 1368 } 1369 1370 void 1371 ureg_fixup_insn_size(struct ureg_program *ureg, 1372 unsigned insn ) 1373 { 1374 union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, insn ); 1375 1376 assert(out->insn.Type == TGSI_TOKEN_TYPE_INSTRUCTION); 1377 out->insn.NrTokens = ureg->domain[DOMAIN_INSN].count - insn - 1; 1378 } 1379 1380 1381 void 1382 ureg_insn(struct ureg_program *ureg, 1383 unsigned opcode, 1384 const struct ureg_dst *dst, 1385 unsigned nr_dst, 1386 const struct ureg_src *src, 1387 unsigned nr_src ) 1388 { 1389 struct ureg_emit_insn_result insn; 1390 unsigned i; 1391 boolean saturate; 1392 boolean predicate; 1393 boolean negate = FALSE; 1394 unsigned swizzle[4] = { 0 }; 1395 1396 if (nr_dst && ureg_dst_is_empty(dst[0])) { 1397 return; 1398 } 1399 1400 saturate = nr_dst ? dst[0].Saturate : FALSE; 1401 predicate = nr_dst ? dst[0].Predicate : FALSE; 1402 if (predicate) { 1403 negate = dst[0].PredNegate; 1404 swizzle[0] = dst[0].PredSwizzleX; 1405 swizzle[1] = dst[0].PredSwizzleY; 1406 swizzle[2] = dst[0].PredSwizzleZ; 1407 swizzle[3] = dst[0].PredSwizzleW; 1408 } 1409 1410 insn = ureg_emit_insn(ureg, 1411 opcode, 1412 saturate, 1413 predicate, 1414 negate, 1415 swizzle[0], 1416 swizzle[1], 1417 swizzle[2], 1418 swizzle[3], 1419 nr_dst, 1420 nr_src); 1421 1422 for (i = 0; i < nr_dst; i++) 1423 ureg_emit_dst( ureg, dst[i] ); 1424 1425 for (i = 0; i < nr_src; i++) 1426 ureg_emit_src( ureg, src[i] ); 1427 1428 ureg_fixup_insn_size( ureg, insn.insn_token ); 1429 } 1430 1431 void 1432 ureg_tex_insn(struct ureg_program *ureg, 1433 unsigned opcode, 1434 const struct ureg_dst *dst, 1435 unsigned nr_dst, 1436 unsigned target, 1437 const struct tgsi_texture_offset *texoffsets, 1438 unsigned nr_offset, 1439 const struct ureg_src *src, 1440 unsigned nr_src ) 1441 { 1442 struct ureg_emit_insn_result insn; 1443 unsigned i; 1444 boolean saturate; 1445 boolean predicate; 1446 boolean negate = FALSE; 1447 unsigned swizzle[4] = { 0 }; 1448 1449 if (nr_dst && ureg_dst_is_empty(dst[0])) { 1450 return; 1451 } 1452 1453 saturate = nr_dst ? dst[0].Saturate : FALSE; 1454 predicate = nr_dst ? dst[0].Predicate : FALSE; 1455 if (predicate) { 1456 negate = dst[0].PredNegate; 1457 swizzle[0] = dst[0].PredSwizzleX; 1458 swizzle[1] = dst[0].PredSwizzleY; 1459 swizzle[2] = dst[0].PredSwizzleZ; 1460 swizzle[3] = dst[0].PredSwizzleW; 1461 } 1462 1463 insn = ureg_emit_insn(ureg, 1464 opcode, 1465 saturate, 1466 predicate, 1467 negate, 1468 swizzle[0], 1469 swizzle[1], 1470 swizzle[2], 1471 swizzle[3], 1472 nr_dst, 1473 nr_src); 1474 1475 ureg_emit_texture( ureg, insn.extended_token, target, nr_offset ); 1476 1477 for (i = 0; i < nr_offset; i++) 1478 ureg_emit_texture_offset( ureg, &texoffsets[i]); 1479 1480 for (i = 0; i < nr_dst; i++) 1481 ureg_emit_dst( ureg, dst[i] ); 1482 1483 for (i = 0; i < nr_src; i++) 1484 ureg_emit_src( ureg, src[i] ); 1485 1486 ureg_fixup_insn_size( ureg, insn.insn_token ); 1487 } 1488 1489 1490 void 1491 ureg_label_insn(struct ureg_program *ureg, 1492 unsigned opcode, 1493 const struct ureg_src *src, 1494 unsigned nr_src, 1495 unsigned *label_token ) 1496 { 1497 struct ureg_emit_insn_result insn; 1498 unsigned i; 1499 1500 insn = ureg_emit_insn(ureg, 1501 opcode, 1502 FALSE, 1503 FALSE, 1504 FALSE, 1505 TGSI_SWIZZLE_X, 1506 TGSI_SWIZZLE_Y, 1507 TGSI_SWIZZLE_Z, 1508 TGSI_SWIZZLE_W, 1509 0, 1510 nr_src); 1511 1512 ureg_emit_label( ureg, insn.extended_token, label_token ); 1513 1514 for (i = 0; i < nr_src; i++) 1515 ureg_emit_src( ureg, src[i] ); 1516 1517 ureg_fixup_insn_size( ureg, insn.insn_token ); 1518 } 1519 1520 1521 void 1522 ureg_memory_insn(struct ureg_program *ureg, 1523 unsigned opcode, 1524 const struct ureg_dst *dst, 1525 unsigned nr_dst, 1526 const struct ureg_src *src, 1527 unsigned nr_src, 1528 unsigned qualifier, 1529 unsigned texture, 1530 unsigned format) 1531 { 1532 struct ureg_emit_insn_result insn; 1533 unsigned i; 1534 1535 insn = ureg_emit_insn(ureg, 1536 opcode, 1537 FALSE, 1538 FALSE, 1539 FALSE, 1540 TGSI_SWIZZLE_X, 1541 TGSI_SWIZZLE_Y, 1542 TGSI_SWIZZLE_Z, 1543 TGSI_SWIZZLE_W, 1544 nr_dst, 1545 nr_src); 1546 1547 ureg_emit_memory(ureg, insn.extended_token, qualifier, texture, format); 1548 1549 for (i = 0; i < nr_dst; i++) 1550 ureg_emit_dst(ureg, dst[i]); 1551 1552 for (i = 0; i < nr_src; i++) 1553 ureg_emit_src(ureg, src[i]); 1554 1555 ureg_fixup_insn_size(ureg, insn.insn_token); 1556 } 1557 1558 1559 static void 1560 emit_decl_semantic(struct ureg_program *ureg, 1561 unsigned file, 1562 unsigned first, 1563 unsigned last, 1564 unsigned semantic_name, 1565 unsigned semantic_index, 1566 unsigned streams, 1567 unsigned usage_mask, 1568 unsigned array_id) 1569 { 1570 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, array_id ? 4 : 3); 1571 1572 out[0].value = 0; 1573 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1574 out[0].decl.NrTokens = 3; 1575 out[0].decl.File = file; 1576 out[0].decl.UsageMask = usage_mask; 1577 out[0].decl.Semantic = 1; 1578 out[0].decl.Array = array_id != 0; 1579 1580 out[1].value = 0; 1581 out[1].decl_range.First = first; 1582 out[1].decl_range.Last = last; 1583 1584 out[2].value = 0; 1585 out[2].decl_semantic.Name = semantic_name; 1586 out[2].decl_semantic.Index = semantic_index; 1587 out[2].decl_semantic.StreamX = streams & 3; 1588 out[2].decl_semantic.StreamY = (streams >> 2) & 3; 1589 out[2].decl_semantic.StreamZ = (streams >> 4) & 3; 1590 out[2].decl_semantic.StreamW = (streams >> 6) & 3; 1591 1592 if (array_id) { 1593 out[3].value = 0; 1594 out[3].array.ArrayID = array_id; 1595 } 1596 } 1597 1598 1599 static void 1600 emit_decl_fs(struct ureg_program *ureg, 1601 unsigned file, 1602 unsigned first, 1603 unsigned last, 1604 unsigned semantic_name, 1605 unsigned semantic_index, 1606 unsigned interpolate, 1607 unsigned cylindrical_wrap, 1608 unsigned interpolate_location, 1609 unsigned array_id, 1610 unsigned usage_mask) 1611 { 1612 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 1613 array_id ? 5 : 4); 1614 1615 out[0].value = 0; 1616 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1617 out[0].decl.NrTokens = 4; 1618 out[0].decl.File = file; 1619 out[0].decl.UsageMask = usage_mask; 1620 out[0].decl.Interpolate = 1; 1621 out[0].decl.Semantic = 1; 1622 out[0].decl.Array = array_id != 0; 1623 1624 out[1].value = 0; 1625 out[1].decl_range.First = first; 1626 out[1].decl_range.Last = last; 1627 1628 out[2].value = 0; 1629 out[2].decl_interp.Interpolate = interpolate; 1630 out[2].decl_interp.CylindricalWrap = cylindrical_wrap; 1631 out[2].decl_interp.Location = interpolate_location; 1632 1633 out[3].value = 0; 1634 out[3].decl_semantic.Name = semantic_name; 1635 out[3].decl_semantic.Index = semantic_index; 1636 1637 if (array_id) { 1638 out[4].value = 0; 1639 out[4].array.ArrayID = array_id; 1640 } 1641 } 1642 1643 static void 1644 emit_decl_temps( struct ureg_program *ureg, 1645 unsigned first, unsigned last, 1646 boolean local, 1647 unsigned arrayid ) 1648 { 1649 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 1650 arrayid ? 3 : 2 ); 1651 1652 out[0].value = 0; 1653 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1654 out[0].decl.NrTokens = 2; 1655 out[0].decl.File = TGSI_FILE_TEMPORARY; 1656 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; 1657 out[0].decl.Local = local; 1658 1659 out[1].value = 0; 1660 out[1].decl_range.First = first; 1661 out[1].decl_range.Last = last; 1662 1663 if (arrayid) { 1664 out[0].decl.Array = 1; 1665 out[2].value = 0; 1666 out[2].array.ArrayID = arrayid; 1667 } 1668 } 1669 1670 static void emit_decl_range( struct ureg_program *ureg, 1671 unsigned file, 1672 unsigned first, 1673 unsigned count ) 1674 { 1675 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 ); 1676 1677 out[0].value = 0; 1678 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1679 out[0].decl.NrTokens = 2; 1680 out[0].decl.File = file; 1681 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; 1682 out[0].decl.Semantic = 0; 1683 1684 out[1].value = 0; 1685 out[1].decl_range.First = first; 1686 out[1].decl_range.Last = first + count - 1; 1687 } 1688 1689 static void 1690 emit_decl_range2D(struct ureg_program *ureg, 1691 unsigned file, 1692 unsigned first, 1693 unsigned last, 1694 unsigned index2D) 1695 { 1696 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 3); 1697 1698 out[0].value = 0; 1699 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1700 out[0].decl.NrTokens = 3; 1701 out[0].decl.File = file; 1702 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; 1703 out[0].decl.Dimension = 1; 1704 1705 out[1].value = 0; 1706 out[1].decl_range.First = first; 1707 out[1].decl_range.Last = last; 1708 1709 out[2].value = 0; 1710 out[2].decl_dim.Index2D = index2D; 1711 } 1712 1713 static void 1714 emit_decl_sampler_view(struct ureg_program *ureg, 1715 unsigned index, 1716 unsigned target, 1717 unsigned return_type_x, 1718 unsigned return_type_y, 1719 unsigned return_type_z, 1720 unsigned return_type_w ) 1721 { 1722 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 3); 1723 1724 out[0].value = 0; 1725 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1726 out[0].decl.NrTokens = 3; 1727 out[0].decl.File = TGSI_FILE_SAMPLER_VIEW; 1728 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; 1729 1730 out[1].value = 0; 1731 out[1].decl_range.First = index; 1732 out[1].decl_range.Last = index; 1733 1734 out[2].value = 0; 1735 out[2].decl_sampler_view.Resource = target; 1736 out[2].decl_sampler_view.ReturnTypeX = return_type_x; 1737 out[2].decl_sampler_view.ReturnTypeY = return_type_y; 1738 out[2].decl_sampler_view.ReturnTypeZ = return_type_z; 1739 out[2].decl_sampler_view.ReturnTypeW = return_type_w; 1740 } 1741 1742 static void 1743 emit_decl_image(struct ureg_program *ureg, 1744 unsigned index, 1745 unsigned target, 1746 unsigned format, 1747 boolean wr, 1748 boolean raw) 1749 { 1750 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 3); 1751 1752 out[0].value = 0; 1753 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1754 out[0].decl.NrTokens = 3; 1755 out[0].decl.File = TGSI_FILE_IMAGE; 1756 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; 1757 1758 out[1].value = 0; 1759 out[1].decl_range.First = index; 1760 out[1].decl_range.Last = index; 1761 1762 out[2].value = 0; 1763 out[2].decl_image.Resource = target; 1764 out[2].decl_image.Writable = wr; 1765 out[2].decl_image.Raw = raw; 1766 out[2].decl_image.Format = format; 1767 } 1768 1769 static void 1770 emit_decl_buffer(struct ureg_program *ureg, 1771 unsigned index, 1772 bool atomic) 1773 { 1774 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 2); 1775 1776 out[0].value = 0; 1777 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1778 out[0].decl.NrTokens = 2; 1779 out[0].decl.File = TGSI_FILE_BUFFER; 1780 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; 1781 out[0].decl.Atomic = atomic; 1782 1783 out[1].value = 0; 1784 out[1].decl_range.First = index; 1785 out[1].decl_range.Last = index; 1786 } 1787 1788 static void 1789 emit_decl_memory(struct ureg_program *ureg, unsigned memory_type) 1790 { 1791 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 2); 1792 1793 out[0].value = 0; 1794 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1795 out[0].decl.NrTokens = 2; 1796 out[0].decl.File = TGSI_FILE_MEMORY; 1797 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; 1798 out[0].decl.MemType = memory_type; 1799 1800 out[1].value = 0; 1801 out[1].decl_range.First = memory_type; 1802 out[1].decl_range.Last = memory_type; 1803 } 1804 1805 static void 1806 emit_immediate( struct ureg_program *ureg, 1807 const unsigned *v, 1808 unsigned type ) 1809 { 1810 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 5 ); 1811 1812 out[0].value = 0; 1813 out[0].imm.Type = TGSI_TOKEN_TYPE_IMMEDIATE; 1814 out[0].imm.NrTokens = 5; 1815 out[0].imm.DataType = type; 1816 out[0].imm.Padding = 0; 1817 1818 out[1].imm_data.Uint = v[0]; 1819 out[2].imm_data.Uint = v[1]; 1820 out[3].imm_data.Uint = v[2]; 1821 out[4].imm_data.Uint = v[3]; 1822 } 1823 1824 static void 1825 emit_property(struct ureg_program *ureg, 1826 unsigned name, 1827 unsigned data) 1828 { 1829 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 2); 1830 1831 out[0].value = 0; 1832 out[0].prop.Type = TGSI_TOKEN_TYPE_PROPERTY; 1833 out[0].prop.NrTokens = 2; 1834 out[0].prop.PropertyName = name; 1835 1836 out[1].prop_data.Data = data; 1837 } 1838 1839 1840 static void emit_decls( struct ureg_program *ureg ) 1841 { 1842 unsigned i,j; 1843 1844 for (i = 0; i < ARRAY_SIZE(ureg->properties); i++) 1845 if (ureg->properties[i] != ~0) 1846 emit_property(ureg, i, ureg->properties[i]); 1847 1848 if (ureg->processor == PIPE_SHADER_VERTEX) { 1849 for (i = 0; i < PIPE_MAX_ATTRIBS; i++) { 1850 if (ureg->vs_inputs[i/32] & (1u << (i%32))) { 1851 emit_decl_range( ureg, TGSI_FILE_INPUT, i, 1 ); 1852 } 1853 } 1854 } else if (ureg->processor == PIPE_SHADER_FRAGMENT) { 1855 if (ureg->supports_any_inout_decl_range) { 1856 for (i = 0; i < ureg->nr_inputs; i++) { 1857 emit_decl_fs(ureg, 1858 TGSI_FILE_INPUT, 1859 ureg->input[i].first, 1860 ureg->input[i].last, 1861 ureg->input[i].semantic_name, 1862 ureg->input[i].semantic_index, 1863 ureg->input[i].interp, 1864 ureg->input[i].cylindrical_wrap, 1865 ureg->input[i].interp_location, 1866 ureg->input[i].array_id, 1867 ureg->input[i].usage_mask); 1868 } 1869 } 1870 else { 1871 for (i = 0; i < ureg->nr_inputs; i++) { 1872 for (j = ureg->input[i].first; j <= ureg->input[i].last; j++) { 1873 emit_decl_fs(ureg, 1874 TGSI_FILE_INPUT, 1875 j, j, 1876 ureg->input[i].semantic_name, 1877 ureg->input[i].semantic_index + 1878 (j - ureg->input[i].first), 1879 ureg->input[i].interp, 1880 ureg->input[i].cylindrical_wrap, 1881 ureg->input[i].interp_location, 0, 1882 ureg->input[i].usage_mask); 1883 } 1884 } 1885 } 1886 } else { 1887 if (ureg->supports_any_inout_decl_range) { 1888 for (i = 0; i < ureg->nr_inputs; i++) { 1889 emit_decl_semantic(ureg, 1890 TGSI_FILE_INPUT, 1891 ureg->input[i].first, 1892 ureg->input[i].last, 1893 ureg->input[i].semantic_name, 1894 ureg->input[i].semantic_index, 1895 0, 1896 TGSI_WRITEMASK_XYZW, 1897 ureg->input[i].array_id); 1898 } 1899 } 1900 else { 1901 for (i = 0; i < ureg->nr_inputs; i++) { 1902 for (j = ureg->input[i].first; j <= ureg->input[i].last; j++) { 1903 emit_decl_semantic(ureg, 1904 TGSI_FILE_INPUT, 1905 j, j, 1906 ureg->input[i].semantic_name, 1907 ureg->input[i].semantic_index + 1908 (j - ureg->input[i].first), 1909 0, 1910 TGSI_WRITEMASK_XYZW, 0); 1911 } 1912 } 1913 } 1914 } 1915 1916 for (i = 0; i < ureg->nr_system_values; i++) { 1917 emit_decl_semantic(ureg, 1918 TGSI_FILE_SYSTEM_VALUE, 1919 i, 1920 i, 1921 ureg->system_value[i].semantic_name, 1922 ureg->system_value[i].semantic_index, 1923 0, 1924 TGSI_WRITEMASK_XYZW, 0); 1925 } 1926 1927 if (ureg->supports_any_inout_decl_range) { 1928 for (i = 0; i < ureg->nr_outputs; i++) { 1929 emit_decl_semantic(ureg, 1930 TGSI_FILE_OUTPUT, 1931 ureg->output[i].first, 1932 ureg->output[i].last, 1933 ureg->output[i].semantic_name, 1934 ureg->output[i].semantic_index, 1935 ureg->output[i].streams, 1936 ureg->output[i].usage_mask, 1937 ureg->output[i].array_id); 1938 } 1939 } 1940 else { 1941 for (i = 0; i < ureg->nr_outputs; i++) { 1942 for (j = ureg->output[i].first; j <= ureg->output[i].last; j++) { 1943 emit_decl_semantic(ureg, 1944 TGSI_FILE_OUTPUT, 1945 j, j, 1946 ureg->output[i].semantic_name, 1947 ureg->output[i].semantic_index + 1948 (j - ureg->output[i].first), 1949 ureg->output[i].streams, 1950 ureg->output[i].usage_mask, 0); 1951 } 1952 } 1953 } 1954 1955 for (i = 0; i < ureg->nr_samplers; i++) { 1956 emit_decl_range( ureg, 1957 TGSI_FILE_SAMPLER, 1958 ureg->sampler[i].Index, 1 ); 1959 } 1960 1961 for (i = 0; i < ureg->nr_sampler_views; i++) { 1962 emit_decl_sampler_view(ureg, 1963 ureg->sampler_view[i].index, 1964 ureg->sampler_view[i].target, 1965 ureg->sampler_view[i].return_type_x, 1966 ureg->sampler_view[i].return_type_y, 1967 ureg->sampler_view[i].return_type_z, 1968 ureg->sampler_view[i].return_type_w); 1969 } 1970 1971 for (i = 0; i < ureg->nr_images; i++) { 1972 emit_decl_image(ureg, 1973 ureg->image[i].index, 1974 ureg->image[i].target, 1975 ureg->image[i].format, 1976 ureg->image[i].wr, 1977 ureg->image[i].raw); 1978 } 1979 1980 for (i = 0; i < ureg->nr_buffers; i++) { 1981 emit_decl_buffer(ureg, ureg->buffer[i].index, ureg->buffer[i].atomic); 1982 } 1983 1984 for (i = 0; i < TGSI_MEMORY_TYPE_COUNT; i++) { 1985 if (ureg->use_memory[i]) 1986 emit_decl_memory(ureg, i); 1987 } 1988 1989 if (ureg->const_decls.nr_constant_ranges) { 1990 for (i = 0; i < ureg->const_decls.nr_constant_ranges; i++) { 1991 emit_decl_range(ureg, 1992 TGSI_FILE_CONSTANT, 1993 ureg->const_decls.constant_range[i].first, 1994 ureg->const_decls.constant_range[i].last - ureg->const_decls.constant_range[i].first + 1); 1995 } 1996 } 1997 1998 for (i = 0; i < PIPE_MAX_CONSTANT_BUFFERS; i++) { 1999 struct const_decl *decl = &ureg->const_decls2D[i]; 2000 2001 if (decl->nr_constant_ranges) { 2002 uint j; 2003 2004 for (j = 0; j < decl->nr_constant_ranges; j++) { 2005 emit_decl_range2D(ureg, 2006 TGSI_FILE_CONSTANT, 2007 decl->constant_range[j].first, 2008 decl->constant_range[j].last, 2009 i); 2010 } 2011 } 2012 } 2013 2014 if (ureg->nr_temps) { 2015 unsigned array = 0; 2016 for (i = 0; i < ureg->nr_temps;) { 2017 boolean local = util_bitmask_get(ureg->local_temps, i); 2018 unsigned first = i; 2019 i = util_bitmask_get_next_index(ureg->decl_temps, i + 1); 2020 if (i == UTIL_BITMASK_INVALID_INDEX) 2021 i = ureg->nr_temps; 2022 2023 if (array < ureg->nr_array_temps && ureg->array_temps[array] == first) 2024 emit_decl_temps( ureg, first, i - 1, local, ++array ); 2025 else 2026 emit_decl_temps( ureg, first, i - 1, local, 0 ); 2027 } 2028 } 2029 2030 if (ureg->nr_addrs) { 2031 emit_decl_range( ureg, 2032 TGSI_FILE_ADDRESS, 2033 0, ureg->nr_addrs ); 2034 } 2035 2036 if (ureg->nr_preds) { 2037 emit_decl_range(ureg, 2038 TGSI_FILE_PREDICATE, 2039 0, 2040 ureg->nr_preds); 2041 } 2042 2043 for (i = 0; i < ureg->nr_immediates; i++) { 2044 emit_immediate( ureg, 2045 ureg->immediate[i].value.u, 2046 ureg->immediate[i].type ); 2047 } 2048 } 2049 2050 /* Append the instruction tokens onto the declarations to build a 2051 * contiguous stream suitable to send to the driver. 2052 */ 2053 static void copy_instructions( struct ureg_program *ureg ) 2054 { 2055 unsigned nr_tokens = ureg->domain[DOMAIN_INSN].count; 2056 union tgsi_any_token *out = get_tokens( ureg, 2057 DOMAIN_DECL, 2058 nr_tokens ); 2059 2060 memcpy(out, 2061 ureg->domain[DOMAIN_INSN].tokens, 2062 nr_tokens * sizeof out[0] ); 2063 } 2064 2065 2066 static void 2067 fixup_header_size(struct ureg_program *ureg) 2068 { 2069 union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_DECL, 0 ); 2070 2071 out->header.BodySize = ureg->domain[DOMAIN_DECL].count - 2; 2072 } 2073 2074 2075 static void 2076 emit_header( struct ureg_program *ureg ) 2077 { 2078 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 ); 2079 2080 out[0].header.HeaderSize = 2; 2081 out[0].header.BodySize = 0; 2082 2083 out[1].processor.Processor = ureg->processor; 2084 out[1].processor.Padding = 0; 2085 } 2086 2087 2088 const struct tgsi_token *ureg_finalize( struct ureg_program *ureg ) 2089 { 2090 const struct tgsi_token *tokens; 2091 2092 switch (ureg->processor) { 2093 case PIPE_SHADER_VERTEX: 2094 case PIPE_SHADER_TESS_EVAL: 2095 ureg_property(ureg, TGSI_PROPERTY_NEXT_SHADER, 2096 ureg->next_shader_processor == -1 ? 2097 PIPE_SHADER_FRAGMENT : 2098 ureg->next_shader_processor); 2099 break; 2100 } 2101 2102 emit_header( ureg ); 2103 emit_decls( ureg ); 2104 copy_instructions( ureg ); 2105 fixup_header_size( ureg ); 2106 2107 if (ureg->domain[0].tokens == error_tokens || 2108 ureg->domain[1].tokens == error_tokens) { 2109 debug_printf("%s: error in generated shader\n", __FUNCTION__); 2110 assert(0); 2111 return NULL; 2112 } 2113 2114 tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token; 2115 2116 if (0) { 2117 debug_printf("%s: emitted shader %d tokens:\n", __FUNCTION__, 2118 ureg->domain[DOMAIN_DECL].count); 2119 tgsi_dump( tokens, 0 ); 2120 } 2121 2122 #if DEBUG 2123 if (tokens && !tgsi_sanity_check(tokens)) { 2124 debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n"); 2125 tgsi_dump(tokens, 0); 2126 assert(0); 2127 } 2128 #endif 2129 2130 2131 return tokens; 2132 } 2133 2134 2135 void *ureg_create_shader( struct ureg_program *ureg, 2136 struct pipe_context *pipe, 2137 const struct pipe_stream_output_info *so ) 2138 { 2139 struct pipe_shader_state state; 2140 2141 pipe_shader_state_from_tgsi(&state, ureg_finalize(ureg)); 2142 if(!state.tokens) 2143 return NULL; 2144 2145 if (so) 2146 state.stream_output = *so; 2147 2148 switch (ureg->processor) { 2149 case PIPE_SHADER_VERTEX: 2150 return pipe->create_vs_state(pipe, &state); 2151 case PIPE_SHADER_TESS_CTRL: 2152 return pipe->create_tcs_state(pipe, &state); 2153 case PIPE_SHADER_TESS_EVAL: 2154 return pipe->create_tes_state(pipe, &state); 2155 case PIPE_SHADER_GEOMETRY: 2156 return pipe->create_gs_state(pipe, &state); 2157 case PIPE_SHADER_FRAGMENT: 2158 return pipe->create_fs_state(pipe, &state); 2159 default: 2160 return NULL; 2161 } 2162 } 2163 2164 2165 const struct tgsi_token *ureg_get_tokens( struct ureg_program *ureg, 2166 unsigned *nr_tokens ) 2167 { 2168 const struct tgsi_token *tokens; 2169 2170 ureg_finalize(ureg); 2171 2172 tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token; 2173 2174 if (nr_tokens) 2175 *nr_tokens = ureg->domain[DOMAIN_DECL].size; 2176 2177 ureg->domain[DOMAIN_DECL].tokens = 0; 2178 ureg->domain[DOMAIN_DECL].size = 0; 2179 ureg->domain[DOMAIN_DECL].order = 0; 2180 ureg->domain[DOMAIN_DECL].count = 0; 2181 2182 return tokens; 2183 } 2184 2185 2186 void ureg_free_tokens( const struct tgsi_token *tokens ) 2187 { 2188 FREE((struct tgsi_token *)tokens); 2189 } 2190 2191 2192 struct ureg_program * 2193 ureg_create(unsigned processor) 2194 { 2195 return ureg_create_with_screen(processor, NULL); 2196 } 2197 2198 2199 struct ureg_program * 2200 ureg_create_with_screen(unsigned processor, struct pipe_screen *screen) 2201 { 2202 int i; 2203 struct ureg_program *ureg = CALLOC_STRUCT( ureg_program ); 2204 if (!ureg) 2205 goto no_ureg; 2206 2207 ureg->processor = processor; 2208 ureg->supports_any_inout_decl_range = 2209 screen && 2210 screen->get_shader_param(screen, processor, 2211 PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE) != 0; 2212 ureg->next_shader_processor = -1; 2213 2214 for (i = 0; i < ARRAY_SIZE(ureg->properties); i++) 2215 ureg->properties[i] = ~0; 2216 2217 ureg->free_temps = util_bitmask_create(); 2218 if (ureg->free_temps == NULL) 2219 goto no_free_temps; 2220 2221 ureg->local_temps = util_bitmask_create(); 2222 if (ureg->local_temps == NULL) 2223 goto no_local_temps; 2224 2225 ureg->decl_temps = util_bitmask_create(); 2226 if (ureg->decl_temps == NULL) 2227 goto no_decl_temps; 2228 2229 return ureg; 2230 2231 no_decl_temps: 2232 util_bitmask_destroy(ureg->local_temps); 2233 no_local_temps: 2234 util_bitmask_destroy(ureg->free_temps); 2235 no_free_temps: 2236 FREE(ureg); 2237 no_ureg: 2238 return NULL; 2239 } 2240 2241 2242 void 2243 ureg_set_next_shader_processor(struct ureg_program *ureg, unsigned processor) 2244 { 2245 ureg->next_shader_processor = processor; 2246 } 2247 2248 2249 unsigned 2250 ureg_get_nr_outputs( const struct ureg_program *ureg ) 2251 { 2252 if (!ureg) 2253 return 0; 2254 return ureg->nr_outputs; 2255 } 2256 2257 2258 void ureg_destroy( struct ureg_program *ureg ) 2259 { 2260 unsigned i; 2261 2262 for (i = 0; i < ARRAY_SIZE(ureg->domain); i++) { 2263 if (ureg->domain[i].tokens && 2264 ureg->domain[i].tokens != error_tokens) 2265 FREE(ureg->domain[i].tokens); 2266 } 2267 2268 util_bitmask_destroy(ureg->free_temps); 2269 util_bitmask_destroy(ureg->local_temps); 2270 util_bitmask_destroy(ureg->decl_temps); 2271 2272 FREE(ureg); 2273 } 2274
