src/gallium/auxiliary/tgsi/tgsi_ureg.c

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