src/gallium/auxiliary/tgsi/tgsi_ureg.c

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