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