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