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