tgsi_ureg.c revision 463351ea6c953c3db7f135ba97160a212562daef
1/************************************************************************** 2 * 3 * Copyright 2009 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_context.h" 30#include "pipe/p_state.h" 31#include "tgsi/tgsi_ureg.h" 32#include "tgsi/tgsi_build.h" 33#include "tgsi/tgsi_info.h" 34#include "tgsi/tgsi_dump.h" 35#include "tgsi/tgsi_sanity.h" 36#include "util/u_memory.h" 37#include "util/u_math.h" 38 39union tgsi_any_token { 40 struct tgsi_header header; 41 struct tgsi_processor processor; 42 struct tgsi_token token; 43 struct tgsi_property prop; 44 struct tgsi_property_data prop_data; 45 struct tgsi_declaration decl; 46 struct tgsi_declaration_range decl_range; 47 struct tgsi_declaration_semantic decl_semantic; 48 struct tgsi_immediate imm; 49 union tgsi_immediate_data imm_data; 50 struct tgsi_instruction insn; 51 struct tgsi_instruction_predicate insn_predicate; 52 struct tgsi_instruction_label insn_label; 53 struct tgsi_instruction_texture insn_texture; 54 struct tgsi_src_register src; 55 struct tgsi_dimension dim; 56 struct tgsi_dst_register dst; 57 unsigned value; 58}; 59 60 61struct ureg_tokens { 62 union tgsi_any_token *tokens; 63 unsigned size; 64 unsigned order; 65 unsigned count; 66}; 67 68#define UREG_MAX_INPUT PIPE_MAX_ATTRIBS 69#define UREG_MAX_SYSTEM_VALUE PIPE_MAX_ATTRIBS 70#define UREG_MAX_OUTPUT PIPE_MAX_ATTRIBS 71#define UREG_MAX_CONSTANT_RANGE 32 72#define UREG_MAX_IMMEDIATE 32 73#define UREG_MAX_TEMP 256 74#define UREG_MAX_ADDR 2 75#define UREG_MAX_LOOP 1 76#define UREG_MAX_PRED 1 77 78#define DOMAIN_DECL 0 79#define DOMAIN_INSN 1 80 81struct ureg_program 82{ 83 unsigned processor; 84 struct pipe_context *pipe; 85 86 struct { 87 unsigned semantic_name; 88 unsigned semantic_index; 89 unsigned interp; 90 } fs_input[UREG_MAX_INPUT]; 91 unsigned nr_fs_inputs; 92 93 unsigned vs_inputs[UREG_MAX_INPUT/32]; 94 95 struct { 96 unsigned index; 97 } gs_input[UREG_MAX_INPUT]; 98 unsigned nr_gs_inputs; 99 100 struct { 101 unsigned index; 102 unsigned semantic_name; 103 unsigned semantic_index; 104 } system_value[UREG_MAX_SYSTEM_VALUE]; 105 unsigned nr_system_values; 106 107 struct { 108 unsigned semantic_name; 109 unsigned semantic_index; 110 } output[UREG_MAX_OUTPUT]; 111 unsigned nr_outputs; 112 113 struct { 114 union { 115 float f[4]; 116 unsigned u[4]; 117 int i[4]; 118 } value; 119 unsigned nr; 120 unsigned type; 121 } immediate[UREG_MAX_IMMEDIATE]; 122 unsigned nr_immediates; 123 124 struct ureg_src sampler[PIPE_MAX_SAMPLERS]; 125 unsigned nr_samplers; 126 127 unsigned temps_active[UREG_MAX_TEMP / 32]; 128 unsigned nr_temps; 129 130 struct { 131 unsigned first; 132 unsigned last; 133 } constant_range[UREG_MAX_CONSTANT_RANGE]; 134 unsigned nr_constant_ranges; 135 136 unsigned property_gs_input_prim; 137 138 unsigned nr_addrs; 139 unsigned nr_preds; 140 unsigned nr_loops; 141 unsigned nr_instructions; 142 143 struct ureg_tokens domain[2]; 144}; 145 146static union tgsi_any_token error_tokens[32]; 147 148static void tokens_error( struct ureg_tokens *tokens ) 149{ 150 if (tokens->tokens && tokens->tokens != error_tokens) 151 FREE(tokens->tokens); 152 153 tokens->tokens = error_tokens; 154 tokens->size = Elements(error_tokens); 155 tokens->count = 0; 156} 157 158 159static void tokens_expand( struct ureg_tokens *tokens, 160 unsigned count ) 161{ 162 unsigned old_size = tokens->size * sizeof(unsigned); 163 164 if (tokens->tokens == error_tokens) { 165 return; 166 } 167 168 while (tokens->count + count > tokens->size) { 169 tokens->size = (1 << ++tokens->order); 170 } 171 172 tokens->tokens = REALLOC(tokens->tokens, 173 old_size, 174 tokens->size * sizeof(unsigned)); 175 if (tokens->tokens == NULL) { 176 tokens_error(tokens); 177 } 178} 179 180static void set_bad( struct ureg_program *ureg ) 181{ 182 tokens_error(&ureg->domain[0]); 183} 184 185 186 187static union tgsi_any_token *get_tokens( struct ureg_program *ureg, 188 unsigned domain, 189 unsigned count ) 190{ 191 struct ureg_tokens *tokens = &ureg->domain[domain]; 192 union tgsi_any_token *result; 193 194 if (tokens->count + count > tokens->size) 195 tokens_expand(tokens, count); 196 197 result = &tokens->tokens[tokens->count]; 198 tokens->count += count; 199 return result; 200} 201 202 203static union tgsi_any_token *retrieve_token( struct ureg_program *ureg, 204 unsigned domain, 205 unsigned nr ) 206{ 207 if (ureg->domain[domain].tokens == error_tokens) 208 return &error_tokens[0]; 209 210 return &ureg->domain[domain].tokens[nr]; 211} 212 213 214 215static INLINE struct ureg_dst 216ureg_dst_register( unsigned file, 217 unsigned index ) 218{ 219 struct ureg_dst dst; 220 221 dst.File = file; 222 dst.WriteMask = TGSI_WRITEMASK_XYZW; 223 dst.Indirect = 0; 224 dst.IndirectIndex = 0; 225 dst.IndirectSwizzle = 0; 226 dst.Saturate = 0; 227 dst.Predicate = 0; 228 dst.PredNegate = 0; 229 dst.PredSwizzleX = TGSI_SWIZZLE_X; 230 dst.PredSwizzleY = TGSI_SWIZZLE_Y; 231 dst.PredSwizzleZ = TGSI_SWIZZLE_Z; 232 dst.PredSwizzleW = TGSI_SWIZZLE_W; 233 dst.Index = index; 234 235 return dst; 236} 237 238static INLINE struct ureg_src 239ureg_src_register( unsigned file, 240 unsigned index ) 241{ 242 struct ureg_src src; 243 244 src.File = file; 245 src.SwizzleX = TGSI_SWIZZLE_X; 246 src.SwizzleY = TGSI_SWIZZLE_Y; 247 src.SwizzleZ = TGSI_SWIZZLE_Z; 248 src.SwizzleW = TGSI_SWIZZLE_W; 249 src.Indirect = 0; 250 src.IndirectFile = TGSI_FILE_NULL; 251 src.IndirectIndex = 0; 252 src.IndirectSwizzle = 0; 253 src.Absolute = 0; 254 src.Index = index; 255 src.Negate = 0; 256 src.Dimension = 0; 257 src.DimensionIndex = 0; 258 259 return src; 260} 261 262 263 264void 265ureg_property_gs_input_prim(struct ureg_program *ureg, 266 unsigned gs_input_prim) 267{ 268 ureg->property_gs_input_prim = gs_input_prim; 269} 270 271 272 273struct ureg_src 274ureg_DECL_fs_input( struct ureg_program *ureg, 275 unsigned name, 276 unsigned index, 277 unsigned interp_mode ) 278{ 279 unsigned i; 280 281 for (i = 0; i < ureg->nr_fs_inputs; i++) { 282 if (ureg->fs_input[i].semantic_name == name && 283 ureg->fs_input[i].semantic_index == index) 284 goto out; 285 } 286 287 if (ureg->nr_fs_inputs < UREG_MAX_INPUT) { 288 ureg->fs_input[i].semantic_name = name; 289 ureg->fs_input[i].semantic_index = index; 290 ureg->fs_input[i].interp = interp_mode; 291 ureg->nr_fs_inputs++; 292 } 293 else { 294 set_bad( ureg ); 295 } 296 297out: 298 return ureg_src_register( TGSI_FILE_INPUT, i ); 299} 300 301 302struct ureg_src 303ureg_DECL_vs_input( struct ureg_program *ureg, 304 unsigned index ) 305{ 306 assert(ureg->processor == TGSI_PROCESSOR_VERTEX); 307 308 ureg->vs_inputs[index/32] |= 1 << (index % 32); 309 return ureg_src_register( TGSI_FILE_INPUT, index ); 310} 311 312 313struct ureg_src 314ureg_DECL_gs_input(struct ureg_program *ureg, 315 unsigned index) 316{ 317 if (ureg->nr_gs_inputs < UREG_MAX_INPUT) { 318 ureg->gs_input[ureg->nr_gs_inputs].index = index; 319 ureg->nr_gs_inputs++; 320 } else { 321 set_bad(ureg); 322 } 323 324 /* XXX: Add suport for true 2D input registers. */ 325 return ureg_src_register(TGSI_FILE_INPUT, index); 326} 327 328 329struct ureg_src 330ureg_DECL_system_value(struct ureg_program *ureg, 331 unsigned index, 332 unsigned semantic_name, 333 unsigned semantic_index) 334{ 335 if (ureg->nr_system_values < UREG_MAX_SYSTEM_VALUE) { 336 ureg->system_value[ureg->nr_system_values].index = index; 337 ureg->system_value[ureg->nr_system_values].semantic_name = semantic_name; 338 ureg->system_value[ureg->nr_system_values].semantic_index = semantic_index; 339 ureg->nr_system_values++; 340 } else { 341 set_bad(ureg); 342 } 343 344 return ureg_src_register(TGSI_FILE_SYSTEM_VALUE, index); 345} 346 347 348struct ureg_dst 349ureg_DECL_output( struct ureg_program *ureg, 350 unsigned name, 351 unsigned index ) 352{ 353 unsigned i; 354 355 for (i = 0; i < ureg->nr_outputs; i++) { 356 if (ureg->output[i].semantic_name == name && 357 ureg->output[i].semantic_index == index) 358 goto out; 359 } 360 361 if (ureg->nr_outputs < UREG_MAX_OUTPUT) { 362 ureg->output[i].semantic_name = name; 363 ureg->output[i].semantic_index = index; 364 ureg->nr_outputs++; 365 } 366 else { 367 set_bad( ureg ); 368 } 369 370out: 371 return ureg_dst_register( TGSI_FILE_OUTPUT, i ); 372} 373 374 375/* Returns a new constant register. Keep track of which have been 376 * referred to so that we can emit decls later. 377 * 378 * There is nothing in this code to bind this constant to any tracked 379 * value or manage any constant_buffer contents -- that's the 380 * resposibility of the calling code. 381 */ 382struct ureg_src ureg_DECL_constant(struct ureg_program *ureg, 383 unsigned index ) 384{ 385 unsigned minconst = index, maxconst = index; 386 unsigned i; 387 388 /* Inside existing range? 389 */ 390 for (i = 0; i < ureg->nr_constant_ranges; i++) { 391 if (ureg->constant_range[i].first <= index && 392 ureg->constant_range[i].last >= index) 393 goto out; 394 } 395 396 /* Extend existing range? 397 */ 398 for (i = 0; i < ureg->nr_constant_ranges; i++) { 399 if (ureg->constant_range[i].last == index - 1) { 400 ureg->constant_range[i].last = index; 401 goto out; 402 } 403 404 if (ureg->constant_range[i].first == index + 1) { 405 ureg->constant_range[i].first = index; 406 goto out; 407 } 408 409 minconst = MIN2(minconst, ureg->constant_range[i].first); 410 maxconst = MAX2(maxconst, ureg->constant_range[i].last); 411 } 412 413 /* Create new range? 414 */ 415 if (ureg->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) { 416 i = ureg->nr_constant_ranges++; 417 ureg->constant_range[i].first = index; 418 ureg->constant_range[i].last = index; 419 goto out; 420 } 421 422 /* Collapse all ranges down to one: 423 */ 424 i = 0; 425 ureg->constant_range[0].first = minconst; 426 ureg->constant_range[0].last = maxconst; 427 ureg->nr_constant_ranges = 1; 428 429out: 430 assert(i < ureg->nr_constant_ranges); 431 assert(ureg->constant_range[i].first <= index); 432 assert(ureg->constant_range[i].last >= index); 433 return ureg_src_register( TGSI_FILE_CONSTANT, index ); 434} 435 436 437/* Allocate a new temporary. Temporaries greater than UREG_MAX_TEMP 438 * are legal, but will not be released. 439 */ 440struct ureg_dst ureg_DECL_temporary( struct ureg_program *ureg ) 441{ 442 unsigned i; 443 444 for (i = 0; i < UREG_MAX_TEMP; i += 32) { 445 int bit = ffs(~ureg->temps_active[i/32]); 446 if (bit != 0) { 447 i += bit - 1; 448 goto out; 449 } 450 } 451 452 /* No reusable temps, so allocate a new one: 453 */ 454 i = ureg->nr_temps++; 455 456out: 457 if (i < UREG_MAX_TEMP) 458 ureg->temps_active[i/32] |= 1 << (i % 32); 459 460 if (i >= ureg->nr_temps) 461 ureg->nr_temps = i + 1; 462 463 return ureg_dst_register( TGSI_FILE_TEMPORARY, i ); 464} 465 466 467void ureg_release_temporary( struct ureg_program *ureg, 468 struct ureg_dst tmp ) 469{ 470 if(tmp.File == TGSI_FILE_TEMPORARY) 471 if (tmp.Index < UREG_MAX_TEMP) 472 ureg->temps_active[tmp.Index/32] &= ~(1 << (tmp.Index % 32)); 473} 474 475 476/* Allocate a new address register. 477 */ 478struct ureg_dst ureg_DECL_address( struct ureg_program *ureg ) 479{ 480 if (ureg->nr_addrs < UREG_MAX_ADDR) 481 return ureg_dst_register( TGSI_FILE_ADDRESS, ureg->nr_addrs++ ); 482 483 assert( 0 ); 484 return ureg_dst_register( TGSI_FILE_ADDRESS, 0 ); 485} 486 487/* Allocate a new loop register. 488 */ 489struct ureg_dst 490ureg_DECL_loop(struct ureg_program *ureg) 491{ 492 if (ureg->nr_loops < UREG_MAX_LOOP) { 493 return ureg_dst_register(TGSI_FILE_LOOP, ureg->nr_loops++); 494 } 495 496 assert(0); 497 return ureg_dst_register(TGSI_FILE_LOOP, 0); 498} 499 500/* Allocate a new predicate register. 501 */ 502struct ureg_dst 503ureg_DECL_predicate(struct ureg_program *ureg) 504{ 505 if (ureg->nr_preds < UREG_MAX_PRED) { 506 return ureg_dst_register(TGSI_FILE_PREDICATE, ureg->nr_preds++); 507 } 508 509 assert(0); 510 return ureg_dst_register(TGSI_FILE_PREDICATE, 0); 511} 512 513/* Allocate a new sampler. 514 */ 515struct ureg_src ureg_DECL_sampler( struct ureg_program *ureg, 516 unsigned nr ) 517{ 518 unsigned i; 519 520 for (i = 0; i < ureg->nr_samplers; i++) 521 if (ureg->sampler[i].Index == nr) 522 return ureg->sampler[i]; 523 524 if (i < PIPE_MAX_SAMPLERS) { 525 ureg->sampler[i] = ureg_src_register( TGSI_FILE_SAMPLER, nr ); 526 ureg->nr_samplers++; 527 return ureg->sampler[i]; 528 } 529 530 assert( 0 ); 531 return ureg->sampler[0]; 532} 533 534 535static int 536match_or_expand_immediate( const unsigned *v, 537 unsigned nr, 538 unsigned *v2, 539 unsigned *pnr2, 540 unsigned *swizzle ) 541{ 542 unsigned nr2 = *pnr2; 543 unsigned i, j; 544 545 *swizzle = 0; 546 547 for (i = 0; i < nr; i++) { 548 boolean found = FALSE; 549 550 for (j = 0; j < nr2 && !found; j++) { 551 if (v[i] == v2[j]) { 552 *swizzle |= j << (i * 2); 553 found = TRUE; 554 } 555 } 556 557 if (!found) { 558 if (nr2 >= 4) { 559 return FALSE; 560 } 561 562 v2[nr2] = v[i]; 563 *swizzle |= nr2 << (i * 2); 564 nr2++; 565 } 566 } 567 568 /* Actually expand immediate only when fully succeeded. 569 */ 570 *pnr2 = nr2; 571 return TRUE; 572} 573 574 575static struct ureg_src 576decl_immediate( struct ureg_program *ureg, 577 const unsigned *v, 578 unsigned nr, 579 unsigned type ) 580{ 581 unsigned i, j; 582 unsigned swizzle; 583 584 /* Could do a first pass where we examine all existing immediates 585 * without expanding. 586 */ 587 588 for (i = 0; i < ureg->nr_immediates; i++) { 589 if (ureg->immediate[i].type != type) { 590 continue; 591 } 592 if (match_or_expand_immediate(v, 593 nr, 594 ureg->immediate[i].value.u, 595 &ureg->immediate[i].nr, 596 &swizzle)) { 597 goto out; 598 } 599 } 600 601 if (ureg->nr_immediates < UREG_MAX_IMMEDIATE) { 602 i = ureg->nr_immediates++; 603 ureg->immediate[i].type = type; 604 if (match_or_expand_immediate(v, 605 nr, 606 ureg->immediate[i].value.u, 607 &ureg->immediate[i].nr, 608 &swizzle)) { 609 goto out; 610 } 611 } 612 613 set_bad(ureg); 614 615out: 616 /* Make sure that all referenced elements are from this immediate. 617 * Has the effect of making size-one immediates into scalars. 618 */ 619 for (j = nr; j < 4; j++) { 620 swizzle |= (swizzle & 0x3) << (j * 2); 621 } 622 623 return ureg_swizzle(ureg_src_register(TGSI_FILE_IMMEDIATE, i), 624 (swizzle >> 0) & 0x3, 625 (swizzle >> 2) & 0x3, 626 (swizzle >> 4) & 0x3, 627 (swizzle >> 6) & 0x3); 628} 629 630 631struct ureg_src 632ureg_DECL_immediate( struct ureg_program *ureg, 633 const float *v, 634 unsigned nr ) 635{ 636 union { 637 float f[4]; 638 unsigned u[4]; 639 } fu; 640 unsigned int i; 641 642 for (i = 0; i < nr; i++) { 643 fu.f[i] = v[i]; 644 } 645 646 return decl_immediate(ureg, fu.u, nr, TGSI_IMM_FLOAT32); 647} 648 649 650struct ureg_src 651ureg_DECL_immediate_uint( struct ureg_program *ureg, 652 const unsigned *v, 653 unsigned nr ) 654{ 655 return decl_immediate(ureg, v, nr, TGSI_IMM_UINT32); 656} 657 658 659struct ureg_src 660ureg_DECL_immediate_block_uint( struct ureg_program *ureg, 661 const unsigned *v, 662 unsigned nr ) 663{ 664 uint index; 665 uint i; 666 667 if (ureg->nr_immediates + (nr + 3) / 4 > UREG_MAX_IMMEDIATE) { 668 set_bad(ureg); 669 return ureg_src_register(TGSI_FILE_IMMEDIATE, 0); 670 } 671 672 index = ureg->nr_immediates; 673 ureg->nr_immediates += (nr + 3) / 4; 674 675 for (i = index; i < ureg->nr_immediates; i++) { 676 ureg->immediate[i].type = TGSI_IMM_UINT32; 677 ureg->immediate[i].nr = nr > 4 ? 4 : nr; 678 memcpy(ureg->immediate[i].value.u, 679 &v[(i - index) * 4], 680 ureg->immediate[i].nr * sizeof(uint)); 681 nr -= 4; 682 } 683 684 return ureg_src_register(TGSI_FILE_IMMEDIATE, index); 685} 686 687 688struct ureg_src 689ureg_DECL_immediate_int( struct ureg_program *ureg, 690 const int *v, 691 unsigned nr ) 692{ 693 return decl_immediate(ureg, (const unsigned *)v, nr, TGSI_IMM_INT32); 694} 695 696 697void 698ureg_emit_src( struct ureg_program *ureg, 699 struct ureg_src src ) 700{ 701 unsigned size = 1 + (src.Indirect ? 1 : 0) + (src.Dimension ? 1 : 0); 702 703 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size ); 704 unsigned n = 0; 705 706 assert(src.File != TGSI_FILE_NULL); 707 assert(src.File != TGSI_FILE_OUTPUT); 708 assert(src.File < TGSI_FILE_COUNT); 709 710 out[n].value = 0; 711 out[n].src.File = src.File; 712 out[n].src.SwizzleX = src.SwizzleX; 713 out[n].src.SwizzleY = src.SwizzleY; 714 out[n].src.SwizzleZ = src.SwizzleZ; 715 out[n].src.SwizzleW = src.SwizzleW; 716 out[n].src.Index = src.Index; 717 out[n].src.Negate = src.Negate; 718 out[0].src.Absolute = src.Absolute; 719 n++; 720 721 if (src.Indirect) { 722 out[0].src.Indirect = 1; 723 out[n].value = 0; 724 out[n].src.File = src.IndirectFile; 725 out[n].src.SwizzleX = src.IndirectSwizzle; 726 out[n].src.SwizzleY = src.IndirectSwizzle; 727 out[n].src.SwizzleZ = src.IndirectSwizzle; 728 out[n].src.SwizzleW = src.IndirectSwizzle; 729 out[n].src.Index = src.IndirectIndex; 730 n++; 731 } 732 733 if (src.Dimension) { 734 out[0].src.Dimension = 1; 735 out[n].dim.Indirect = 0; 736 out[n].dim.Dimension = 0; 737 out[n].dim.Padding = 0; 738 out[n].dim.Index = src.DimensionIndex; 739 n++; 740 } 741 742 assert(n == size); 743} 744 745 746void 747ureg_emit_dst( struct ureg_program *ureg, 748 struct ureg_dst dst ) 749{ 750 unsigned size = (1 + 751 (dst.Indirect ? 1 : 0)); 752 753 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size ); 754 unsigned n = 0; 755 756 assert(dst.File != TGSI_FILE_NULL); 757 assert(dst.File != TGSI_FILE_CONSTANT); 758 assert(dst.File != TGSI_FILE_INPUT); 759 assert(dst.File != TGSI_FILE_SAMPLER); 760 assert(dst.File != TGSI_FILE_IMMEDIATE); 761 assert(dst.File < TGSI_FILE_COUNT); 762 763 out[n].value = 0; 764 out[n].dst.File = dst.File; 765 out[n].dst.WriteMask = dst.WriteMask; 766 out[n].dst.Indirect = dst.Indirect; 767 out[n].dst.Index = dst.Index; 768 n++; 769 770 if (dst.Indirect) { 771 out[n].value = 0; 772 out[n].src.File = TGSI_FILE_ADDRESS; 773 out[n].src.SwizzleX = dst.IndirectSwizzle; 774 out[n].src.SwizzleY = dst.IndirectSwizzle; 775 out[n].src.SwizzleZ = dst.IndirectSwizzle; 776 out[n].src.SwizzleW = dst.IndirectSwizzle; 777 out[n].src.Index = dst.IndirectIndex; 778 n++; 779 } 780 781 assert(n == size); 782} 783 784 785static void validate( unsigned opcode, 786 unsigned nr_dst, 787 unsigned nr_src ) 788{ 789#ifdef DEBUG 790 const struct tgsi_opcode_info *info = tgsi_get_opcode_info( opcode ); 791 assert(info); 792 if(info) { 793 assert(nr_dst == info->num_dst); 794 assert(nr_src == info->num_src); 795 } 796#endif 797} 798 799struct ureg_emit_insn_result 800ureg_emit_insn(struct ureg_program *ureg, 801 unsigned opcode, 802 boolean saturate, 803 boolean predicate, 804 boolean pred_negate, 805 unsigned pred_swizzle_x, 806 unsigned pred_swizzle_y, 807 unsigned pred_swizzle_z, 808 unsigned pred_swizzle_w, 809 unsigned num_dst, 810 unsigned num_src ) 811{ 812 union tgsi_any_token *out; 813 uint count = predicate ? 2 : 1; 814 struct ureg_emit_insn_result result; 815 816 validate( opcode, num_dst, num_src ); 817 818 out = get_tokens( ureg, DOMAIN_INSN, count ); 819 out[0].insn = tgsi_default_instruction(); 820 out[0].insn.Opcode = opcode; 821 out[0].insn.Saturate = saturate; 822 out[0].insn.NumDstRegs = num_dst; 823 out[0].insn.NumSrcRegs = num_src; 824 825 result.insn_token = ureg->domain[DOMAIN_INSN].count - count; 826 result.extended_token = result.insn_token; 827 828 if (predicate) { 829 out[0].insn.Predicate = 1; 830 out[1].insn_predicate = tgsi_default_instruction_predicate(); 831 out[1].insn_predicate.Negate = pred_negate; 832 out[1].insn_predicate.SwizzleX = pred_swizzle_x; 833 out[1].insn_predicate.SwizzleY = pred_swizzle_y; 834 out[1].insn_predicate.SwizzleZ = pred_swizzle_z; 835 out[1].insn_predicate.SwizzleW = pred_swizzle_w; 836 } 837 838 ureg->nr_instructions++; 839 840 return result; 841} 842 843 844void 845ureg_emit_label(struct ureg_program *ureg, 846 unsigned extended_token, 847 unsigned *label_token ) 848{ 849 union tgsi_any_token *out, *insn; 850 851 if(!label_token) 852 return; 853 854 out = get_tokens( ureg, DOMAIN_INSN, 1 ); 855 out[0].value = 0; 856 857 insn = retrieve_token( ureg, DOMAIN_INSN, extended_token ); 858 insn->insn.Label = 1; 859 860 *label_token = ureg->domain[DOMAIN_INSN].count - 1; 861} 862 863/* Will return a number which can be used in a label to point to the 864 * next instruction to be emitted. 865 */ 866unsigned 867ureg_get_instruction_number( struct ureg_program *ureg ) 868{ 869 return ureg->nr_instructions; 870} 871 872/* Patch a given label (expressed as a token number) to point to a 873 * given instruction (expressed as an instruction number). 874 */ 875void 876ureg_fixup_label(struct ureg_program *ureg, 877 unsigned label_token, 878 unsigned instruction_number ) 879{ 880 union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, label_token ); 881 882 out->insn_label.Label = instruction_number; 883} 884 885 886void 887ureg_emit_texture(struct ureg_program *ureg, 888 unsigned extended_token, 889 unsigned target ) 890{ 891 union tgsi_any_token *out, *insn; 892 893 out = get_tokens( ureg, DOMAIN_INSN, 1 ); 894 insn = retrieve_token( ureg, DOMAIN_INSN, extended_token ); 895 896 insn->insn.Texture = 1; 897 898 out[0].value = 0; 899 out[0].insn_texture.Texture = target; 900} 901 902 903void 904ureg_fixup_insn_size(struct ureg_program *ureg, 905 unsigned insn ) 906{ 907 union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, insn ); 908 909 assert(out->insn.Type == TGSI_TOKEN_TYPE_INSTRUCTION); 910 out->insn.NrTokens = ureg->domain[DOMAIN_INSN].count - insn - 1; 911} 912 913 914void 915ureg_insn(struct ureg_program *ureg, 916 unsigned opcode, 917 const struct ureg_dst *dst, 918 unsigned nr_dst, 919 const struct ureg_src *src, 920 unsigned nr_src ) 921{ 922 struct ureg_emit_insn_result insn; 923 unsigned i; 924 boolean saturate; 925 boolean predicate; 926 boolean negate = FALSE; 927 unsigned swizzle[4] = { 0 }; 928 929 saturate = nr_dst ? dst[0].Saturate : FALSE; 930 predicate = nr_dst ? dst[0].Predicate : FALSE; 931 if (predicate) { 932 negate = dst[0].PredNegate; 933 swizzle[0] = dst[0].PredSwizzleX; 934 swizzle[1] = dst[0].PredSwizzleY; 935 swizzle[2] = dst[0].PredSwizzleZ; 936 swizzle[3] = dst[0].PredSwizzleW; 937 } 938 939 insn = ureg_emit_insn(ureg, 940 opcode, 941 saturate, 942 predicate, 943 negate, 944 swizzle[0], 945 swizzle[1], 946 swizzle[2], 947 swizzle[3], 948 nr_dst, 949 nr_src); 950 951 for (i = 0; i < nr_dst; i++) 952 ureg_emit_dst( ureg, dst[i] ); 953 954 for (i = 0; i < nr_src; i++) 955 ureg_emit_src( ureg, src[i] ); 956 957 ureg_fixup_insn_size( ureg, insn.insn_token ); 958} 959 960void 961ureg_tex_insn(struct ureg_program *ureg, 962 unsigned opcode, 963 const struct ureg_dst *dst, 964 unsigned nr_dst, 965 unsigned target, 966 const struct ureg_src *src, 967 unsigned nr_src ) 968{ 969 struct ureg_emit_insn_result insn; 970 unsigned i; 971 boolean saturate; 972 boolean predicate; 973 boolean negate = FALSE; 974 unsigned swizzle[4] = { 0 }; 975 976 saturate = nr_dst ? dst[0].Saturate : FALSE; 977 predicate = nr_dst ? dst[0].Predicate : FALSE; 978 if (predicate) { 979 negate = dst[0].PredNegate; 980 swizzle[0] = dst[0].PredSwizzleX; 981 swizzle[1] = dst[0].PredSwizzleY; 982 swizzle[2] = dst[0].PredSwizzleZ; 983 swizzle[3] = dst[0].PredSwizzleW; 984 } 985 986 insn = ureg_emit_insn(ureg, 987 opcode, 988 saturate, 989 predicate, 990 negate, 991 swizzle[0], 992 swizzle[1], 993 swizzle[2], 994 swizzle[3], 995 nr_dst, 996 nr_src); 997 998 ureg_emit_texture( ureg, insn.extended_token, target ); 999 1000 for (i = 0; i < nr_dst; i++) 1001 ureg_emit_dst( ureg, dst[i] ); 1002 1003 for (i = 0; i < nr_src; i++) 1004 ureg_emit_src( ureg, src[i] ); 1005 1006 ureg_fixup_insn_size( ureg, insn.insn_token ); 1007} 1008 1009 1010void 1011ureg_label_insn(struct ureg_program *ureg, 1012 unsigned opcode, 1013 const struct ureg_src *src, 1014 unsigned nr_src, 1015 unsigned *label_token ) 1016{ 1017 struct ureg_emit_insn_result insn; 1018 unsigned i; 1019 1020 insn = ureg_emit_insn(ureg, 1021 opcode, 1022 FALSE, 1023 FALSE, 1024 FALSE, 1025 TGSI_SWIZZLE_X, 1026 TGSI_SWIZZLE_Y, 1027 TGSI_SWIZZLE_Z, 1028 TGSI_SWIZZLE_W, 1029 0, 1030 nr_src); 1031 1032 ureg_emit_label( ureg, insn.extended_token, label_token ); 1033 1034 for (i = 0; i < nr_src; i++) 1035 ureg_emit_src( ureg, src[i] ); 1036 1037 ureg_fixup_insn_size( ureg, insn.insn_token ); 1038} 1039 1040 1041 1042static void emit_decl( struct ureg_program *ureg, 1043 unsigned file, 1044 unsigned index, 1045 unsigned semantic_name, 1046 unsigned semantic_index, 1047 unsigned interp ) 1048{ 1049 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 3 ); 1050 1051 out[0].value = 0; 1052 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1053 out[0].decl.NrTokens = 3; 1054 out[0].decl.File = file; 1055 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; /* FIXME! */ 1056 out[0].decl.Interpolate = interp; 1057 out[0].decl.Semantic = 1; 1058 1059 out[1].value = 0; 1060 out[1].decl_range.First = 1061 out[1].decl_range.Last = index; 1062 1063 out[2].value = 0; 1064 out[2].decl_semantic.Name = semantic_name; 1065 out[2].decl_semantic.Index = semantic_index; 1066 1067} 1068 1069 1070static void emit_decl_range( struct ureg_program *ureg, 1071 unsigned file, 1072 unsigned first, 1073 unsigned count ) 1074{ 1075 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 ); 1076 1077 out[0].value = 0; 1078 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION; 1079 out[0].decl.NrTokens = 2; 1080 out[0].decl.File = file; 1081 out[0].decl.UsageMask = 0xf; 1082 out[0].decl.Interpolate = TGSI_INTERPOLATE_CONSTANT; 1083 out[0].decl.Semantic = 0; 1084 1085 out[1].value = 0; 1086 out[1].decl_range.First = first; 1087 out[1].decl_range.Last = first + count - 1; 1088} 1089 1090static void 1091emit_immediate( struct ureg_program *ureg, 1092 const unsigned *v, 1093 unsigned type ) 1094{ 1095 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 5 ); 1096 1097 out[0].value = 0; 1098 out[0].imm.Type = TGSI_TOKEN_TYPE_IMMEDIATE; 1099 out[0].imm.NrTokens = 5; 1100 out[0].imm.DataType = type; 1101 out[0].imm.Padding = 0; 1102 1103 out[1].imm_data.Uint = v[0]; 1104 out[2].imm_data.Uint = v[1]; 1105 out[3].imm_data.Uint = v[2]; 1106 out[4].imm_data.Uint = v[3]; 1107} 1108 1109static void 1110emit_property(struct ureg_program *ureg, 1111 unsigned name, 1112 unsigned data) 1113{ 1114 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 2); 1115 1116 out[0].value = 0; 1117 out[0].prop.Type = TGSI_TOKEN_TYPE_PROPERTY; 1118 out[0].prop.NrTokens = 2; 1119 out[0].prop.PropertyName = name; 1120 1121 out[1].prop_data.Data = data; 1122} 1123 1124 1125static void emit_decls( struct ureg_program *ureg ) 1126{ 1127 unsigned i; 1128 1129 if (ureg->property_gs_input_prim != ~0) { 1130 assert(ureg->processor == TGSI_PROCESSOR_GEOMETRY); 1131 1132 emit_property(ureg, 1133 TGSI_PROPERTY_GS_INPUT_PRIM, 1134 ureg->property_gs_input_prim); 1135 } 1136 1137 if (ureg->processor == TGSI_PROCESSOR_VERTEX) { 1138 for (i = 0; i < UREG_MAX_INPUT; i++) { 1139 if (ureg->vs_inputs[i/32] & (1 << (i%32))) { 1140 emit_decl_range( ureg, TGSI_FILE_INPUT, i, 1 ); 1141 } 1142 } 1143 } else if (ureg->processor == TGSI_PROCESSOR_FRAGMENT) { 1144 for (i = 0; i < ureg->nr_fs_inputs; i++) { 1145 emit_decl( ureg, 1146 TGSI_FILE_INPUT, 1147 i, 1148 ureg->fs_input[i].semantic_name, 1149 ureg->fs_input[i].semantic_index, 1150 ureg->fs_input[i].interp ); 1151 } 1152 } else { 1153 for (i = 0; i < ureg->nr_gs_inputs; i++) { 1154 emit_decl_range(ureg, 1155 TGSI_FILE_INPUT, 1156 ureg->gs_input[i].index, 1157 1); 1158 } 1159 } 1160 1161 for (i = 0; i < ureg->nr_system_values; i++) { 1162 emit_decl(ureg, 1163 TGSI_FILE_SYSTEM_VALUE, 1164 ureg->system_value[i].index, 1165 ureg->system_value[i].semantic_name, 1166 ureg->system_value[i].semantic_index, 1167 TGSI_INTERPOLATE_CONSTANT); 1168 } 1169 1170 for (i = 0; i < ureg->nr_outputs; i++) { 1171 emit_decl( ureg, 1172 TGSI_FILE_OUTPUT, 1173 i, 1174 ureg->output[i].semantic_name, 1175 ureg->output[i].semantic_index, 1176 TGSI_INTERPOLATE_CONSTANT ); 1177 } 1178 1179 for (i = 0; i < ureg->nr_samplers; i++) { 1180 emit_decl_range( ureg, 1181 TGSI_FILE_SAMPLER, 1182 ureg->sampler[i].Index, 1 ); 1183 } 1184 1185 if (ureg->nr_constant_ranges) { 1186 for (i = 0; i < ureg->nr_constant_ranges; i++) 1187 emit_decl_range( ureg, 1188 TGSI_FILE_CONSTANT, 1189 ureg->constant_range[i].first, 1190 (ureg->constant_range[i].last + 1 - 1191 ureg->constant_range[i].first) ); 1192 } 1193 1194 if (ureg->nr_temps) { 1195 emit_decl_range( ureg, 1196 TGSI_FILE_TEMPORARY, 1197 0, ureg->nr_temps ); 1198 } 1199 1200 if (ureg->nr_addrs) { 1201 emit_decl_range( ureg, 1202 TGSI_FILE_ADDRESS, 1203 0, ureg->nr_addrs ); 1204 } 1205 1206 if (ureg->nr_loops) { 1207 emit_decl_range(ureg, 1208 TGSI_FILE_LOOP, 1209 0, 1210 ureg->nr_loops); 1211 } 1212 1213 if (ureg->nr_preds) { 1214 emit_decl_range(ureg, 1215 TGSI_FILE_PREDICATE, 1216 0, 1217 ureg->nr_preds); 1218 } 1219 1220 for (i = 0; i < ureg->nr_immediates; i++) { 1221 emit_immediate( ureg, 1222 ureg->immediate[i].value.u, 1223 ureg->immediate[i].type ); 1224 } 1225} 1226 1227/* Append the instruction tokens onto the declarations to build a 1228 * contiguous stream suitable to send to the driver. 1229 */ 1230static void copy_instructions( struct ureg_program *ureg ) 1231{ 1232 unsigned nr_tokens = ureg->domain[DOMAIN_INSN].count; 1233 union tgsi_any_token *out = get_tokens( ureg, 1234 DOMAIN_DECL, 1235 nr_tokens ); 1236 1237 memcpy(out, 1238 ureg->domain[DOMAIN_INSN].tokens, 1239 nr_tokens * sizeof out[0] ); 1240} 1241 1242 1243static void 1244fixup_header_size(struct ureg_program *ureg) 1245{ 1246 union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_DECL, 0 ); 1247 1248 out->header.BodySize = ureg->domain[DOMAIN_DECL].count - 2; 1249} 1250 1251 1252static void 1253emit_header( struct ureg_program *ureg ) 1254{ 1255 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 ); 1256 1257 out[0].header.HeaderSize = 2; 1258 out[0].header.BodySize = 0; 1259 1260 out[1].processor.Processor = ureg->processor; 1261 out[1].processor.Padding = 0; 1262} 1263 1264 1265const struct tgsi_token *ureg_finalize( struct ureg_program *ureg ) 1266{ 1267 const struct tgsi_token *tokens; 1268 1269 emit_header( ureg ); 1270 emit_decls( ureg ); 1271 copy_instructions( ureg ); 1272 fixup_header_size( ureg ); 1273 1274 if (ureg->domain[0].tokens == error_tokens || 1275 ureg->domain[1].tokens == error_tokens) { 1276 debug_printf("%s: error in generated shader\n", __FUNCTION__); 1277 assert(0); 1278 return NULL; 1279 } 1280 1281 tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token; 1282 1283 if (0) { 1284 debug_printf("%s: emitted shader %d tokens:\n", __FUNCTION__, 1285 ureg->domain[DOMAIN_DECL].count); 1286 tgsi_dump( tokens, 0 ); 1287 } 1288 1289#if DEBUG 1290 if (tokens && !tgsi_sanity_check(tokens)) { 1291 debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n"); 1292 tgsi_dump(tokens, 0); 1293 assert(0); 1294 } 1295#endif 1296 1297 1298 return tokens; 1299} 1300 1301 1302void *ureg_create_shader( struct ureg_program *ureg, 1303 struct pipe_context *pipe ) 1304{ 1305 struct pipe_shader_state state; 1306 1307 state.tokens = ureg_finalize(ureg); 1308 if(!state.tokens) 1309 return NULL; 1310 1311 if (ureg->processor == TGSI_PROCESSOR_VERTEX) 1312 return pipe->create_vs_state( pipe, &state ); 1313 else 1314 return pipe->create_fs_state( pipe, &state ); 1315} 1316 1317 1318const struct tgsi_token *ureg_get_tokens( struct ureg_program *ureg, 1319 unsigned *nr_tokens ) 1320{ 1321 const struct tgsi_token *tokens; 1322 1323 ureg_finalize(ureg); 1324 1325 tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token; 1326 1327 if (nr_tokens) 1328 *nr_tokens = ureg->domain[DOMAIN_DECL].size; 1329 1330 ureg->domain[DOMAIN_DECL].tokens = 0; 1331 ureg->domain[DOMAIN_DECL].size = 0; 1332 ureg->domain[DOMAIN_DECL].order = 0; 1333 ureg->domain[DOMAIN_DECL].count = 0; 1334 1335 return tokens; 1336} 1337 1338 1339struct ureg_program *ureg_create( unsigned processor ) 1340{ 1341 struct ureg_program *ureg = CALLOC_STRUCT( ureg_program ); 1342 if (ureg == NULL) 1343 return NULL; 1344 1345 ureg->processor = processor; 1346 ureg->property_gs_input_prim = ~0; 1347 return ureg; 1348} 1349 1350 1351void ureg_destroy( struct ureg_program *ureg ) 1352{ 1353 unsigned i; 1354 1355 for (i = 0; i < Elements(ureg->domain); i++) { 1356 if (ureg->domain[i].tokens && 1357 ureg->domain[i].tokens != error_tokens) 1358 FREE(ureg->domain[i].tokens); 1359 } 1360 1361 FREE(ureg); 1362} 1363