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_debug.h"
  37 #include "util/u_memory.h"
  38 #include "util/u_math.h"
  39
  40 union 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
  63 struct 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
  80 struct 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
  91 struct 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
 159 static union tgsi_any_token error_tokens[32];
 160
 161 static 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
 172 static 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
 193 static void set_bad( struct ureg_program *ureg )
 194 {
 195    tokens_error(&ureg->domain[0]);
 196 }
 197
 198
 199
 200 static 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
 216 static 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
 228 static INLINE struct ureg_dst
 229 ureg_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
 252 void
 253 ureg_property_gs_input_prim(struct ureg_program *ureg,
 254                             unsigned input_prim)
 255 {
 256    ureg->property_gs_input_prim = input_prim;
 257 }
 258
 259 void
 260 ureg_property_gs_output_prim(struct ureg_program *ureg,
 261                              unsigned output_prim)
 262 {
 263    ureg->property_gs_output_prim = output_prim;
 264 }
 265
 266 void
 267 ureg_property_gs_max_vertices(struct ureg_program *ureg,
 268                               unsigned max_vertices)
 269 {
 270    ureg->property_gs_max_vertices = max_vertices;
 271 }
 272
 273 void
 274 ureg_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
 280 void
 281 ureg_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
 289 struct ureg_src
 290 ureg_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
 313 out:
 314    return ureg_src_register( TGSI_FILE_INPUT, i );
 315 }
 316
 317
 318 struct ureg_src
 319 ureg_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
 329 struct ureg_src
 330 ureg_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
 349 struct ureg_src
 350 ureg_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
 368 struct ureg_dst
 369 ureg_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
 390 out:
 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  */
 405 void
 406 ureg_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  */
 429 struct ureg_src
 430 ureg_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
 479 out:
 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  */
 490 struct 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
 506 out:
 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
 517 void 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  */
 528 struct 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  */
 539 struct ureg_dst
 540 ureg_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  */
 552 struct ureg_dst
 553 ureg_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  */
 565 struct 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
 585 static int
 586 match_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
 625 static struct ureg_src
 626 decl_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
 665 out:
 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
 681 struct ureg_src
 682 ureg_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
 700 struct ureg_src
 701 ureg_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
 709 struct ureg_src
 710 ureg_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
 738 struct ureg_src
 739 ureg_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
 747 void
 748 ureg_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
 796 void
 797 ureg_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
 835 static 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
 849 struct ureg_emit_insn_result
 850 ureg_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
 894 void
 895 ureg_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  */
 916 unsigned
 917 ureg_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  */
 925 void
 926 ureg_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
 936 void
 937 ureg_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
 953 void
 954 ureg_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
 964 void
 965 ureg_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
1010 void
1011 ureg_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
1060 void
1061 ureg_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
1092 static 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
1120 static 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
1140 static void
1141 emit_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
1165 static void
1166 emit_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
1184 static void
1185 emit_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
1200 static 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  */
1355 static 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
1368 static void
1369 fixup_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
1377 static void
1378 emit_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
1390 const 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
1427 void *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
1443 const 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
1464 struct 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
1478 void 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 }