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.Indirect = 0;
 246    src.IndirectIndex = 0;
 247    src.IndirectSwizzle = 0;
 248    src.Absolute = 0;
 249    src.Index    = index;
 250    src.Negate   = 0;
 251    src.Dimension = 0;
 252    src.DimensionIndex = 0;
 253
 254    return src;
 255 }
 256
 257
 258
 259
 260 struct ureg_src
 261 ureg_DECL_fs_input( struct ureg_program *ureg,
 262                     unsigned name,
 263                     unsigned index,
 264                     unsigned interp_mode )
 265 {
 266    unsigned i;
 267
 268    for (i = 0; i < ureg->nr_fs_inputs; i++) {
 269       if (ureg->fs_input[i].semantic_name == name &&
 270           ureg->fs_input[i].semantic_index == index)
 271          goto out;
 272    }
 273
 274    if (ureg->nr_fs_inputs < UREG_MAX_INPUT) {
 275       ureg->fs_input[i].semantic_name = name;
 276       ureg->fs_input[i].semantic_index = index;
 277       ureg->fs_input[i].interp = interp_mode;
 278       ureg->nr_fs_inputs++;
 279    }
 280    else {
 281       set_bad( ureg );
 282    }
 283
 284 out:
 285    return ureg_src_register( TGSI_FILE_INPUT, i );
 286 }
 287
 288
 289 struct ureg_src
 290 ureg_DECL_vs_input( struct ureg_program *ureg,
 291                     unsigned index )
 292 {
 293    assert(ureg->processor == TGSI_PROCESSOR_VERTEX);
 294
 295    ureg->vs_inputs[index/32] |= 1 << (index % 32);
 296    return ureg_src_register( TGSI_FILE_INPUT, index );
 297 }
 298
 299
 300 struct ureg_src
 301 ureg_DECL_gs_input(struct ureg_program *ureg,
 302                    unsigned index)
 303 {
 304    if (ureg->nr_gs_inputs < UREG_MAX_INPUT) {
 305       ureg->gs_input[ureg->nr_gs_inputs].index = index;
 306       ureg->nr_gs_inputs++;
 307    } else {
 308       set_bad(ureg);
 309    }
 310
 311    /* XXX: Add suport for true 2D input registers. */
 312    return ureg_src_register(TGSI_FILE_INPUT, index);
 313 }
 314
 315
 316 struct ureg_src
 317 ureg_DECL_system_value(struct ureg_program *ureg,
 318                        unsigned index,
 319                        unsigned semantic_name,
 320                        unsigned semantic_index)
 321 {
 322    if (ureg->nr_system_values < UREG_MAX_SYSTEM_VALUE) {
 323       ureg->system_value[ureg->nr_system_values].index = index;
 324       ureg->system_value[ureg->nr_system_values].semantic_name = semantic_name;
 325       ureg->system_value[ureg->nr_system_values].semantic_index = semantic_index;
 326       ureg->nr_system_values++;
 327    } else {
 328       set_bad(ureg);
 329    }
 330
 331    return ureg_src_register(TGSI_FILE_SYSTEM_VALUE, index);
 332 }
 333
 334
 335 struct ureg_dst
 336 ureg_DECL_output( struct ureg_program *ureg,
 337                   unsigned name,
 338                   unsigned index )
 339 {
 340    unsigned i;
 341
 342    for (i = 0; i < ureg->nr_outputs; i++) {
 343       if (ureg->output[i].semantic_name == name &&
 344           ureg->output[i].semantic_index == index)
 345          goto out;
 346    }
 347
 348    if (ureg->nr_outputs < UREG_MAX_OUTPUT) {
 349       ureg->output[i].semantic_name = name;
 350       ureg->output[i].semantic_index = index;
 351       ureg->nr_outputs++;
 352    }
 353    else {
 354       set_bad( ureg );
 355    }
 356
 357 out:
 358    return ureg_dst_register( TGSI_FILE_OUTPUT, i );
 359 }
 360
 361
 362 /* Returns a new constant register.  Keep track of which have been
 363  * referred to so that we can emit decls later.
 364  *
 365  * There is nothing in this code to bind this constant to any tracked
 366  * value or manage any constant_buffer contents -- that's the
 367  * resposibility of the calling code.
 368  */
 369 struct ureg_src ureg_DECL_constant(struct ureg_program *ureg,
 370                                    unsigned index )
 371 {
 372    unsigned minconst = index, maxconst = index;
 373    unsigned i;
 374
 375    /* Inside existing range?
 376     */
 377    for (i = 0; i < ureg->nr_constant_ranges; i++) {
 378       if (ureg->constant_range[i].first <= index &&
 379           ureg->constant_range[i].last >= index)
 380          goto out;
 381    }
 382
 383    /* Extend existing range?
 384     */
 385    for (i = 0; i < ureg->nr_constant_ranges; i++) {
 386       if (ureg->constant_range[i].last == index - 1) {
 387          ureg->constant_range[i].last = index;
 388          goto out;
 389       }
 390
 391       if (ureg->constant_range[i].first == index + 1) {
 392          ureg->constant_range[i].first = index;
 393          goto out;
 394       }
 395
 396       minconst = MIN2(minconst, ureg->constant_range[i].first);
 397       maxconst = MAX2(maxconst, ureg->constant_range[i].last);
 398    }
 399
 400    /* Create new range?
 401     */
 402    if (ureg->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) {
 403       i = ureg->nr_constant_ranges++;
 404       ureg->constant_range[i].first = index;
 405       ureg->constant_range[i].last = index;
 406       goto out;
 407    }
 408
 409    /* Collapse all ranges down to one:
 410     */
 411    i = 0;
 412    ureg->constant_range[0].first = minconst;
 413    ureg->constant_range[0].last = maxconst;
 414    ureg->nr_constant_ranges = 1;
 415
 416 out:
 417    assert(i < ureg->nr_constant_ranges);
 418    assert(ureg->constant_range[i].first <= index);
 419    assert(ureg->constant_range[i].last >= index);
 420    return ureg_src_register( TGSI_FILE_CONSTANT, index );
 421 }
 422
 423
 424 /* Allocate a new temporary.  Temporaries greater than UREG_MAX_TEMP
 425  * are legal, but will not be released.
 426  */
 427 struct ureg_dst ureg_DECL_temporary( struct ureg_program *ureg )
 428 {
 429    unsigned i;
 430
 431    for (i = 0; i < UREG_MAX_TEMP; i += 32) {
 432       int bit = ffs(~ureg->temps_active[i/32]);
 433       if (bit != 0) {
 434          i += bit - 1;
 435          goto out;
 436       }
 437    }
 438
 439    /* No reusable temps, so allocate a new one:
 440     */
 441    i = ureg->nr_temps++;
 442
 443 out:
 444    if (i < UREG_MAX_TEMP)
 445       ureg->temps_active[i/32] |= 1 << (i % 32);
 446
 447    if (i >= ureg->nr_temps)
 448       ureg->nr_temps = i + 1;
 449
 450    return ureg_dst_register( TGSI_FILE_TEMPORARY, i );
 451 }
 452
 453
 454 void ureg_release_temporary( struct ureg_program *ureg,
 455                              struct ureg_dst tmp )
 456 {
 457    if(tmp.File == TGSI_FILE_TEMPORARY)
 458       if (tmp.Index < UREG_MAX_TEMP)
 459          ureg->temps_active[tmp.Index/32] &= ~(1 << (tmp.Index % 32));
 460 }
 461
 462
 463 /* Allocate a new address register.
 464  */
 465 struct ureg_dst ureg_DECL_address( struct ureg_program *ureg )
 466 {
 467    if (ureg->nr_addrs < UREG_MAX_ADDR)
 468       return ureg_dst_register( TGSI_FILE_ADDRESS, ureg->nr_addrs++ );
 469
 470    assert( 0 );
 471    return ureg_dst_register( TGSI_FILE_ADDRESS, 0 );
 472 }
 473
 474 /* Allocate a new loop register.
 475  */
 476 struct ureg_dst
 477 ureg_DECL_loop(struct ureg_program *ureg)
 478 {
 479    if (ureg->nr_loops < UREG_MAX_LOOP) {
 480       return ureg_dst_register(TGSI_FILE_LOOP, ureg->nr_loops++);
 481    }
 482
 483    assert(0);
 484    return ureg_dst_register(TGSI_FILE_LOOP, 0);
 485 }
 486
 487 /* Allocate a new predicate register.
 488  */
 489 struct ureg_dst
 490 ureg_DECL_predicate(struct ureg_program *ureg)
 491 {
 492    if (ureg->nr_preds < UREG_MAX_PRED) {
 493       return ureg_dst_register(TGSI_FILE_PREDICATE, ureg->nr_preds++);
 494    }
 495
 496    assert(0);
 497    return ureg_dst_register(TGSI_FILE_PREDICATE, 0);
 498 }
 499
 500 /* Allocate a new sampler.
 501  */
 502 struct ureg_src ureg_DECL_sampler( struct ureg_program *ureg,
 503                                    unsigned nr )
 504 {
 505    unsigned i;
 506
 507    for (i = 0; i < ureg->nr_samplers; i++)
 508       if (ureg->sampler[i].Index == nr)
 509          return ureg->sampler[i];
 510
 511    if (i < PIPE_MAX_SAMPLERS) {
 512       ureg->sampler[i] = ureg_src_register( TGSI_FILE_SAMPLER, nr );
 513       ureg->nr_samplers++;
 514       return ureg->sampler[i];
 515    }
 516
 517    assert( 0 );
 518    return ureg->sampler[0];
 519 }
 520
 521
 522 static int
 523 match_or_expand_immediate( const unsigned *v,
 524                            unsigned nr,
 525                            unsigned *v2,
 526                            unsigned *pnr2,
 527                            unsigned *swizzle )
 528 {
 529    unsigned nr2 = *pnr2;
 530    unsigned i, j;
 531
 532    *swizzle = 0;
 533
 534    for (i = 0; i < nr; i++) {
 535       boolean found = FALSE;
 536
 537       for (j = 0; j < nr2 && !found; j++) {
 538          if (v[i] == v2[j]) {
 539             *swizzle |= j << (i * 2);
 540             found = TRUE;
 541          }
 542       }
 543
 544       if (!found) {
 545          if (nr2 >= 4) {
 546             return FALSE;
 547          }
 548
 549          v2[nr2] = v[i];
 550          *swizzle |= nr2 << (i * 2);
 551          nr2++;
 552       }
 553    }
 554
 555    /* Actually expand immediate only when fully succeeded.
 556     */
 557    *pnr2 = nr2;
 558    return TRUE;
 559 }
 560
 561
 562 static struct ureg_src
 563 decl_immediate( struct ureg_program *ureg,
 564                 const unsigned *v,
 565                 unsigned nr,
 566                 unsigned type )
 567 {
 568    unsigned i, j;
 569    unsigned swizzle;
 570
 571    /* Could do a first pass where we examine all existing immediates
 572     * without expanding.
 573     */
 574
 575    for (i = 0; i < ureg->nr_immediates; i++) {
 576       if (ureg->immediate[i].type != type) {
 577          continue;
 578       }
 579       if (match_or_expand_immediate(v,
 580                                     nr,
 581                                     ureg->immediate[i].value.u,
 582                                     &ureg->immediate[i].nr,
 583                                     &swizzle)) {
 584          goto out;
 585       }
 586    }
 587
 588    if (ureg->nr_immediates < UREG_MAX_IMMEDIATE) {
 589       i = ureg->nr_immediates++;
 590       ureg->immediate[i].type = type;
 591       if (match_or_expand_immediate(v,
 592                                     nr,
 593                                     ureg->immediate[i].value.u,
 594                                     &ureg->immediate[i].nr,
 595                                     &swizzle)) {
 596          goto out;
 597       }
 598    }
 599
 600    set_bad(ureg);
 601
 602 out:
 603    /* Make sure that all referenced elements are from this immediate.
 604     * Has the effect of making size-one immediates into scalars.
 605     */
 606    for (j = nr; j < 4; j++) {
 607       swizzle |= (swizzle & 0x3) << (j * 2);
 608    }
 609
 610    return ureg_swizzle(ureg_src_register(TGSI_FILE_IMMEDIATE, i),
 611                        (swizzle >> 0) & 0x3,
 612                        (swizzle >> 2) & 0x3,
 613                        (swizzle >> 4) & 0x3,
 614                        (swizzle >> 6) & 0x3);
 615 }
 616
 617
 618 struct ureg_src
 619 ureg_DECL_immediate( struct ureg_program *ureg,
 620                      const float *v,
 621                      unsigned nr )
 622 {
 623    union {
 624       float f[4];
 625       unsigned u[4];
 626    } fu;
 627    unsigned int i;
 628
 629    for (i = 0; i < nr; i++) {
 630       fu.f[i] = v[i];
 631    }
 632
 633    return decl_immediate(ureg, fu.u, nr, TGSI_IMM_FLOAT32);
 634 }
 635
 636
 637 struct ureg_src
 638 ureg_DECL_immediate_uint( struct ureg_program *ureg,
 639                           const unsigned *v,
 640                           unsigned nr )
 641 {
 642    return decl_immediate(ureg, v, nr, TGSI_IMM_UINT32);
 643 }
 644
 645
 646 struct ureg_src
 647 ureg_DECL_immediate_int( struct ureg_program *ureg,
 648                          const int *v,
 649                          unsigned nr )
 650 {
 651    return decl_immediate(ureg, (const unsigned *)v, nr, TGSI_IMM_INT32);
 652 }
 653
 654
 655 void
 656 ureg_emit_src( struct ureg_program *ureg,
 657                struct ureg_src src )
 658 {
 659    unsigned size = 1 + (src.Indirect ? 1 : 0) + (src.Dimension ? 1 : 0);
 660
 661    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size );
 662    unsigned n = 0;
 663
 664    assert(src.File != TGSI_FILE_NULL);
 665    assert(src.File != TGSI_FILE_OUTPUT);
 666    assert(src.File < TGSI_FILE_COUNT);
 667
 668    out[n].value = 0;
 669    out[n].src.File = src.File;
 670    out[n].src.SwizzleX = src.SwizzleX;
 671    out[n].src.SwizzleY = src.SwizzleY;
 672    out[n].src.SwizzleZ = src.SwizzleZ;
 673    out[n].src.SwizzleW = src.SwizzleW;
 674    out[n].src.Index = src.Index;
 675    out[n].src.Negate = src.Negate;
 676    out[0].src.Absolute = src.Absolute;
 677    n++;
 678
 679    if (src.Indirect) {
 680       out[0].src.Indirect = 1;
 681       out[n].value = 0;
 682       out[n].src.File = TGSI_FILE_ADDRESS;
 683       out[n].src.SwizzleX = src.IndirectSwizzle;
 684       out[n].src.SwizzleY = src.IndirectSwizzle;
 685       out[n].src.SwizzleZ = src.IndirectSwizzle;
 686       out[n].src.SwizzleW = src.IndirectSwizzle;
 687       out[n].src.Index = src.IndirectIndex;
 688       n++;
 689    }
 690
 691    if (src.Dimension) {
 692       out[0].src.Dimension = 1;
 693       out[n].dim.Indirect = 0;
 694       out[n].dim.Dimension = 0;
 695       out[n].dim.Padding = 0;
 696       out[n].dim.Index = src.DimensionIndex;
 697       n++;
 698    }
 699
 700    assert(n == size);
 701 }
 702
 703
 704 void
 705 ureg_emit_dst( struct ureg_program *ureg,
 706                struct ureg_dst dst )
 707 {
 708    unsigned size = (1 +
 709                     (dst.Indirect ? 1 : 0));
 710
 711    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size );
 712    unsigned n = 0;
 713
 714    assert(dst.File != TGSI_FILE_NULL);
 715    assert(dst.File != TGSI_FILE_CONSTANT);
 716    assert(dst.File != TGSI_FILE_INPUT);
 717    assert(dst.File != TGSI_FILE_SAMPLER);
 718    assert(dst.File != TGSI_FILE_IMMEDIATE);
 719    assert(dst.File < TGSI_FILE_COUNT);
 720
 721    out[n].value = 0;
 722    out[n].dst.File = dst.File;
 723    out[n].dst.WriteMask = dst.WriteMask;
 724    out[n].dst.Indirect = dst.Indirect;
 725    out[n].dst.Index = dst.Index;
 726    n++;
 727
 728    if (dst.Indirect) {
 729       out[n].value = 0;
 730       out[n].src.File = TGSI_FILE_ADDRESS;
 731       out[n].src.SwizzleX = dst.IndirectSwizzle;
 732       out[n].src.SwizzleY = dst.IndirectSwizzle;
 733       out[n].src.SwizzleZ = dst.IndirectSwizzle;
 734       out[n].src.SwizzleW = dst.IndirectSwizzle;
 735       out[n].src.Index = dst.IndirectIndex;
 736       n++;
 737    }
 738
 739    assert(n == size);
 740 }
 741
 742
 743 static void validate( unsigned opcode,
 744                       unsigned nr_dst,
 745                       unsigned nr_src )
 746 {
 747 #ifdef DEBUG
 748    const struct tgsi_opcode_info *info = tgsi_get_opcode_info( opcode );
 749    assert(info);
 750    if(info) {
 751       assert(nr_dst == info->num_dst);
 752       assert(nr_src == info->num_src);
 753    }
 754 #endif
 755 }
 756
 757 struct ureg_emit_insn_result
 758 ureg_emit_insn(struct ureg_program *ureg,
 759                unsigned opcode,
 760                boolean saturate,
 761                boolean predicate,
 762                boolean pred_negate,
 763                unsigned pred_swizzle_x,
 764                unsigned pred_swizzle_y,
 765                unsigned pred_swizzle_z,
 766                unsigned pred_swizzle_w,
 767                unsigned num_dst,
 768                unsigned num_src )
 769 {
 770    union tgsi_any_token *out;
 771    uint count = predicate ? 2 : 1;
 772    struct ureg_emit_insn_result result;
 773
 774    validate( opcode, num_dst, num_src );
 775
 776    out = get_tokens( ureg, DOMAIN_INSN, count );
 777    out[0].insn = tgsi_default_instruction();
 778    out[0].insn.Opcode = opcode;
 779    out[0].insn.Saturate = saturate;
 780    out[0].insn.NumDstRegs = num_dst;
 781    out[0].insn.NumSrcRegs = num_src;
 782
 783    result.insn_token = ureg->domain[DOMAIN_INSN].count - count;
 784    result.extended_token = result.insn_token;
 785
 786    if (predicate) {
 787       out[0].insn.Predicate = 1;
 788       out[1].insn_predicate = tgsi_default_instruction_predicate();
 789       out[1].insn_predicate.Negate = pred_negate;
 790       out[1].insn_predicate.SwizzleX = pred_swizzle_x;
 791       out[1].insn_predicate.SwizzleY = pred_swizzle_y;
 792       out[1].insn_predicate.SwizzleZ = pred_swizzle_z;
 793       out[1].insn_predicate.SwizzleW = pred_swizzle_w;
 794    }
 795
 796    ureg->nr_instructions++;
 797
 798    return result;
 799 }
 800
 801
 802 void
 803 ureg_emit_label(struct ureg_program *ureg,
 804                 unsigned extended_token,
 805                 unsigned *label_token )
 806 {
 807    union tgsi_any_token *out, *insn;
 808
 809    if(!label_token)
 810       return;
 811
 812    out = get_tokens( ureg, DOMAIN_INSN, 1 );
 813    out[0].value = 0;
 814
 815    insn = retrieve_token( ureg, DOMAIN_INSN, extended_token );
 816    insn->insn.Label = 1;
 817
 818    *label_token = ureg->domain[DOMAIN_INSN].count - 1;
 819 }
 820
 821 /* Will return a number which can be used in a label to point to the
 822  * next instruction to be emitted.
 823  */
 824 unsigned
 825 ureg_get_instruction_number( struct ureg_program *ureg )
 826 {
 827    return ureg->nr_instructions;
 828 }
 829
 830 /* Patch a given label (expressed as a token number) to point to a
 831  * given instruction (expressed as an instruction number).
 832  */
 833 void
 834 ureg_fixup_label(struct ureg_program *ureg,
 835                  unsigned label_token,
 836                  unsigned instruction_number )
 837 {
 838    union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, label_token );
 839
 840    out->insn_label.Label = instruction_number;
 841 }
 842
 843
 844 void
 845 ureg_emit_texture(struct ureg_program *ureg,
 846                   unsigned extended_token,
 847                   unsigned target )
 848 {
 849    union tgsi_any_token *out, *insn;
 850
 851    out = get_tokens( ureg, DOMAIN_INSN, 1 );
 852    insn = retrieve_token( ureg, DOMAIN_INSN, extended_token );
 853
 854    insn->insn.Texture = 1;
 855
 856    out[0].value = 0;
 857    out[0].insn_texture.Texture = target;
 858 }
 859
 860
 861 void
 862 ureg_fixup_insn_size(struct ureg_program *ureg,
 863                      unsigned insn )
 864 {
 865    union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, insn );
 866
 867    assert(out->insn.Type == TGSI_TOKEN_TYPE_INSTRUCTION);
 868    out->insn.NrTokens = ureg->domain[DOMAIN_INSN].count - insn - 1;
 869 }
 870
 871
 872 void
 873 ureg_insn(struct ureg_program *ureg,
 874           unsigned opcode,
 875           const struct ureg_dst *dst,
 876           unsigned nr_dst,
 877           const struct ureg_src *src,
 878           unsigned nr_src )
 879 {
 880    struct ureg_emit_insn_result insn;
 881    unsigned i;
 882    boolean saturate;
 883    boolean predicate;
 884    boolean negate = FALSE;
 885    unsigned swizzle[4] = { 0 };
 886
 887    saturate = nr_dst ? dst[0].Saturate : FALSE;
 888    predicate = nr_dst ? dst[0].Predicate : FALSE;
 889    if (predicate) {
 890       negate = dst[0].PredNegate;
 891       swizzle[0] = dst[0].PredSwizzleX;
 892       swizzle[1] = dst[0].PredSwizzleY;
 893       swizzle[2] = dst[0].PredSwizzleZ;
 894       swizzle[3] = dst[0].PredSwizzleW;
 895    }
 896
 897    insn = ureg_emit_insn(ureg,
 898                          opcode,
 899                          saturate,
 900                          predicate,
 901                          negate,
 902                          swizzle[0],
 903                          swizzle[1],
 904                          swizzle[2],
 905                          swizzle[3],
 906                          nr_dst,
 907                          nr_src);
 908
 909    for (i = 0; i < nr_dst; i++)
 910       ureg_emit_dst( ureg, dst[i] );
 911
 912    for (i = 0; i < nr_src; i++)
 913       ureg_emit_src( ureg, src[i] );
 914
 915    ureg_fixup_insn_size( ureg, insn.insn_token );
 916 }
 917
 918 void
 919 ureg_tex_insn(struct ureg_program *ureg,
 920               unsigned opcode,
 921               const struct ureg_dst *dst,
 922               unsigned nr_dst,
 923               unsigned target,
 924               const struct ureg_src *src,
 925               unsigned nr_src )
 926 {
 927    struct ureg_emit_insn_result insn;
 928    unsigned i;
 929    boolean saturate;
 930    boolean predicate;
 931    boolean negate = FALSE;
 932    unsigned swizzle[4] = { 0 };
 933
 934    saturate = nr_dst ? dst[0].Saturate : FALSE;
 935    predicate = nr_dst ? dst[0].Predicate : FALSE;
 936    if (predicate) {
 937       negate = dst[0].PredNegate;
 938       swizzle[0] = dst[0].PredSwizzleX;
 939       swizzle[1] = dst[0].PredSwizzleY;
 940       swizzle[2] = dst[0].PredSwizzleZ;
 941       swizzle[3] = dst[0].PredSwizzleW;
 942    }
 943
 944    insn = ureg_emit_insn(ureg,
 945                          opcode,
 946                          saturate,
 947                          predicate,
 948                          negate,
 949                          swizzle[0],
 950                          swizzle[1],
 951                          swizzle[2],
 952                          swizzle[3],
 953                          nr_dst,
 954                          nr_src);
 955
 956    ureg_emit_texture( ureg, insn.extended_token, target );
 957
 958    for (i = 0; i < nr_dst; i++)
 959       ureg_emit_dst( ureg, dst[i] );
 960
 961    for (i = 0; i < nr_src; i++)
 962       ureg_emit_src( ureg, src[i] );
 963
 964    ureg_fixup_insn_size( ureg, insn.insn_token );
 965 }
 966
 967
 968 void
 969 ureg_label_insn(struct ureg_program *ureg,
 970                 unsigned opcode,
 971                 const struct ureg_src *src,
 972                 unsigned nr_src,
 973                 unsigned *label_token )
 974 {
 975    struct ureg_emit_insn_result insn;
 976    unsigned i;
 977
 978    insn = ureg_emit_insn(ureg,
 979                          opcode,
 980                          FALSE,
 981                          FALSE,
 982                          FALSE,
 983                          TGSI_SWIZZLE_X,
 984                          TGSI_SWIZZLE_Y,
 985                          TGSI_SWIZZLE_Z,
 986                          TGSI_SWIZZLE_W,
 987                          0,
 988                          nr_src);
 989
 990    ureg_emit_label( ureg, insn.extended_token, label_token );
 991
 992    for (i = 0; i < nr_src; i++)
 993       ureg_emit_src( ureg, src[i] );
 994
 995    ureg_fixup_insn_size( ureg, insn.insn_token );
 996 }
 997
 998
 999
