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