src/gallium/auxiliary/tgsi/tgsi_ureg.c

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