1000 static void emit_decl( struct ureg_program *ureg,
1001                        unsigned file,
1002                        unsigned index,
1003                        unsigned semantic_name,
1004                        unsigned semantic_index,
1005                        unsigned interp )
1006 {
1007    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 3 );
1008
1009    out[0].value = 0;
1010    out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1011    out[0].decl.NrTokens = 3;
1012    out[0].decl.File = file;
1013    out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; /* FIXME! */
1014    out[0].decl.Interpolate = interp;
1015    out[0].decl.Semantic = 1;
1016
1017    out[1].value = 0;
1018    out[1].decl_range.First =
1019       out[1].decl_range.Last = index;
1020
1021    out[2].value = 0;
1022    out[2].decl_semantic.Name = semantic_name;
1023    out[2].decl_semantic.Index = semantic_index;
1024
1025 }
1026
1027
1028 static void emit_decl_range( struct ureg_program *ureg,
1029                              unsigned file,
1030                              unsigned first,
1031                              unsigned count )
1032 {
1033    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 );
1034
1035    out[0].value = 0;
1036    out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1037    out[0].decl.NrTokens = 2;
1038    out[0].decl.File = file;
1039    out[0].decl.UsageMask = 0xf;
1040    out[0].decl.Interpolate = TGSI_INTERPOLATE_CONSTANT;
1041    out[0].decl.Semantic = 0;
1042
1043    out[1].value = 0;
1044    out[1].decl_range.First = first;
1045    out[1].decl_range.Last = first + count - 1;
1046 }
1047
1048 static void
1049 emit_immediate( struct ureg_program *ureg,
1050                 const unsigned *v,
1051                 unsigned type )
1052 {
1053    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 5 );
1054
1055    out[0].value = 0;
1056    out[0].imm.Type = TGSI_TOKEN_TYPE_IMMEDIATE;
1057    out[0].imm.NrTokens = 5;
1058    out[0].imm.DataType = type;
1059    out[0].imm.Padding = 0;
1060
1061    out[1].imm_data.Uint = v[0];
1062    out[2].imm_data.Uint = v[1];
1063    out[3].imm_data.Uint = v[2];
1064    out[4].imm_data.Uint = v[3];
1065 }
1066
1067
1068
1069
1070 static void emit_decls( struct ureg_program *ureg )
1071 {
1072    unsigned i;
1073
1074    if (ureg->processor == TGSI_PROCESSOR_VERTEX) {
1075       for (i = 0; i < UREG_MAX_INPUT; i++) {
1076          if (ureg->vs_inputs[i/32] & (1 << (i%32))) {
1077             emit_decl_range( ureg, TGSI_FILE_INPUT, i, 1 );
1078          }
1079       }
1080    } else if (ureg->processor == TGSI_PROCESSOR_FRAGMENT) {
1081       for (i = 0; i < ureg->nr_fs_inputs; i++) {
1082          emit_decl( ureg,
1083                     TGSI_FILE_INPUT,
1084                     i,
1085                     ureg->fs_input[i].semantic_name,
1086                     ureg->fs_input[i].semantic_index,
1087                     ureg->fs_input[i].interp );
1088       }
1089    } else {
1090       for (i = 0; i < ureg->nr_gs_inputs; i++) {
1091          emit_decl_range(ureg,
1092                          TGSI_FILE_INPUT,
1093                          ureg->gs_input[i].index,
1094                          1);
1095       }
1096    }
1097
1098    for (i = 0; i < ureg->nr_system_values; i++) {
1099       emit_decl(ureg,
1100                 TGSI_FILE_SYSTEM_VALUE,
1101                 ureg->system_value[i].index,
1102                 ureg->system_value[i].semantic_name,
1103                 ureg->system_value[i].semantic_index,
1104                 TGSI_INTERPOLATE_CONSTANT);
1105    }
1106
1107    for (i = 0; i < ureg->nr_outputs; i++) {
1108       emit_decl( ureg,
1109                  TGSI_FILE_OUTPUT,
1110                  i,
1111                  ureg->output[i].semantic_name,
1112                  ureg->output[i].semantic_index,
1113                  TGSI_INTERPOLATE_CONSTANT );
1114    }
1115
1116    for (i = 0; i < ureg->nr_samplers; i++) {
1117       emit_decl_range( ureg,
1118                        TGSI_FILE_SAMPLER,
1119                        ureg->sampler[i].Index, 1 );
1120    }
1121
1122    if (ureg->nr_constant_ranges) {
1123       for (i = 0; i < ureg->nr_constant_ranges; i++)
1124          emit_decl_range( ureg,
1125                           TGSI_FILE_CONSTANT,
1126                           ureg->constant_range[i].first,
1127                           (ureg->constant_range[i].last + 1 -
1128                            ureg->constant_range[i].first) );
1129    }
1130
1131    if (ureg->nr_temps) {
1132       emit_decl_range( ureg,
1133                        TGSI_FILE_TEMPORARY,
1134                        0, ureg->nr_temps );
1135    }
1136
1137    if (ureg->nr_addrs) {
1138       emit_decl_range( ureg,
1139                        TGSI_FILE_ADDRESS,
1140                        0, ureg->nr_addrs );
1141    }
1142
1143    if (ureg->nr_loops) {
1144       emit_decl_range(ureg,
1145                       TGSI_FILE_LOOP,
1146                       0,
1147                       ureg->nr_loops);
1148    }
1149
1150    if (ureg->nr_preds) {
1151       emit_decl_range(ureg,
1152                       TGSI_FILE_PREDICATE,
1153                       0,
1154                       ureg->nr_preds);
1155    }
1156
1157    for (i = 0; i < ureg->nr_immediates; i++) {
1158       emit_immediate( ureg,
1159                       ureg->immediate[i].value.u,
1160                       ureg->immediate[i].type );
1161    }
1162 }
1163
1164 /* Append the instruction tokens onto the declarations to build a
1165  * contiguous stream suitable to send to the driver.
1166  */
1167 static void copy_instructions( struct ureg_program *ureg )
1168 {
1169    unsigned nr_tokens = ureg->domain[DOMAIN_INSN].count;
1170    union tgsi_any_token *out = get_tokens( ureg,
1171                                            DOMAIN_DECL,
1172                                            nr_tokens );
1173
1174    memcpy(out,
1175           ureg->domain[DOMAIN_INSN].tokens,
1176           nr_tokens * sizeof out[0] );
1177 }
1178
1179
1180 static void
1181 fixup_header_size(struct ureg_program *ureg)
1182 {
1183    union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_DECL, 0 );
1184
1185    out->header.BodySize = ureg->domain[DOMAIN_DECL].count - 2;
1186 }
1187
1188
1189 static void
1190 emit_header( struct ureg_program *ureg )
1191 {
1192    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 );
1193
1194    out[0].header.HeaderSize = 2;
1195    out[0].header.BodySize = 0;
1196
1197    out[1].processor.Processor = ureg->processor;
1198    out[1].processor.Padding = 0;
1199 }
1200
1201
1202 const struct tgsi_token *ureg_finalize( struct ureg_program *ureg )
1203 {
1204    const struct tgsi_token *tokens;
1205
1206    emit_header( ureg );
1207    emit_decls( ureg );
1208    copy_instructions( ureg );
1209    fixup_header_size( ureg );
1210
1211    if (ureg->domain[0].tokens == error_tokens ||
1212        ureg->domain[1].tokens == error_tokens) {
1213       debug_printf("%s: error in generated shader\n", __FUNCTION__);
1214       assert(0);
1215       return NULL;
1216    }
1217
1218    tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token;
1219
1220    if (0) {
1221       debug_printf("%s: emitted shader %d tokens:\n", __FUNCTION__,
1222                    ureg->domain[DOMAIN_DECL].count);
1223       tgsi_dump( tokens, 0 );
1224    }
1225
1226 #if DEBUG
1227    if (tokens && !tgsi_sanity_check(tokens)) {
1228       debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n");
1229       tgsi_dump(tokens, 0);
1230       assert(0);
1231    }
1232 #endif
1233
1234
1235    return tokens;
1236 }
1237
1238
1239 void *ureg_create_shader( struct ureg_program *ureg,
1240                           struct pipe_context *pipe )
1241 {
1242    struct pipe_shader_state state;
1243
1244    state.tokens = ureg_finalize(ureg);
1245    if(!state.tokens)
1246       return NULL;
1247
1248    if (ureg->processor == TGSI_PROCESSOR_VERTEX)
1249       return pipe->create_vs_state( pipe, &state );
1250    else
1251       return pipe->create_fs_state( pipe, &state );
1252 }
1253
1254
1255 const struct tgsi_token *ureg_get_tokens( struct ureg_program *ureg,
1256                                           unsigned *nr_tokens )
1257 {
1258    const struct tgsi_token *tokens;
1259
1260    ureg_finalize(ureg);
1261
1262    tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token;
1263
1264    if (nr_tokens)
1265       *nr_tokens = ureg->domain[DOMAIN_DECL].size;
1266
1267    ureg->domain[DOMAIN_DECL].tokens = 0;
1268    ureg->domain[DOMAIN_DECL].size = 0;
1269    ureg->domain[DOMAIN_DECL].order = 0;
1270    ureg->domain[DOMAIN_DECL].count = 0;
1271
1272    return tokens;
1273 }
1274
1275
1276 struct ureg_program *ureg_create( unsigned processor )
1277 {
1278    struct ureg_program *ureg = CALLOC_STRUCT( ureg_program );
1279    if (ureg == NULL)
1280       return NULL;
1281
1282    ureg->processor = processor;
1283    return ureg;
1284 }
1285
1286
1287 void ureg_destroy( struct ureg_program *ureg )
1288 {
1289    unsigned i;
1290
1291    for (i = 0; i < Elements(ureg->domain); i++) {
1292       if (ureg->domain[i].tokens &&
1293           ureg->domain[i].tokens != error_tokens)
1294          FREE(ureg->domain[i].tokens);
1295    }
1296
1297    FREE(ureg);
1298 }