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