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