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