src/gallium/auxiliary/tgsi/tgsi_ureg.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009-2010 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE, INC AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 #include "pipe/p_context.h"
  30 #include "pipe/p_state.h"
  31 #include "tgsi/tgsi_ureg.h"
  32 #include "tgsi/tgsi_build.h"
  33 #include "tgsi/tgsi_info.h"
  34 #include "tgsi/tgsi_dump.h"
  35 #include "tgsi/tgsi_sanity.h"
  36 #include "util/u_debug.h"
  37 #include "util/u_memory.h"
  38 #include "util/u_math.h"
  39 #include "util/u_bitmask.h"
  40
  41 union tgsi_any_token {
  42    struct tgsi_header header;
  43    struct tgsi_processor processor;
  44    struct tgsi_token token;
  45    struct tgsi_property prop;
  46    struct tgsi_property_data prop_data;
  47    struct tgsi_declaration decl;
  48    struct tgsi_declaration_range decl_range;
  49    struct tgsi_declaration_dimension decl_dim;
  50    struct tgsi_declaration_interp decl_interp;
  51    struct tgsi_declaration_semantic decl_semantic;
  52    struct tgsi_declaration_sampler_view decl_sampler_view;
  53    struct tgsi_declaration_array array;
  54    struct tgsi_immediate imm;
  55    union  tgsi_immediate_data imm_data;
  56    struct tgsi_instruction insn;
  57    struct tgsi_instruction_predicate insn_predicate;
  58    struct tgsi_instruction_label insn_label;
  59    struct tgsi_instruction_texture insn_texture;
  60    struct tgsi_texture_offset insn_texture_offset;
  61    struct tgsi_src_register src;
  62    struct tgsi_ind_register ind;
  63    struct tgsi_dimension dim;
  64    struct tgsi_dst_register dst;
  65    unsigned value;
  66 };
  67
  68
  69 struct ureg_tokens {
  70    union tgsi_any_token *tokens;
  71    unsigned size;
  72    unsigned order;
  73    unsigned count;
  74 };
  75
  76 #define UREG_MAX_INPUT PIPE_MAX_ATTRIBS
  77 #define UREG_MAX_SYSTEM_VALUE PIPE_MAX_ATTRIBS
  78 #define UREG_MAX_OUTPUT PIPE_MAX_SHADER_OUTPUTS
  79 #define UREG_MAX_CONSTANT_RANGE 32
  80 #define UREG_MAX_IMMEDIATE 4096
  81 #define UREG_MAX_ADDR 3
  82 #define UREG_MAX_PRED 1
  83 #define UREG_MAX_ARRAY_TEMPS 256
  84
  85 struct const_decl {
  86    struct {
  87       unsigned first;
  88       unsigned last;
  89    } constant_range[UREG_MAX_CONSTANT_RANGE];
  90    unsigned nr_constant_ranges;
  91 };
  92
  93 #define DOMAIN_DECL 0
  94 #define DOMAIN_INSN 1
  95
  96 struct ureg_program
  97 {
  98    unsigned processor;
  99    struct pipe_context *pipe;
 100
 101    struct {
 102       unsigned semantic_name;
 103       unsigned semantic_index;
 104       unsigned interp;
 105       unsigned char cylindrical_wrap;
 106       unsigned interp_location;
 107    } fs_input[UREG_MAX_INPUT];
 108    unsigned nr_fs_inputs;
 109
 110    unsigned vs_inputs[UREG_MAX_INPUT/32];
 111
 112    struct {
 113       unsigned index;
 114       unsigned semantic_name;
 115       unsigned semantic_index;
 116    } gs_input[UREG_MAX_INPUT];
 117    unsigned nr_gs_inputs;
 118
 119    struct {
 120       unsigned index;
 121       unsigned semantic_name;
 122       unsigned semantic_index;
 123    } system_value[UREG_MAX_SYSTEM_VALUE];
 124    unsigned nr_system_values;
 125
 126    struct {
 127       unsigned semantic_name;
 128       unsigned semantic_index;
 129       unsigned usage_mask; /* = TGSI_WRITEMASK_* */
 130    } output[UREG_MAX_OUTPUT];
 131    unsigned nr_outputs;
 132
 133    struct {
 134       union {
 135          float f[4];
 136          unsigned u[4];
 137          int i[4];
 138       } value;
 139       unsigned nr;
 140       unsigned type;
 141    } immediate[UREG_MAX_IMMEDIATE];
 142    unsigned nr_immediates;
 143
 144    struct ureg_src sampler[PIPE_MAX_SAMPLERS];
 145    unsigned nr_samplers;
 146
 147    struct {
 148       unsigned index;
 149       unsigned target;
 150       unsigned return_type_x;
 151       unsigned return_type_y;
 152       unsigned return_type_z;
 153       unsigned return_type_w;
 154    } sampler_view[PIPE_MAX_SHADER_SAMPLER_VIEWS];
 155    unsigned nr_sampler_views;
 156
 157    struct util_bitmask *free_temps;
 158    struct util_bitmask *local_temps;
 159    struct util_bitmask *decl_temps;
 160    unsigned nr_temps;
 161
 162    unsigned array_temps[UREG_MAX_ARRAY_TEMPS];
 163    unsigned nr_array_temps;
 164
 165    struct const_decl const_decls;
 166    struct const_decl const_decls2D[PIPE_MAX_CONSTANT_BUFFERS];
 167
 168    unsigned properties[TGSI_PROPERTY_COUNT];
 169
 170    unsigned nr_addrs;
 171    unsigned nr_preds;
 172    unsigned nr_instructions;
 173
 174    struct ureg_tokens domain[2];
 175 };
 176
 177 static union tgsi_any_token error_tokens[32];
 178
 179 static void tokens_error( struct ureg_tokens *tokens )
 180 {
 181    if (tokens->tokens && tokens->tokens != error_tokens)
 182       FREE(tokens->tokens);
 183
 184    tokens->tokens = error_tokens;
 185    tokens->size = Elements(error_tokens);
 186    tokens->count = 0;
 187 }
 188
 189
 190 static void tokens_expand( struct ureg_tokens *tokens,
 191                            unsigned count )
 192 {
 193    unsigned old_size = tokens->size * sizeof(unsigned);
 194
 195    if (tokens->tokens == error_tokens) {
 196       return;
 197    }
 198
 199    while (tokens->count + count > tokens->size) {
 200       tokens->size = (1 << ++tokens->order);
 201    }
 202
 203    tokens->tokens = REALLOC(tokens->tokens,
 204                             old_size,
 205                             tokens->size * sizeof(unsigned));
 206    if (tokens->tokens == NULL) {
 207       tokens_error(tokens);
 208    }
 209 }
 210
 211 static void set_bad( struct ureg_program *ureg )
 212 {
 213    tokens_error(&ureg->domain[0]);
 214 }
 215
 216
 217
 218 static union tgsi_any_token *get_tokens( struct ureg_program *ureg,
 219                                          unsigned domain,
 220                                          unsigned count )
 221 {
 222    struct ureg_tokens *tokens = &ureg->domain[domain];
 223    union tgsi_any_token *result;
 224
 225    if (tokens->count + count > tokens->size)
 226       tokens_expand(tokens, count);
 227
 228    result = &tokens->tokens[tokens->count];
 229    tokens->count += count;
 230    return result;
 231 }
 232
 233
 234 static union tgsi_any_token *retrieve_token( struct ureg_program *ureg,
 235                                             unsigned domain,
 236                                             unsigned nr )
 237 {
 238    if (ureg->domain[domain].tokens == error_tokens)
 239       return &error_tokens[0];
 240
 241    return &ureg->domain[domain].tokens[nr];
 242 }
 243
 244 void
 245 ureg_property(struct ureg_program *ureg, unsigned name, unsigned value)
 246 {
 247    assert(name < Elements(ureg->properties));
 248    ureg->properties[name] = value;
 249 }
 250
 251 struct ureg_src
 252 ureg_DECL_fs_input_cyl_centroid(struct ureg_program *ureg,
 253                        unsigned semantic_name,
 254                        unsigned semantic_index,
 255                        unsigned interp_mode,
 256                        unsigned cylindrical_wrap,
 257                        unsigned interp_location)
 258 {
 259    unsigned i;
 260
 261    for (i = 0; i < ureg->nr_fs_inputs; i++) {
 262       if (ureg->fs_input[i].semantic_name == semantic_name &&
 263           ureg->fs_input[i].semantic_index == semantic_index) {
 264          goto out;
 265       }
 266    }
 267
 268    if (ureg->nr_fs_inputs < UREG_MAX_INPUT) {
 269       ureg->fs_input[i].semantic_name = semantic_name;
 270       ureg->fs_input[i].semantic_index = semantic_index;
 271       ureg->fs_input[i].interp = interp_mode;
 272       ureg->fs_input[i].cylindrical_wrap = cylindrical_wrap;
 273       ureg->fs_input[i].interp_location = interp_location;
 274       ureg->nr_fs_inputs++;
 275    } else {
 276       set_bad(ureg);
 277    }
 278
 279 out:
 280    return ureg_src_register(TGSI_FILE_INPUT, i);
 281 }
 282
 283
 284 struct ureg_src
 285 ureg_DECL_vs_input( struct ureg_program *ureg,
 286                     unsigned index )
 287 {
 288    assert(ureg->processor == TGSI_PROCESSOR_VERTEX);
 289
 290    ureg->vs_inputs[index/32] |= 1 << (index % 32);
 291    return ureg_src_register( TGSI_FILE_INPUT, index );
 292 }
 293
 294
 295 struct ureg_src
 296 ureg_DECL_gs_input(struct ureg_program *ureg,
 297                    unsigned index,
 298                    unsigned semantic_name,
 299                    unsigned semantic_index)
 300 {
 301    if (ureg->nr_gs_inputs < UREG_MAX_INPUT) {
 302       ureg->gs_input[ureg->nr_gs_inputs].index = index;
 303       ureg->gs_input[ureg->nr_gs_inputs].semantic_name = semantic_name;
 304       ureg->gs_input[ureg->nr_gs_inputs].semantic_index = semantic_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_masked( struct ureg_program *ureg,
 336                          unsigned name,
 337                          unsigned index,
 338                          unsigned usage_mask )
 339 {
 340    unsigned i;
 341
 342    assert(usage_mask != 0);
 343
 344    for (i = 0; i < ureg->nr_outputs; i++) {
 345       if (ureg->output[i].semantic_name == name &&
 346           ureg->output[i].semantic_index == index) {
 347          ureg->output[i].usage_mask |= usage_mask;
 348          goto out;
 349       }
 350    }
 351
 352    if (ureg->nr_outputs < UREG_MAX_OUTPUT) {
 353       ureg->output[i].semantic_name = name;
 354       ureg->output[i].semantic_index = index;
 355       ureg->output[i].usage_mask = usage_mask;
 356       ureg->nr_outputs++;
 357    }
 358    else {
 359       set_bad( ureg );
 360    }
 361
 362 out:
 363    return ureg_dst_register( TGSI_FILE_OUTPUT, i );
 364 }
 365
 366
 367 struct ureg_dst
 368 ureg_DECL_output( struct ureg_program *ureg,
 369                   unsigned name,
 370                   unsigned index )
 371 {
 372    return ureg_DECL_output_masked(ureg, name, index, TGSI_WRITEMASK_XYZW);
 373 }
 374
 375
 376 /* Returns a new constant register.  Keep track of which have been
 377  * referred to so that we can emit decls later.
 378  *
 379  * Constant operands declared with this function must be addressed
 380  * with a two-dimensional index.
 381  *
 382  * There is nothing in this code to bind this constant to any tracked
 383  * value or manage any constant_buffer contents -- that's the
 384  * resposibility of the calling code.
 385  */
 386 void
 387 ureg_DECL_constant2D(struct ureg_program *ureg,
 388                      unsigned first,
 389                      unsigned last,
 390                      unsigned index2D)
 391 {
 392    struct const_decl *decl = &ureg->const_decls2D[index2D];
 393
 394    assert(index2D < PIPE_MAX_CONSTANT_BUFFERS);
 395
 396    if (decl->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) {
 397       uint i = decl->nr_constant_ranges++;
 398
 399       decl->constant_range[i].first = first;
 400       decl->constant_range[i].last = last;
 401    }
 402 }
 403
 404
 405 /* A one-dimensional, depricated version of ureg_DECL_constant2D().
 406  *
 407  * Constant operands declared with this function must be addressed
 408  * with a one-dimensional index.
 409  */
 410 struct ureg_src
 411 ureg_DECL_constant(struct ureg_program *ureg,
 412                    unsigned index)
 413 {
 414    struct const_decl *decl = &ureg->const_decls;
 415    unsigned minconst = index, maxconst = index;
 416    unsigned i;
 417
 418    /* Inside existing range?
 419     */
 420    for (i = 0; i < decl->nr_constant_ranges; i++) {
 421       if (decl->constant_range[i].first <= index &&
 422           decl->constant_range[i].last >= index) {
 423          goto out;
 424       }
 425    }
 426
 427    /* Extend existing range?
 428     */
 429    for (i = 0; i < decl->nr_constant_ranges; i++) {
 430       if (decl->constant_range[i].last == index - 1) {
 431          decl->constant_range[i].last = index;
 432          goto out;
 433       }
 434
 435       if (decl->constant_range[i].first == index + 1) {
 436          decl->constant_range[i].first = index;
 437          goto out;
 438       }
 439
 440       minconst = MIN2(minconst, decl->constant_range[i].first);
 441       maxconst = MAX2(maxconst, decl->constant_range[i].last);
 442    }
 443
 444    /* Create new range?
 445     */
 446    if (decl->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) {
 447       i = decl->nr_constant_ranges++;
 448       decl->constant_range[i].first = index;
 449       decl->constant_range[i].last = index;
 450       goto out;
 451    }
 452
 453    /* Collapse all ranges down to one:
 454     */
 455    i = 0;
 456    decl->constant_range[0].first = minconst;
 457    decl->constant_range[0].last = maxconst;
 458    decl->nr_constant_ranges = 1;
 459
 460 out:
 461    assert(i < decl->nr_constant_ranges);
 462    assert(decl->constant_range[i].first <= index);
 463    assert(decl->constant_range[i].last >= index);
 464    return ureg_src_register(TGSI_FILE_CONSTANT, index);
 465 }
 466
 467 static struct ureg_dst alloc_temporary( struct ureg_program *ureg,
 468                                         boolean local )
 469 {
 470    unsigned i;
 471
 472    /* Look for a released temporary.
 473     */
 474    for (i = util_bitmask_get_first_index(ureg->free_temps);
 475         i != UTIL_BITMASK_INVALID_INDEX;
 476         i = util_bitmask_get_next_index(ureg->free_temps, i + 1)) {
 477       if (util_bitmask_get(ureg->local_temps, i) == local)
 478          break;
 479    }
 480
 481    /* Or allocate a new one.
 482     */
 483    if (i == UTIL_BITMASK_INVALID_INDEX) {
 484       i = ureg->nr_temps++;
 485
 486       if (local)
 487          util_bitmask_set(ureg->local_temps, i);
 488
 489       /* Start a new declaration when the local flag changes */
 490       if (!i || util_bitmask_get(ureg->local_temps, i - 1) != local)
 491          util_bitmask_set(ureg->decl_temps, i);
 492    }
 493
 494    util_bitmask_clear(ureg->free_temps, i);
 495
 496    return ureg_dst_register( TGSI_FILE_TEMPORARY, i );
 497 }
 498
 499 struct ureg_dst ureg_DECL_temporary( struct ureg_program *ureg )
 500 {
 501    return alloc_temporary(ureg, FALSE);
 502 }
 503
 504 struct ureg_dst ureg_DECL_local_temporary( struct ureg_program *ureg )
 505 {
 506    return alloc_temporary(ureg, TRUE);
 507 }
 508
 509 struct ureg_dst ureg_DECL_array_temporary( struct ureg_program *ureg,
 510                                            unsigned size,
 511                                            boolean local )
 512 {
 513    unsigned i = ureg->nr_temps;
 514    struct ureg_dst dst = ureg_dst_register( TGSI_FILE_TEMPORARY, i );
 515
 516    if (local)
 517       util_bitmask_set(ureg->local_temps, i);
 518
 519    /* Always start a new declaration at the start */
 520    util_bitmask_set(ureg->decl_temps, i);
 521
 522    ureg->nr_temps += size;
 523
 524    /* and also at the end of the array */
 525    util_bitmask_set(ureg->decl_temps, ureg->nr_temps);
 526
 527    if (ureg->nr_array_temps < UREG_MAX_ARRAY_TEMPS) {
 528       ureg->array_temps[ureg->nr_array_temps++] = i;
 529       dst.ArrayID = ureg->nr_array_temps;
 530    }
 531
 532    return dst;
 533 }
 534
 535 void ureg_release_temporary( struct ureg_program *ureg,
 536                              struct ureg_dst tmp )
 537 {
 538    if(tmp.File == TGSI_FILE_TEMPORARY)
 539       util_bitmask_set(ureg->free_temps, tmp.Index);
 540 }
 541
 542
 543 /* Allocate a new address register.
 544  */
 545 struct ureg_dst ureg_DECL_address( struct ureg_program *ureg )
 546 {
 547    if (ureg->nr_addrs < UREG_MAX_ADDR)
 548       return ureg_dst_register( TGSI_FILE_ADDRESS, ureg->nr_addrs++ );
 549
 550    assert( 0 );
 551    return ureg_dst_register( TGSI_FILE_ADDRESS, 0 );
 552 }
 553
 554 /* Allocate a new predicate register.
 555  */
 556 struct ureg_dst
 557 ureg_DECL_predicate(struct ureg_program *ureg)
 558 {
 559    if (ureg->nr_preds < UREG_MAX_PRED) {
 560       return ureg_dst_register(TGSI_FILE_PREDICATE, ureg->nr_preds++);
 561    }
 562
 563    assert(0);
 564    return ureg_dst_register(TGSI_FILE_PREDICATE, 0);
 565 }
 566
 567 /* Allocate a new sampler.
 568  */
 569 struct ureg_src ureg_DECL_sampler( struct ureg_program *ureg,
 570                                    unsigned nr )
 571 {
 572    unsigned i;
 573
 574    for (i = 0; i < ureg->nr_samplers; i++)
 575       if (ureg->sampler[i].Index == nr)
 576          return ureg->sampler[i];
 577
 578    if (i < PIPE_MAX_SAMPLERS) {
 579       ureg->sampler[i] = ureg_src_register( TGSI_FILE_SAMPLER, nr );
 580       ureg->nr_samplers++;
 581       return ureg->sampler[i];
 582    }
 583
 584    assert( 0 );
 585    return ureg->sampler[0];
 586 }
 587
 588 /*
 589  * Allocate a new shader sampler view.
 590  */
 591 struct ureg_src
 592 ureg_DECL_sampler_view(struct ureg_program *ureg,
 593                        unsigned index,
 594                        unsigned target,
 595                        unsigned return_type_x,
 596                        unsigned return_type_y,
 597                        unsigned return_type_z,
 598                        unsigned return_type_w)
 599 {
 600    struct ureg_src reg = ureg_src_register(TGSI_FILE_SAMPLER_VIEW, index);
 601    uint i;
 602
 603    for (i = 0; i < ureg->nr_sampler_views; i++) {
 604       if (ureg->sampler_view[i].index == index) {
 605          return reg;
 606       }
 607    }
 608
 609    if (i < PIPE_MAX_SHADER_SAMPLER_VIEWS) {
 610       ureg->sampler_view[i].index = index;
 611       ureg->sampler_view[i].target = target;
 612       ureg->sampler_view[i].return_type_x = return_type_x;
 613       ureg->sampler_view[i].return_type_y = return_type_y;
 614       ureg->sampler_view[i].return_type_z = return_type_z;
 615       ureg->sampler_view[i].return_type_w = return_type_w;
 616       ureg->nr_sampler_views++;
 617       return reg;
 618    }
 619
 620    assert(0);
 621    return reg;
 622 }
 623
 624 static int
 625 match_or_expand_immediate64( const unsigned *v,
 626                              int type,
 627                              unsigned nr,
 628                              unsigned *v2,
 629                              unsigned *pnr2,
 630                              unsigned *swizzle )
 631 {
 632    unsigned nr2 = *pnr2;
 633    unsigned i, j;
 634    *swizzle = 0;
 635
 636    for (i = 0; i < nr; i += 2) {
 637       boolean found = FALSE;
 638
 639       for (j = 0; j < nr2 && !found; j += 2) {
 640          if (v[i] == v2[j] && v[i + 1] == v2[j + 1]) {
 641             *swizzle |= (j << (i * 2)) | ((j + 1) << ((i + 1) * 2));
 642             found = TRUE;
 643          }
 644       }
 645       if (!found) {
 646          if ((nr2) >= 4) {
 647             return FALSE;
 648          }
 649
 650          v2[nr2] = v[i];
 651          v2[nr2 + 1] = v[i + 1];
 652
 653          *swizzle |= (nr2 << (i * 2)) | ((nr2 + 1) << ((i + 1) * 2));
 654          nr2 += 2;
 655       }
 656    }
 657
 658    /* Actually expand immediate only when fully succeeded.
 659     */
 660    *pnr2 = nr2;
 661    return TRUE;
 662 }
 663
 664 static int
 665 match_or_expand_immediate( const unsigned *v,
 666                            int type,
 667                            unsigned nr,
 668                            unsigned *v2,
 669                            unsigned *pnr2,
 670                            unsigned *swizzle )
 671 {
 672    unsigned nr2 = *pnr2;
 673    unsigned i, j;
 674
 675    if (type == TGSI_IMM_FLOAT64)
 676       return match_or_expand_immediate64(v, type, nr, v2, pnr2, swizzle);
 677
 678    *swizzle = 0;
 679
 680    for (i = 0; i < nr; i++) {
 681       boolean found = FALSE;
 682
 683       for (j = 0; j < nr2 && !found; j++) {
 684          if (v[i] == v2[j]) {
 685             *swizzle |= j << (i * 2);
 686             found = TRUE;
 687          }
 688       }
 689
 690       if (!found) {
 691          if (nr2 >= 4) {
 692             return FALSE;
 693          }
 694
 695          v2[nr2] = v[i];
 696          *swizzle |= nr2 << (i * 2);
 697          nr2++;
 698       }
 699    }
 700
 701    /* Actually expand immediate only when fully succeeded.
 702     */
 703    *pnr2 = nr2;
 704    return TRUE;
 705 }
 706
 707
 708 static struct ureg_src
 709 decl_immediate( struct ureg_program *ureg,
 710                 const unsigned *v,
 711                 unsigned nr,
 712                 unsigned type )
 713 {
 714    unsigned i, j;
 715    unsigned swizzle = 0;
 716
 717    /* Could do a first pass where we examine all existing immediates
 718     * without expanding.
 719     */
 720
 721    for (i = 0; i < ureg->nr_immediates; i++) {
 722       if (ureg->immediate[i].type != type) {
 723          continue;
 724       }
 725       if (match_or_expand_immediate(v,
 726                                     type,
 727                                     nr,
 728                                     ureg->immediate[i].value.u,
 729                                     &ureg->immediate[i].nr,
 730                                     &swizzle)) {
 731          goto out;
 732       }
 733    }
 734
 735    if (ureg->nr_immediates < UREG_MAX_IMMEDIATE) {
 736       i = ureg->nr_immediates++;
 737       ureg->immediate[i].type = type;
 738       if (match_or_expand_immediate(v,
 739                                     type,
 740                                     nr,
 741                                     ureg->immediate[i].value.u,
 742                                     &ureg->immediate[i].nr,
 743                                     &swizzle)) {
 744          goto out;
 745       }
 746    }
 747
 748    set_bad(ureg);
 749
 750 out:
 751    /* Make sure that all referenced elements are from this immediate.
 752     * Has the effect of making size-one immediates into scalars.
 753     */
 754    if (type == TGSI_IMM_FLOAT64) {
 755       for (j = nr; j < 4; j+=2) {
 756          swizzle |= (swizzle & 0xf) << (j * 2);
 757       }
 758    } else {
 759       for (j = nr; j < 4; j++) {
 760          swizzle |= (swizzle & 0x3) << (j * 2);
 761       }
 762    }
 763    return ureg_swizzle(ureg_src_register(TGSI_FILE_IMMEDIATE, i),
 764                        (swizzle >> 0) & 0x3,
 765                        (swizzle >> 2) & 0x3,
 766                        (swizzle >> 4) & 0x3,
 767                        (swizzle >> 6) & 0x3);
 768 }
 769
 770
 771 struct ureg_src
 772 ureg_DECL_immediate( struct ureg_program *ureg,
 773                      const float *v,
 774                      unsigned nr )
 775 {
 776    union {
 777       float f[4];
 778       unsigned u[4];
 779    } fu;
 780    unsigned int i;
 781
 782    for (i = 0; i < nr; i++) {
 783       fu.f[i] = v[i];
 784    }
 785
 786    return decl_immediate(ureg, fu.u, nr, TGSI_IMM_FLOAT32);
 787 }
 788
 789 struct ureg_src
 790 ureg_DECL_immediate_f64( struct ureg_program *ureg,
 791                          const double *v,
 792                          unsigned nr )
 793 {
 794    union {
 795       unsigned u[4];
 796       double d[2];
 797    } fu;
 798    unsigned int i;
 799
 800    assert((nr / 2) < 3);
 801    for (i = 0; i < nr / 2; i++) {
 802       fu.d[i] = v[i];
 803    }
 804
 805    return decl_immediate(ureg, fu.u, nr, TGSI_IMM_FLOAT64);
 806 }
 807
 808 struct ureg_src
 809 ureg_DECL_immediate_uint( struct ureg_program *ureg,
 810                           const unsigned *v,
 811                           unsigned nr )
 812 {
 813    return decl_immediate(ureg, v, nr, TGSI_IMM_UINT32);
 814 }
 815
 816
 817 struct ureg_src
 818 ureg_DECL_immediate_block_uint( struct ureg_program *ureg,
 819                                 const unsigned *v,
 820                                 unsigned nr )
 821 {
 822    uint index;
 823    uint i;
 824
 825    if (ureg->nr_immediates + (nr + 3) / 4 > UREG_MAX_IMMEDIATE) {
 826       set_bad(ureg);
 827       return ureg_src_register(TGSI_FILE_IMMEDIATE, 0);
 828    }
 829
 830    index = ureg->nr_immediates;
 831    ureg->nr_immediates += (nr + 3) / 4;
 832
 833    for (i = index; i < ureg->nr_immediates; i++) {
 834       ureg->immediate[i].type = TGSI_IMM_UINT32;
 835       ureg->immediate[i].nr = nr > 4 ? 4 : nr;
 836       memcpy(ureg->immediate[i].value.u,
 837              &v[(i - index) * 4],
 838              ureg->immediate[i].nr * sizeof(uint));
 839       nr -= 4;
 840    }
 841
 842    return ureg_src_register(TGSI_FILE_IMMEDIATE, index);
 843 }
 844
 845
 846 struct ureg_src
 847 ureg_DECL_immediate_int( struct ureg_program *ureg,
 848                          const int *v,
 849                          unsigned nr )
 850 {
 851    return decl_immediate(ureg, (const unsigned *)v, nr, TGSI_IMM_INT32);
 852 }
 853
 854
 855 void
 856 ureg_emit_src( struct ureg_program *ureg,
 857                struct ureg_src src )
 858 {
 859    unsigned size = 1 + (src.Indirect ? 1 : 0) +
 860                    (src.Dimension ? (src.DimIndirect ? 2 : 1) : 0);
 861
 862    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size );
 863    unsigned n = 0;
 864
 865    assert(src.File != TGSI_FILE_NULL);
 866    assert(src.File < TGSI_FILE_COUNT);
 867
 868    out[n].value = 0;
 869    out[n].src.File = src.File;
 870    out[n].src.SwizzleX = src.SwizzleX;
 871    out[n].src.SwizzleY = src.SwizzleY;
 872    out[n].src.SwizzleZ = src.SwizzleZ;
 873    out[n].src.SwizzleW = src.SwizzleW;
 874    out[n].src.Index = src.Index;
 875    out[n].src.Negate = src.Negate;
 876    out[0].src.Absolute = src.Absolute;
 877    n++;
 878
 879    if (src.Indirect) {
 880       out[0].src.Indirect = 1;
 881       out[n].value = 0;
 882       out[n].ind.File = src.IndirectFile;
 883       out[n].ind.Swizzle = src.IndirectSwizzle;
 884       out[n].ind.Index = src.IndirectIndex;
 885       out[n].ind.ArrayID = src.ArrayID;
 886       n++;
 887    }
 888
 889    if (src.Dimension) {
 890       out[0].src.Dimension = 1;
 891       out[n].dim.Dimension = 0;
 892       out[n].dim.Padding = 0;
 893       if (src.DimIndirect) {
 894          out[n].dim.Indirect = 1;
 895          out[n].dim.Index = src.DimensionIndex;
 896          n++;
 897          out[n].value = 0;
 898          out[n].ind.File = src.DimIndFile;
 899          out[n].ind.Swizzle = src.DimIndSwizzle;
 900          out[n].ind.Index = src.DimIndIndex;
 901          out[n].ind.ArrayID = src.ArrayID;
 902       } else {
 903          out[n].dim.Indirect = 0;
 904          out[n].dim.Index = src.DimensionIndex;
 905       }
 906       n++;
 907    }
 908
 909    assert(n == size);
 910 }
 911
 912
 913 void
 914 ureg_emit_dst( struct ureg_program *ureg,
 915                struct ureg_dst dst )
 916 {
 917    unsigned size = (1 +
 918                     (dst.Indirect ? 1 : 0));
 919
 920    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size );
 921    unsigned n = 0;
 922
 923    assert(dst.File != TGSI_FILE_NULL);
 924    assert(dst.File != TGSI_FILE_CONSTANT);
 925    assert(dst.File != TGSI_FILE_INPUT);
 926    assert(dst.File != TGSI_FILE_SAMPLER);
 927    assert(dst.File != TGSI_FILE_SAMPLER_VIEW);
 928    assert(dst.File != TGSI_FILE_IMMEDIATE);
 929    assert(dst.File < TGSI_FILE_COUNT);
 930
 931    out[n].value = 0;
 932    out[n].dst.File = dst.File;
 933    out[n].dst.WriteMask = dst.WriteMask;
 934    out[n].dst.Indirect = dst.Indirect;
 935    out[n].dst.Index = dst.Index;
 936    n++;
 937
 938    if (dst.Indirect) {
 939       out[n].value = 0;
 940       out[n].ind.File = dst.IndirectFile;
 941       out[n].ind.Swizzle = dst.IndirectSwizzle;
 942       out[n].ind.Index = dst.IndirectIndex;
 943       out[n].ind.ArrayID = dst.ArrayID;
 944       n++;
 945    }
 946
 947    assert(n == size);
 948 }
 949
 950
 951 static void validate( unsigned opcode,
 952                       unsigned nr_dst,
 953                       unsigned nr_src )
 954 {
 955 #ifdef DEBUG
 956    const struct tgsi_opcode_info *info = tgsi_get_opcode_info( opcode );
 957    assert(info);
 958    if(info) {
 959       assert(nr_dst == info->num_dst);
 960       assert(nr_src == info->num_src);
 961    }
 962 #endif
 963 }
 964
 965 struct ureg_emit_insn_result
 966 ureg_emit_insn(struct ureg_program *ureg,
 967                unsigned opcode,
 968                boolean saturate,
 969                boolean predicate,
 970                boolean pred_negate,
 971                unsigned pred_swizzle_x,
 972                unsigned pred_swizzle_y,
 973                unsigned pred_swizzle_z,
 974                unsigned pred_swizzle_w,
 975                unsigned num_dst,
 976                unsigned num_src )
 977 {
 978    union tgsi_any_token *out;
 979    uint count = predicate ? 2 : 1;
 980    struct ureg_emit_insn_result result;
 981
 982    validate( opcode, num_dst, num_src );
 983
 984    out = get_tokens( ureg, DOMAIN_INSN, count );
 985    out[0].insn = tgsi_default_instruction();
 986    out[0].insn.Opcode = opcode;
 987    out[0].insn.Saturate = saturate;
 988    out[0].insn.NumDstRegs = num_dst;
 989    out[0].insn.NumSrcRegs = num_src;
 990
 991    result.insn_token = ureg->domain[DOMAIN_INSN].count - count;
 992    result.extended_token = result.insn_token;
 993
 994    if (predicate) {
 995       out[0].insn.Predicate = 1;
 996       out[1].insn_predicate = tgsi_default_instruction_predicate();
 997       out[1].insn_predicate.Negate = pred_negate;
 998       out[1].insn_predicate.SwizzleX = pred_swizzle_x;
 999       out[1].insn_predicate.SwizzleY = pred_swizzle_y;
1000       out[1].insn_predicate.SwizzleZ = pred_swizzle_z;
1001       out[1].insn_predicate.SwizzleW = pred_swizzle_w;
1002    }
1003
1004    ureg->nr_instructions++;
1005
1006    return result;
1007 }
1008
1009
1010 void
1011 ureg_emit_label(struct ureg_program *ureg,
1012                 unsigned extended_token,
1013                 unsigned *label_token )
1014 {
1015    union tgsi_any_token *out, *insn;
1016
1017    if(!label_token)
1018       return;
1019
1020    out = get_tokens( ureg, DOMAIN_INSN, 1 );
1021    out[0].value = 0;
1022
1023    insn = retrieve_token( ureg, DOMAIN_INSN, extended_token );
1024    insn->insn.Label = 1;
1025
1026    *label_token = ureg->domain[DOMAIN_INSN].count - 1;
1027 }
1028
1029 /* Will return a number which can be used in a label to point to the
1030  * next instruction to be emitted.
1031  */
1032 unsigned
1033 ureg_get_instruction_number( struct ureg_program *ureg )
1034 {
1035    return ureg->nr_instructions;
1036 }
1037
1038 /* Patch a given label (expressed as a token number) to point to a
1039  * given instruction (expressed as an instruction number).
1040  */
1041 void
1042 ureg_fixup_label(struct ureg_program *ureg,
1043                  unsigned label_token,
1044                  unsigned instruction_number )
1045 {
1046    union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, label_token );
1047
1048    out->insn_label.Label = instruction_number;
1049 }
1050
1051
1052 void
1053 ureg_emit_texture(struct ureg_program *ureg,
1054                   unsigned extended_token,
1055                   unsigned target, unsigned num_offsets)
1056 {
1057    union tgsi_any_token *out, *insn;
1058
1059    out = get_tokens( ureg, DOMAIN_INSN, 1 );
1060    insn = retrieve_token( ureg, DOMAIN_INSN, extended_token );
1061
1062    insn->insn.Texture = 1;
1063
1064    out[0].value = 0;
1065    out[0].insn_texture.Texture = target;
1066    out[0].insn_texture.NumOffsets = num_offsets;
1067 }
1068
1069 void
1070 ureg_emit_texture_offset(struct ureg_program *ureg,
1071                          const struct tgsi_texture_offset *offset)
1072 {
1073    union tgsi_any_token *out;
1074
1075    out = get_tokens( ureg, DOMAIN_INSN, 1);
1076
1077    out[0].value = 0;
1078    out[0].insn_texture_offset = *offset;
1079
1080 }
1081
1082
1083 void
1084 ureg_fixup_insn_size(struct ureg_program *ureg,
1085                      unsigned insn )
1086 {
1087    union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, insn );
1088
1089    assert(out->insn.Type == TGSI_TOKEN_TYPE_INSTRUCTION);
1090    out->insn.NrTokens = ureg->domain[DOMAIN_INSN].count - insn - 1;
1091 }
1092
1093
1094 void
1095 ureg_insn(struct ureg_program *ureg,
1096           unsigned opcode,
1097           const struct ureg_dst *dst,
1098           unsigned nr_dst,
1099           const struct ureg_src *src,
1100           unsigned nr_src )
1101 {
1102    struct ureg_emit_insn_result insn;
1103    unsigned i;
1104    boolean saturate;
1105    boolean predicate;
1106    boolean negate = FALSE;
1107    unsigned swizzle[4] = { 0 };
1108
1109    if (nr_dst && ureg_dst_is_empty(dst[0])) {
1110       return;
1111    }
1112
1113    saturate = nr_dst ? dst[0].Saturate : FALSE;
1114    predicate = nr_dst ? dst[0].Predicate : FALSE;
1115    if (predicate) {
1116       negate = dst[0].PredNegate;
1117       swizzle[0] = dst[0].PredSwizzleX;
1118       swizzle[1] = dst[0].PredSwizzleY;
1119       swizzle[2] = dst[0].PredSwizzleZ;
1120       swizzle[3] = dst[0].PredSwizzleW;
1121    }
1122
1123    insn = ureg_emit_insn(ureg,
1124                          opcode,
1125                          saturate,
1126                          predicate,
1127                          negate,
1128                          swizzle[0],
1129                          swizzle[1],
1130                          swizzle[2],
1131                          swizzle[3],
1132                          nr_dst,
1133                          nr_src);
1134
1135    for (i = 0; i < nr_dst; i++)
1136       ureg_emit_dst( ureg, dst[i] );
1137
1138    for (i = 0; i < nr_src; i++)
1139       ureg_emit_src( ureg, src[i] );
1140
1141    ureg_fixup_insn_size( ureg, insn.insn_token );
1142 }
1143
1144 void
1145 ureg_tex_insn(struct ureg_program *ureg,
1146               unsigned opcode,
1147               const struct ureg_dst *dst,
1148               unsigned nr_dst,
1149               unsigned target,
1150               const struct tgsi_texture_offset *texoffsets,
1151               unsigned nr_offset,
1152               const struct ureg_src *src,
1153               unsigned nr_src )
1154 {
1155    struct ureg_emit_insn_result insn;
1156    unsigned i;
1157    boolean saturate;
1158    boolean predicate;
1159    boolean negate = FALSE;
1160    unsigned swizzle[4] = { 0 };
1161
1162    if (nr_dst && ureg_dst_is_empty(dst[0])) {
1163       return;
1164    }
1165
1166    saturate = nr_dst ? dst[0].Saturate : FALSE;
1167    predicate = nr_dst ? dst[0].Predicate : FALSE;
1168    if (predicate) {
1169       negate = dst[0].PredNegate;
1170       swizzle[0] = dst[0].PredSwizzleX;
1171       swizzle[1] = dst[0].PredSwizzleY;
1172       swizzle[2] = dst[0].PredSwizzleZ;
1173       swizzle[3] = dst[0].PredSwizzleW;
1174    }
1175
1176    insn = ureg_emit_insn(ureg,
1177                          opcode,
1178                          saturate,
1179                          predicate,
1180                          negate,
1181                          swizzle[0],
1182                          swizzle[1],
1183                          swizzle[2],
1184                          swizzle[3],
1185                          nr_dst,
1186                          nr_src);
1187
1188    ureg_emit_texture( ureg, insn.extended_token, target, nr_offset );
1189
1190    for (i = 0; i < nr_offset; i++)
1191       ureg_emit_texture_offset( ureg, &texoffsets[i]);
1192
1193    for (i = 0; i < nr_dst; i++)
1194       ureg_emit_dst( ureg, dst[i] );
1195
1196    for (i = 0; i < nr_src; i++)
1197       ureg_emit_src( ureg, src[i] );
1198
1199    ureg_fixup_insn_size( ureg, insn.insn_token );
1200 }
1201
1202
1203 void
1204 ureg_label_insn(struct ureg_program *ureg,
1205                 unsigned opcode,
1206                 const struct ureg_src *src,
1207                 unsigned nr_src,
1208                 unsigned *label_token )
1209 {
1210    struct ureg_emit_insn_result insn;
1211    unsigned i;
1212
1213    insn = ureg_emit_insn(ureg,
1214                          opcode,
1215                          FALSE,
1216                          FALSE,
1217                          FALSE,
1218                          TGSI_SWIZZLE_X,
1219                          TGSI_SWIZZLE_Y,
1220                          TGSI_SWIZZLE_Z,
1221                          TGSI_SWIZZLE_W,
1222                          0,
1223                          nr_src);
1224
1225    ureg_emit_label( ureg, insn.extended_token, label_token );
1226
1227    for (i = 0; i < nr_src; i++)
1228       ureg_emit_src( ureg, src[i] );
1229
1230    ureg_fixup_insn_size( ureg, insn.insn_token );
1231 }
1232
1233
1234 static void
1235 emit_decl_semantic(struct ureg_program *ureg,
1236                    unsigned file,
1237                    unsigned index,
1238                    unsigned semantic_name,
1239                    unsigned semantic_index,
1240                    unsigned usage_mask)
1241 {
1242    union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 3);
1243
1244    out[0].value = 0;
1245    out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1246    out[0].decl.NrTokens = 3;
1247    out[0].decl.File = file;
1248    out[0].decl.UsageMask = usage_mask;
1249    out[0].decl.Semantic = 1;
1250
1251    out[1].value = 0;
1252    out[1].decl_range.First = index;
1253    out[1].decl_range.Last = index;
1254
1255    out[2].value = 0;
1256    out[2].decl_semantic.Name = semantic_name;
1257    out[2].decl_semantic.Index = semantic_index;
1258 }
1259
1260
1261 static void
1262 emit_decl_fs(struct ureg_program *ureg,
1263              unsigned file,
1264              unsigned index,
1265              unsigned semantic_name,
1266              unsigned semantic_index,
1267              unsigned interpolate,
1268              unsigned cylindrical_wrap,
1269              unsigned interpolate_location)
1270 {
1271    union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 4);
1272
1273    out[0].value = 0;
1274    out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1275    out[0].decl.NrTokens = 4;
1276    out[0].decl.File = file;
1277    out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW; /* FIXME! */
1278    out[0].decl.Interpolate = 1;
1279    out[0].decl.Semantic = 1;
1280
1281    out[1].value = 0;
1282    out[1].decl_range.First = index;
1283    out[1].decl_range.Last = index;
1284
1285    out[2].value = 0;
1286    out[2].decl_interp.Interpolate = interpolate;
1287    out[2].decl_interp.CylindricalWrap = cylindrical_wrap;
1288    out[2].decl_interp.Location = interpolate_location;
1289
1290    out[3].value = 0;
1291    out[3].decl_semantic.Name = semantic_name;
1292    out[3].decl_semantic.Index = semantic_index;
1293 }
1294
1295 static void
1296 emit_decl_temps( struct ureg_program *ureg,
1297                  unsigned first, unsigned last,
1298                  boolean local,
1299                  unsigned arrayid )
1300 {
1301    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL,
1302                                            arrayid ? 3 : 2 );
1303
1304    out[0].value = 0;
1305    out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1306    out[0].decl.NrTokens = 2;
1307    out[0].decl.File = TGSI_FILE_TEMPORARY;
1308    out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1309    out[0].decl.Local = local;
1310
1311    out[1].value = 0;
1312    out[1].decl_range.First = first;
1313    out[1].decl_range.Last = last;
1314
1315    if (arrayid) {
1316       out[0].decl.Array = 1;
1317       out[2].value = 0;
1318       out[2].array.ArrayID = arrayid;
1319    }
1320 }
1321
1322 static void emit_decl_range( struct ureg_program *ureg,
1323                              unsigned file,
1324                              unsigned first,
1325                              unsigned count )
1326 {
1327    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 );
1328
1329    out[0].value = 0;
1330    out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1331    out[0].decl.NrTokens = 2;
1332    out[0].decl.File = file;
1333    out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1334    out[0].decl.Semantic = 0;
1335
1336    out[1].value = 0;
1337    out[1].decl_range.First = first;
1338    out[1].decl_range.Last = first + count - 1;
1339 }
1340
1341 static void
1342 emit_decl_range2D(struct ureg_program *ureg,
1343                   unsigned file,
1344                   unsigned first,
1345                   unsigned last,
1346                   unsigned index2D)
1347 {
1348    union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 3);
1349
1350    out[0].value = 0;
1351    out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1352    out[0].decl.NrTokens = 3;
1353    out[0].decl.File = file;
1354    out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1355    out[0].decl.Dimension = 1;
1356
1357    out[1].value = 0;
1358    out[1].decl_range.First = first;
1359    out[1].decl_range.Last = last;
1360
1361    out[2].value = 0;
1362    out[2].decl_dim.Index2D = index2D;
1363 }
1364
1365 static void
1366 emit_decl_sampler_view(struct ureg_program *ureg,
1367                        unsigned index,
1368                        unsigned target,
1369                        unsigned return_type_x,
1370                        unsigned return_type_y,
1371                        unsigned return_type_z,
1372                        unsigned return_type_w )
1373 {
1374    union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 3);
1375
1376    out[0].value = 0;
1377    out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1378    out[0].decl.NrTokens = 3;
1379    out[0].decl.File = TGSI_FILE_SAMPLER_VIEW;
1380    out[0].decl.UsageMask = 0xf;
1381
1382    out[1].value = 0;
1383    out[1].decl_range.First = index;
1384    out[1].decl_range.Last = index;
1385
1386    out[2].value = 0;
1387    out[2].decl_sampler_view.Resource    = target;
1388    out[2].decl_sampler_view.ReturnTypeX = return_type_x;
1389    out[2].decl_sampler_view.ReturnTypeY = return_type_y;
1390    out[2].decl_sampler_view.ReturnTypeZ = return_type_z;
1391    out[2].decl_sampler_view.ReturnTypeW = return_type_w;
1392 }
1393
1394 static void
1395 emit_immediate( struct ureg_program *ureg,
1396                 const unsigned *v,
1397                 unsigned type )
1398 {
1399    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 5 );
1400
1401    out[0].value = 0;
1402    out[0].imm.Type = TGSI_TOKEN_TYPE_IMMEDIATE;
1403    out[0].imm.NrTokens = 5;
1404    out[0].imm.DataType = type;
1405    out[0].imm.Padding = 0;
1406
1407    out[1].imm_data.Uint = v[0];
1408    out[2].imm_data.Uint = v[1];
1409    out[3].imm_data.Uint = v[2];
1410    out[4].imm_data.Uint = v[3];
1411 }
1412
1413 static void
1414 emit_property(struct ureg_program *ureg,
1415               unsigned name,
1416               unsigned data)
1417 {
1418    union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 2);
1419
1420    out[0].value = 0;
1421    out[0].prop.Type = TGSI_TOKEN_TYPE_PROPERTY;
1422    out[0].prop.NrTokens = 2;
1423    out[0].prop.PropertyName = name;
1424
1425    out[1].prop_data.Data = data;
1426 }
1427
1428
1429 static void emit_decls( struct ureg_program *ureg )
1430 {
1431    unsigned i;
1432
1433    for (i = 0; i < Elements(ureg->properties); i++)
1434       if (ureg->properties[i] != ~0)
1435          emit_property(ureg, i, ureg->properties[i]);
1436
1437    if (ureg->processor == TGSI_PROCESSOR_VERTEX) {
1438       for (i = 0; i < UREG_MAX_INPUT; i++) {
1439          if (ureg->vs_inputs[i/32] & (1 << (i%32))) {
1440             emit_decl_range( ureg, TGSI_FILE_INPUT, i, 1 );
1441          }
1442       }
1443    } else if (ureg->processor == TGSI_PROCESSOR_FRAGMENT) {
1444       for (i = 0; i < ureg->nr_fs_inputs; i++) {
1445          emit_decl_fs(ureg,
1446                       TGSI_FILE_INPUT,
1447                       i,
1448                       ureg->fs_input[i].semantic_name,
1449                       ureg->fs_input[i].semantic_index,
1450                       ureg->fs_input[i].interp,
1451                       ureg->fs_input[i].cylindrical_wrap,
1452                       ureg->fs_input[i].interp_location);
1453       }
1454    } else {
1455       for (i = 0; i < ureg->nr_gs_inputs; i++) {
1456          emit_decl_semantic(ureg,
1457                             TGSI_FILE_INPUT,
1458                             ureg->gs_input[i].index,
1459                             ureg->gs_input[i].semantic_name,
1460                             ureg->gs_input[i].semantic_index,
1461                             TGSI_WRITEMASK_XYZW);
1462       }
1463    }
1464
1465    for (i = 0; i < ureg->nr_system_values; i++) {
1466       emit_decl_semantic(ureg,
1467                          TGSI_FILE_SYSTEM_VALUE,
1468                          ureg->system_value[i].index,
1469                          ureg->system_value[i].semantic_name,
1470                          ureg->system_value[i].semantic_index,
1471                          TGSI_WRITEMASK_XYZW);
1472    }
1473
1474    for (i = 0; i < ureg->nr_outputs; i++) {
1475       emit_decl_semantic(ureg,
1476                          TGSI_FILE_OUTPUT,
1477                          i,
1478                          ureg->output[i].semantic_name,
1479                          ureg->output[i].semantic_index,
1480                          ureg->output[i].usage_mask);
1481    }
1482
1483    for (i = 0; i < ureg->nr_samplers; i++) {
1484       emit_decl_range( ureg,
1485                        TGSI_FILE_SAMPLER,
1486                        ureg->sampler[i].Index, 1 );
1487    }
1488
1489    for (i = 0; i < ureg->nr_sampler_views; i++) {
1490       emit_decl_sampler_view(ureg,
1491                              ureg->sampler_view[i].index,
1492                              ureg->sampler_view[i].target,
1493                              ureg->sampler_view[i].return_type_x,
1494                              ureg->sampler_view[i].return_type_y,
1495                              ureg->sampler_view[i].return_type_z,
1496                              ureg->sampler_view[i].return_type_w);
1497    }
1498
1499    if (ureg->const_decls.nr_constant_ranges) {
1500       for (i = 0; i < ureg->const_decls.nr_constant_ranges; i++) {
1501          emit_decl_range(ureg,
1502                          TGSI_FILE_CONSTANT,
1503                          ureg->const_decls.constant_range[i].first,
1504                          ureg->const_decls.constant_range[i].last - ureg->const_decls.constant_range[i].first + 1);
1505       }
1506    }
1507
1508    for (i = 0; i < PIPE_MAX_CONSTANT_BUFFERS; i++) {
1509       struct const_decl *decl = &ureg->const_decls2D[i];
1510
1511       if (decl->nr_constant_ranges) {
1512          uint j;
1513
1514          for (j = 0; j < decl->nr_constant_ranges; j++) {
1515             emit_decl_range2D(ureg,
1516                               TGSI_FILE_CONSTANT,
1517                               decl->constant_range[j].first,
1518                               decl->constant_range[j].last,
1519                               i);
1520          }
1521       }
1522    }
1523
1524    if (ureg->nr_temps) {
1525       unsigned array = 0;
1526       for (i = 0; i < ureg->nr_temps;) {
1527          boolean local = util_bitmask_get(ureg->local_temps, i);
1528          unsigned first = i;
1529          i = util_bitmask_get_next_index(ureg->decl_temps, i + 1);
1530          if (i == UTIL_BITMASK_INVALID_INDEX)
1531             i = ureg->nr_temps;
1532
1533          if (array < ureg->nr_array_temps && ureg->array_temps[array] == first)
1534             emit_decl_temps( ureg, first, i - 1, local, ++array );
1535          else
1536             emit_decl_temps( ureg, first, i - 1, local, 0 );
1537       }
1538    }
1539
1540    if (ureg->nr_addrs) {
1541       emit_decl_range( ureg,
1542                        TGSI_FILE_ADDRESS,
1543                        0, ureg->nr_addrs );
1544    }
1545
1546    if (ureg->nr_preds) {
1547       emit_decl_range(ureg,
1548                       TGSI_FILE_PREDICATE,
1549                       0,
1550                       ureg->nr_preds);
1551    }
1552
1553    for (i = 0; i < ureg->nr_immediates; i++) {
1554       emit_immediate( ureg,
1555                       ureg->immediate[i].value.u,
1556                       ureg->immediate[i].type );
1557    }
1558 }
1559
1560 /* Append the instruction tokens onto the declarations to build a
1561  * contiguous stream suitable to send to the driver.
1562  */
1563 static void copy_instructions( struct ureg_program *ureg )
1564 {
1565    unsigned nr_tokens = ureg->domain[DOMAIN_INSN].count;
1566    union tgsi_any_token *out = get_tokens( ureg,
1567                                            DOMAIN_DECL,
1568                                            nr_tokens );
1569
1570    memcpy(out,
1571           ureg->domain[DOMAIN_INSN].tokens,
1572           nr_tokens * sizeof out[0] );
1573 }
1574
1575
1576 static void
1577 fixup_header_size(struct ureg_program *ureg)
1578 {
1579    union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_DECL, 0 );
1580
1581    out->header.BodySize = ureg->domain[DOMAIN_DECL].count - 2;
1582 }
1583
1584
1585 static void
1586 emit_header( struct ureg_program *ureg )
1587 {
1588    union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 );
1589
1590    out[0].header.HeaderSize = 2;
1591    out[0].header.BodySize = 0;
1592
1593    out[1].processor.Processor = ureg->processor;
1594    out[1].processor.Padding = 0;
1595 }
1596
1597
1598 const struct tgsi_token *ureg_finalize( struct ureg_program *ureg )
1599 {
1600    const struct tgsi_token *tokens;
1601
1602    emit_header( ureg );
1603    emit_decls( ureg );
1604    copy_instructions( ureg );
1605    fixup_header_size( ureg );
1606
1607    if (ureg->domain[0].tokens == error_tokens ||
1608        ureg->domain[1].tokens == error_tokens) {
1609       debug_printf("%s: error in generated shader\n", __FUNCTION__);
1610       assert(0);
1611       return NULL;
1612    }
1613
1614    tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token;
1615
1616    if (0) {
1617       debug_printf("%s: emitted shader %d tokens:\n", __FUNCTION__,
1618                    ureg->domain[DOMAIN_DECL].count);
1619       tgsi_dump( tokens, 0 );
1620    }
1621
1622 #if DEBUG
1623    if (tokens && !tgsi_sanity_check(tokens)) {
1624       debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n");
1625       tgsi_dump(tokens, 0);
1626       assert(0);
1627    }
1628 #endif
1629
1630
1631    return tokens;
1632 }
1633
1634
1635 void *ureg_create_shader( struct ureg_program *ureg,
1636                           struct pipe_context *pipe,
1637                           const struct pipe_stream_output_info *so )
1638 {
1639    struct pipe_shader_state state;
1640
1641    state.tokens = ureg_finalize(ureg);
1642    if(!state.tokens)
1643       return NULL;
1644
1645    if (so)
1646       state.stream_output = *so;
1647    else
1648       memset(&state.stream_output, 0, sizeof(state.stream_output));
1649
1650    if (ureg->processor == TGSI_PROCESSOR_VERTEX)
1651       return pipe->create_vs_state( pipe, &state );
1652    else
1653       return pipe->create_fs_state( pipe, &state );
1654 }
1655
1656
1657 const struct tgsi_token *ureg_get_tokens( struct ureg_program *ureg,
1658                                           unsigned *nr_tokens )
1659 {
1660    const struct tgsi_token *tokens;
1661
1662    ureg_finalize(ureg);
1663
1664    tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token;
1665
1666    if (nr_tokens)
1667       *nr_tokens = ureg->domain[DOMAIN_DECL].size;
1668
1669    ureg->domain[DOMAIN_DECL].tokens = 0;
1670    ureg->domain[DOMAIN_DECL].size = 0;
1671    ureg->domain[DOMAIN_DECL].order = 0;
1672    ureg->domain[DOMAIN_DECL].count = 0;
1673
1674    return tokens;
1675 }
1676
1677
1678 void ureg_free_tokens( const struct tgsi_token *tokens )
1679 {
1680    FREE((struct tgsi_token *)tokens);
1681 }
1682
1683
1684 struct ureg_program *ureg_create( unsigned processor )
1685 {
1686    int i;
1687    struct ureg_program *ureg = CALLOC_STRUCT( ureg_program );
1688    if (ureg == NULL)
1689       goto no_ureg;
1690
1691    ureg->processor = processor;
1692
1693    for (i = 0; i < Elements(ureg->properties); i++)
1694       ureg->properties[i] = ~0;
1695
1696    ureg->free_temps = util_bitmask_create();
1697    if (ureg->free_temps == NULL)
1698       goto no_free_temps;
1699
1700    ureg->local_temps = util_bitmask_create();
1701    if (ureg->local_temps == NULL)
1702       goto no_local_temps;
1703
1704    ureg->decl_temps = util_bitmask_create();
1705    if (ureg->decl_temps == NULL)
1706       goto no_decl_temps;
1707
1708    return ureg;
1709
1710 no_decl_temps:
1711    util_bitmask_destroy(ureg->local_temps);
1712 no_local_temps:
1713    util_bitmask_destroy(ureg->free_temps);
1714 no_free_temps:
1715    FREE(ureg);
1716 no_ureg:
1717    return NULL;
1718 }
1719
1720
1721 unsigned
1722 ureg_get_nr_outputs( const struct ureg_program *ureg )
1723 {
1724    if (!ureg)
1725       return 0;
1726    return ureg->nr_outputs;
1727 }
1728
1729
1730 void ureg_destroy( struct ureg_program *ureg )
1731 {
1732    unsigned i;
1733
1734    for (i = 0; i < Elements(ureg->domain); i++) {
1735       if (ureg->domain[i].tokens &&
1736           ureg->domain[i].tokens != error_tokens)
1737          FREE(ureg->domain[i].tokens);
1738    }
1739
1740    util_bitmask_destroy(ureg->free_temps);
1741    util_bitmask_destroy(ureg->local_temps);
1742    util_bitmask_destroy(ureg->decl_temps);
1743
1744    FREE(ureg);
1745 }