src/gallium/auxiliary/tgsi/tgsi_build.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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 #include "util/u_debug.h"
  29 #include "pipe/p_format.h"
  30 #include "pipe/p_shader_tokens.h"
  31 #include "tgsi_build.h"
  32 #include "tgsi_parse.h"
  33
  34
  35 /*
  36  * header
  37  */
  38
  39 struct tgsi_header
  40 tgsi_build_header( void )
  41 {
  42    struct tgsi_header header;
  43
  44    header.HeaderSize = 1;
  45    header.BodySize = 0;
  46
  47    return header;
  48 }
  49
  50 static void
  51 header_headersize_grow( struct tgsi_header *header )
  52 {
  53    assert( header->HeaderSize < 0xFF );
  54    assert( header->BodySize == 0 );
  55
  56    header->HeaderSize++;
  57 }
  58
  59 static void
  60 header_bodysize_grow( struct tgsi_header *header )
  61 {
  62    assert( header->BodySize < 0xFFFFFF );
  63
  64    header->BodySize++;
  65 }
  66
  67 struct tgsi_processor
  68 tgsi_build_processor(
  69    unsigned type,
  70    struct tgsi_header *header )
  71 {
  72    struct tgsi_processor processor;
  73
  74    processor.Processor = type;
  75    processor.Padding = 0;
  76
  77    header_headersize_grow( header );
  78
  79    return processor;
  80 }
  81
  82 /*
  83  * declaration
  84  */
  85
  86 static void
  87 declaration_grow(
  88    struct tgsi_declaration *declaration,
  89    struct tgsi_header *header )
  90 {
  91    assert( declaration->NrTokens < 0xFF );
  92
  93    declaration->NrTokens++;
  94
  95    header_bodysize_grow( header );
  96 }
  97
  98 static struct tgsi_declaration
  99 tgsi_default_declaration( void )
 100 {
 101    struct tgsi_declaration declaration;
 102
 103    declaration.Type = TGSI_TOKEN_TYPE_DECLARATION;
 104    declaration.NrTokens = 1;
 105    declaration.File = TGSI_FILE_NULL;
 106    declaration.UsageMask = TGSI_WRITEMASK_XYZW;
 107    declaration.Interpolate = 0;
 108    declaration.Dimension = 0;
 109    declaration.Semantic = 0;
 110    declaration.Invariant = 0;
 111    declaration.Local = 0;
 112    declaration.Padding = 0;
 113
 114    return declaration;
 115 }
 116
 117 static struct tgsi_declaration
 118 tgsi_build_declaration(
 119    unsigned file,
 120    unsigned usage_mask,
 121    unsigned interpolate,
 122    unsigned dimension,
 123    unsigned semantic,
 124    unsigned invariant,
 125    unsigned local,
 126    struct tgsi_header *header )
 127 {
 128    struct tgsi_declaration declaration;
 129
 130    assert( file < TGSI_FILE_COUNT );
 131    assert( interpolate < TGSI_INTERPOLATE_COUNT );
 132
 133    declaration = tgsi_default_declaration();
 134    declaration.File = file;
 135    declaration.UsageMask = usage_mask;
 136    declaration.Interpolate = interpolate;
 137    declaration.Dimension = dimension;
 138    declaration.Semantic = semantic;
 139    declaration.Invariant = invariant;
 140    declaration.Local = local;
 141
 142    header_bodysize_grow( header );
 143
 144    return declaration;
 145 }
 146
 147 static struct tgsi_declaration_range
 148 tgsi_default_declaration_range( void )
 149 {
 150    struct tgsi_declaration_range dr;
 151
 152    dr.First = 0;
 153    dr.Last = 0;
 154
 155    return dr;
 156 }
 157
 158 static struct tgsi_declaration_range
 159 tgsi_build_declaration_range(
 160    unsigned first,
 161    unsigned last,
 162    struct tgsi_declaration *declaration,
 163    struct tgsi_header *header )
 164 {
 165    struct tgsi_declaration_range declaration_range;
 166
 167    assert( last >= first );
 168    assert( last <= 0xFFFF );
 169
 170    declaration_range.First = first;
 171    declaration_range.Last = last;
 172
 173    declaration_grow( declaration, header );
 174
 175    return declaration_range;
 176 }
 177
 178 static struct tgsi_declaration_dimension
 179 tgsi_build_declaration_dimension(unsigned index_2d,
 180                                  struct tgsi_declaration *declaration,
 181                                  struct tgsi_header *header)
 182 {
 183    struct tgsi_declaration_dimension dd;
 184
 185    assert(index_2d <= 0xFFFF);
 186
 187    dd.Index2D = index_2d;
 188    dd.Padding = 0;
 189
 190    declaration_grow(declaration, header);
 191
 192    return dd;
 193 }
 194
 195 static struct tgsi_declaration_interp
 196 tgsi_default_declaration_interp( void )
 197 {
 198    struct tgsi_declaration_interp di;
 199
 200    di.Interpolate = TGSI_INTERPOLATE_CONSTANT;
 201    di.Centroid = 0;
 202    di.CylindricalWrap = 0;
 203    di.Padding = 0;
 204
 205    return di;
 206 }
 207
 208 static struct tgsi_declaration_interp
 209 tgsi_build_declaration_interp(unsigned interpolate,
 210                               unsigned centroid,
 211                               unsigned cylindrical_wrap,
 212                               struct tgsi_declaration *declaration,
 213                               struct tgsi_header *header)
 214 {
 215    struct tgsi_declaration_interp di;
 216
 217    di.Interpolate = interpolate;
 218    di.Centroid = centroid;
 219    di.CylindricalWrap = cylindrical_wrap;
 220    di.Padding = 0;
 221
 222    declaration_grow(declaration, header);
 223
 224    return di;
 225 }
 226
 227 static struct tgsi_declaration_semantic
 228 tgsi_default_declaration_semantic( void )
 229 {
 230    struct tgsi_declaration_semantic ds;
 231
 232    ds.Name = TGSI_SEMANTIC_POSITION;
 233    ds.Index = 0;
 234    ds.Padding = 0;
 235
 236    return ds;
 237 }
 238
 239 static struct tgsi_declaration_semantic
 240 tgsi_build_declaration_semantic(
 241    unsigned semantic_name,
 242    unsigned semantic_index,
 243    struct tgsi_declaration *declaration,
 244    struct tgsi_header *header )
 245 {
 246    struct tgsi_declaration_semantic ds;
 247
 248    assert( semantic_name <= TGSI_SEMANTIC_COUNT );
 249    assert( semantic_index <= 0xFFFF );
 250
 251    ds.Name = semantic_name;
 252    ds.Index = semantic_index;
 253    ds.Padding = 0;
 254
 255    declaration_grow( declaration, header );
 256
 257    return ds;
 258 }
 259
 260 static struct tgsi_declaration_resource
 261 tgsi_default_declaration_resource(void)
 262 {
 263    struct tgsi_declaration_resource dr;
 264
 265    dr.Resource = TGSI_TEXTURE_BUFFER;
 266    dr.Raw = 0;
 267    dr.Writable = 0;
 268    dr.Padding = 0;
 269
 270    return dr;
 271 }
 272
 273 static struct tgsi_declaration_resource
 274 tgsi_build_declaration_resource(unsigned texture,
 275                                 unsigned raw,
 276                                 unsigned writable,
 277                                 struct tgsi_declaration *declaration,
 278                                 struct tgsi_header *header)
 279 {
 280    struct tgsi_declaration_resource dr;
 281
 282    dr = tgsi_default_declaration_resource();
 283    dr.Resource = texture;
 284    dr.Raw = raw;
 285    dr.Writable = writable;
 286
 287    declaration_grow(declaration, header);
 288
 289    return dr;
 290 }
 291
 292 static struct tgsi_declaration_sampler_view
 293 tgsi_default_declaration_sampler_view(void)
 294 {
 295    struct tgsi_declaration_sampler_view dsv;
 296
 297    dsv.Resource = TGSI_TEXTURE_BUFFER;
 298    dsv.ReturnTypeX = PIPE_TYPE_UNORM;
 299    dsv.ReturnTypeY = PIPE_TYPE_UNORM;
 300    dsv.ReturnTypeZ = PIPE_TYPE_UNORM;
 301    dsv.ReturnTypeW = PIPE_TYPE_UNORM;
 302
 303    return dsv;
 304 }
 305
 306 static struct tgsi_declaration_sampler_view
 307 tgsi_build_declaration_sampler_view(unsigned texture,
 308                                     unsigned return_type_x,
 309                                     unsigned return_type_y,
 310                                     unsigned return_type_z,
 311                                     unsigned return_type_w,
 312                                     struct tgsi_declaration *declaration,
 313                                     struct tgsi_header *header)
 314 {
 315    struct tgsi_declaration_sampler_view dsv;
 316
 317    dsv = tgsi_default_declaration_sampler_view();
 318    dsv.Resource = texture;
 319    dsv.ReturnTypeX = return_type_x;
 320    dsv.ReturnTypeY = return_type_y;
 321    dsv.ReturnTypeZ = return_type_z;
 322    dsv.ReturnTypeW = return_type_w;
 323
 324    declaration_grow(declaration, header);
 325
 326    return dsv;
 327 }
 328
 329
 330 struct tgsi_full_declaration
 331 tgsi_default_full_declaration( void )
 332 {
 333    struct tgsi_full_declaration  full_declaration;
 334
 335    full_declaration.Declaration  = tgsi_default_declaration();
 336    full_declaration.Range = tgsi_default_declaration_range();
 337    full_declaration.Semantic = tgsi_default_declaration_semantic();
 338    full_declaration.Interp = tgsi_default_declaration_interp();
 339    full_declaration.ImmediateData.u = NULL;
 340    full_declaration.Resource = tgsi_default_declaration_resource();
 341    full_declaration.SamplerView = tgsi_default_declaration_sampler_view();
 342
 343    return full_declaration;
 344 }
 345
 346 unsigned
 347 tgsi_build_full_declaration(
 348    const struct tgsi_full_declaration *full_decl,
 349    struct tgsi_token *tokens,
 350    struct tgsi_header *header,
 351    unsigned maxsize )
 352 {
 353    unsigned size = 0;
 354    struct tgsi_declaration *declaration;
 355    struct tgsi_declaration_range *dr;
 356
 357    if( maxsize <= size )
 358       return 0;
 359    declaration = (struct tgsi_declaration *) &tokens[size];
 360    size++;
 361
 362    *declaration = tgsi_build_declaration(
 363       full_decl->Declaration.File,
 364       full_decl->Declaration.UsageMask,
 365       full_decl->Declaration.Interpolate,
 366       full_decl->Declaration.Dimension,
 367       full_decl->Declaration.Semantic,
 368       full_decl->Declaration.Invariant,
 369       full_decl->Declaration.Local,
 370       header );
 371
 372    if (maxsize <= size)
 373       return 0;
 374    dr = (struct tgsi_declaration_range *) &tokens[size];
 375    size++;
 376
 377    *dr = tgsi_build_declaration_range(
 378       full_decl->Range.First,
 379       full_decl->Range.Last,
 380       declaration,
 381       header );
 382
 383    if (full_decl->Declaration.Dimension) {
 384       struct tgsi_declaration_dimension *dd;
 385
 386       if (maxsize <= size) {
 387          return 0;
 388       }
 389       dd = (struct tgsi_declaration_dimension *)&tokens[size];
 390       size++;
 391
 392       *dd = tgsi_build_declaration_dimension(full_decl->Dim.Index2D,
 393                                              declaration,
 394                                              header);
 395    }
 396
 397    if (full_decl->Declaration.Interpolate) {
 398       struct tgsi_declaration_interp *di;
 399
 400       if (maxsize <= size) {
 401          return 0;
 402       }
 403       di = (struct tgsi_declaration_interp *)&tokens[size];
 404       size++;
 405
 406       *di = tgsi_build_declaration_interp(full_decl->Interp.Interpolate,
 407                                           full_decl->Interp.Centroid,
 408                                           full_decl->Interp.CylindricalWrap,
 409                                           declaration,
 410                                           header);
 411    }
 412
 413    if( full_decl->Declaration.Semantic ) {
 414       struct tgsi_declaration_semantic *ds;
 415
 416       if( maxsize <= size )
 417          return  0;
 418       ds = (struct tgsi_declaration_semantic *) &tokens[size];
 419       size++;
 420
 421       *ds = tgsi_build_declaration_semantic(
 422          full_decl->Semantic.Name,
 423          full_decl->Semantic.Index,
 424          declaration,
 425          header );
 426    }
 427
 428    if (full_decl->Declaration.File == TGSI_FILE_IMMEDIATE_ARRAY) {
 429       unsigned i, j;
 430       union tgsi_immediate_data *data;
 431
 432       for (i = 0; i <= dr->Last; ++i) {
 433          for (j = 0; j < 4; ++j) {
 434             unsigned idx = i*4 + j;
 435             if (maxsize <= size)
 436                return 0;
 437             data = (union tgsi_immediate_data *) &tokens[size];
 438             ++size;
 439
 440             *data = full_decl->ImmediateData.u[idx];
 441             declaration_grow( declaration, header );
 442          }
 443       }
 444    }
 445
 446    if (full_decl->Declaration.File == TGSI_FILE_RESOURCE) {
 447       struct tgsi_declaration_resource *dr;
 448
 449       if (maxsize <= size) {
 450          return  0;
 451       }
 452       dr = (struct tgsi_declaration_resource *)&tokens[size];
 453       size++;
 454
 455       *dr = tgsi_build_declaration_resource(full_decl->Resource.Resource,
 456                                             full_decl->Resource.Raw,
 457                                             full_decl->Resource.Writable,
 458                                             declaration,
 459                                             header);
 460    }
 461
 462    if (full_decl->Declaration.File == TGSI_FILE_SAMPLER_VIEW) {
 463       struct tgsi_declaration_sampler_view *dsv;
 464
 465       if (maxsize <= size) {
 466          return  0;
 467       }
 468       dsv = (struct tgsi_declaration_sampler_view *)&tokens[size];
 469       size++;
 470
 471       *dsv = tgsi_build_declaration_sampler_view(
 472          full_decl->SamplerView.Resource,
 473          full_decl->SamplerView.ReturnTypeX,
 474          full_decl->SamplerView.ReturnTypeY,
 475          full_decl->SamplerView.ReturnTypeZ,
 476          full_decl->SamplerView.ReturnTypeW,
 477          declaration,
 478          header);
 479    }
 480
 481    return size;
 482 }
 483
 484 /*
 485  * immediate
 486  */
 487
 488 static struct tgsi_immediate
 489 tgsi_default_immediate( void )
 490 {
 491    struct tgsi_immediate immediate;
 492
 493    immediate.Type = TGSI_TOKEN_TYPE_IMMEDIATE;
 494    immediate.NrTokens = 1;
 495    immediate.DataType = TGSI_IMM_FLOAT32;
 496    immediate.Padding = 0;
 497
 498    return immediate;
 499 }
 500
 501 static struct tgsi_immediate
 502 tgsi_build_immediate(
 503    struct tgsi_header *header,
 504    unsigned type )
 505 {
 506    struct tgsi_immediate immediate;
 507
 508    immediate = tgsi_default_immediate();
 509    immediate.DataType = type;
 510
 511    header_bodysize_grow( header );
 512
 513    return immediate;
 514 }
 515
 516 struct tgsi_full_immediate
 517 tgsi_default_full_immediate( void )
 518 {
 519    struct tgsi_full_immediate fullimm;
 520
 521    fullimm.Immediate = tgsi_default_immediate();
 522    fullimm.u[0].Float = 0.0f;
 523    fullimm.u[1].Float = 0.0f;
 524    fullimm.u[2].Float = 0.0f;
 525    fullimm.u[3].Float = 0.0f;
 526
 527    return fullimm;
 528 }
 529
 530 static void
 531 immediate_grow(
 532    struct tgsi_immediate *immediate,
 533    struct tgsi_header *header )
 534 {
 535    assert( immediate->NrTokens < 0xFF );
 536
 537    immediate->NrTokens++;
 538
 539    header_bodysize_grow( header );
 540 }
 541
 542 unsigned
 543 tgsi_build_full_immediate(
 544    const struct tgsi_full_immediate *full_imm,
 545    struct tgsi_token *tokens,
 546    struct tgsi_header *header,
 547    unsigned maxsize )
 548 {
 549    unsigned size = 0, i;
 550    struct tgsi_immediate *immediate;
 551
 552    if( maxsize <= size )
 553       return 0;
 554    immediate = (struct tgsi_immediate *) &tokens[size];
 555    size++;
 556
 557    *immediate = tgsi_build_immediate( header, full_imm->Immediate.DataType );
 558
 559    assert( full_imm->Immediate.NrTokens <= 4 + 1 );
 560
 561    for( i = 0; i < full_imm->Immediate.NrTokens - 1; i++ ) {
 562       union tgsi_immediate_data *data;
 563
 564       if( maxsize <= size )
 565          return  0;
 566
 567       data = (union tgsi_immediate_data *) &tokens[size];
 568       *data = full_imm->u[i];
 569
 570       immediate_grow( immediate, header );
 571       size++;
 572    }
 573
 574    return size;
 575 }
 576
 577 /*
 578  * instruction
 579  */
 580
 581 struct tgsi_instruction
 582 tgsi_default_instruction( void )
 583 {
 584    struct tgsi_instruction instruction;
 585
 586    instruction.Type = TGSI_TOKEN_TYPE_INSTRUCTION;
 587    instruction.NrTokens = 0;
 588    instruction.Opcode = TGSI_OPCODE_MOV;
 589    instruction.Saturate = TGSI_SAT_NONE;
 590    instruction.Predicate = 0;
 591    instruction.NumDstRegs = 1;
 592    instruction.NumSrcRegs = 1;
 593    instruction.Label = 0;
 594    instruction.Texture = 0;
 595    instruction.Padding  = 0;
 596
 597    return instruction;
 598 }
 599
 600 static struct tgsi_instruction
 601 tgsi_build_instruction(unsigned opcode,
 602                        unsigned saturate,
 603                        unsigned predicate,
 604                        unsigned num_dst_regs,
 605                        unsigned num_src_regs,
 606                        struct tgsi_header *header)
 607 {
 608    struct tgsi_instruction instruction;
 609
 610    assert (opcode <= TGSI_OPCODE_LAST);
 611    assert (saturate <= TGSI_SAT_MINUS_PLUS_ONE);
 612    assert (num_dst_regs <= 3);
 613    assert (num_src_regs <= 15);
 614
 615    instruction = tgsi_default_instruction();
 616    instruction.Opcode = opcode;
 617    instruction.Saturate = saturate;
 618    instruction.Predicate = predicate;
 619    instruction.NumDstRegs = num_dst_regs;
 620    instruction.NumSrcRegs = num_src_regs;
 621
 622    header_bodysize_grow( header );
 623
 624    return instruction;
 625 }
 626
 627 static void
 628 instruction_grow(
 629    struct tgsi_instruction *instruction,
 630    struct tgsi_header *header )
 631 {
 632    assert (instruction->NrTokens <   0xFF);
 633
 634    instruction->NrTokens++;
 635
 636    header_bodysize_grow( header );
 637 }
 638
 639 struct tgsi_instruction_predicate
 640 tgsi_default_instruction_predicate(void)
 641 {
 642    struct tgsi_instruction_predicate instruction_predicate;
 643
 644    instruction_predicate.SwizzleX = TGSI_SWIZZLE_X;
 645    instruction_predicate.SwizzleY = TGSI_SWIZZLE_Y;
 646    instruction_predicate.SwizzleZ = TGSI_SWIZZLE_Z;
 647    instruction_predicate.SwizzleW = TGSI_SWIZZLE_W;
 648    instruction_predicate.Negate = 0;
 649    instruction_predicate.Index = 0;
 650    instruction_predicate.Padding = 0;
 651
 652    return instruction_predicate;
 653 }
 654
 655 static struct tgsi_instruction_predicate
 656 tgsi_build_instruction_predicate(int index,
 657                                  unsigned negate,
 658                                  unsigned swizzleX,
 659                                  unsigned swizzleY,
 660                                  unsigned swizzleZ,
 661                                  unsigned swizzleW,
 662                                  struct tgsi_instruction *instruction,
 663                                  struct tgsi_header *header)
 664 {
 665    struct tgsi_instruction_predicate instruction_predicate;
 666
 667    instruction_predicate = tgsi_default_instruction_predicate();
 668    instruction_predicate.SwizzleX = swizzleX;
 669    instruction_predicate.SwizzleY = swizzleY;
 670    instruction_predicate.SwizzleZ = swizzleZ;
 671    instruction_predicate.SwizzleW = swizzleW;
 672    instruction_predicate.Negate = negate;
 673    instruction_predicate.Index = index;
 674
 675    instruction_grow(instruction, header);
 676
 677    return instruction_predicate;
 678 }
 679
 680 static struct tgsi_instruction_label
 681 tgsi_default_instruction_label( void )
 682 {
 683    struct tgsi_instruction_label instruction_label;
 684
 685    instruction_label.Label = 0;
 686    instruction_label.Padding = 0;
 687
 688    return instruction_label;
 689 }
 690
 691 static struct tgsi_instruction_label
 692 tgsi_build_instruction_label(
 693    unsigned label,
 694    struct tgsi_token  *prev_token,
 695    struct tgsi_instruction *instruction,
 696    struct tgsi_header *header )
 697 {
 698    struct tgsi_instruction_label instruction_label;
 699
 700    instruction_label.Label = label;
 701    instruction_label.Padding = 0;
 702    instruction->Label = 1;
 703
 704    instruction_grow( instruction, header );
 705
 706    return instruction_label;
 707 }
 708
 709 static struct tgsi_instruction_texture
 710 tgsi_default_instruction_texture( void )
 711 {
 712    struct tgsi_instruction_texture instruction_texture;
 713
 714    instruction_texture.Texture = TGSI_TEXTURE_UNKNOWN;
 715    instruction_texture.NumOffsets = 0;
 716    instruction_texture.Padding = 0;
 717
 718    return instruction_texture;
 719 }
 720
 721 static struct tgsi_instruction_texture
 722 tgsi_build_instruction_texture(
 723    unsigned texture,
 724    unsigned num_offsets,
 725    struct tgsi_token *prev_token,
 726    struct tgsi_instruction *instruction,
 727    struct tgsi_header *header )
 728 {
 729    struct tgsi_instruction_texture instruction_texture;
 730
 731    instruction_texture.Texture = texture;
 732    instruction_texture.NumOffsets = num_offsets;
 733    instruction_texture.Padding = 0;
 734    instruction->Texture = 1;
 735
 736    instruction_grow( instruction, header );
 737
 738    return instruction_texture;
 739 }
 740
 741
 742 static struct tgsi_texture_offset
 743 tgsi_default_texture_offset( void )
 744 {
 745    struct tgsi_texture_offset texture_offset;
 746
 747    texture_offset.Index = 0;
 748    texture_offset.File = 0;
 749    texture_offset.SwizzleX = 0;
 750    texture_offset.SwizzleY = 0;
 751    texture_offset.SwizzleZ = 0;
 752    texture_offset.Padding = 0;
 753
 754    return texture_offset;
 755 }
 756
 757 static struct tgsi_texture_offset
 758 tgsi_build_texture_offset(
 759    int index, int file, int swizzle_x, int swizzle_y, int swizzle_z,
 760    struct tgsi_token *prev_token,
 761    struct tgsi_instruction *instruction,
 762    struct tgsi_header *header )
 763 {
 764    struct tgsi_texture_offset texture_offset;
 765
 766    texture_offset.Index = index;
 767    texture_offset.File = file;
 768    texture_offset.SwizzleX = swizzle_x;
 769    texture_offset.SwizzleY = swizzle_y;
 770    texture_offset.SwizzleZ = swizzle_z;
 771    texture_offset.Padding = 0;
 772
 773    instruction_grow( instruction, header );
 774
 775    return texture_offset;
 776 }
 777
 778 static struct tgsi_src_register
 779 tgsi_default_src_register( void )
 780 {
 781    struct tgsi_src_register src_register;
 782
 783    src_register.File = TGSI_FILE_NULL;
 784    src_register.SwizzleX = TGSI_SWIZZLE_X;
 785    src_register.SwizzleY = TGSI_SWIZZLE_Y;
 786    src_register.SwizzleZ = TGSI_SWIZZLE_Z;
 787    src_register.SwizzleW = TGSI_SWIZZLE_W;
 788    src_register.Negate = 0;
 789    src_register.Absolute = 0;
 790    src_register.Indirect = 0;
 791    src_register.Dimension = 0;
 792    src_register.Index = 0;
 793
 794    return src_register;
 795 }
 796
 797 static struct tgsi_src_register
 798 tgsi_build_src_register(
 799    unsigned file,
 800    unsigned swizzle_x,
 801    unsigned swizzle_y,
 802    unsigned swizzle_z,
 803    unsigned swizzle_w,
 804    unsigned negate,
 805    unsigned absolute,
 806    unsigned indirect,
 807    unsigned dimension,
 808    int index,
 809    struct tgsi_instruction *instruction,
 810    struct tgsi_header *header )
 811 {
 812    struct tgsi_src_register   src_register;
 813
 814    assert( file < TGSI_FILE_COUNT );
 815    assert( swizzle_x <= TGSI_SWIZZLE_W );
 816    assert( swizzle_y <= TGSI_SWIZZLE_W );
 817    assert( swizzle_z <= TGSI_SWIZZLE_W );
 818    assert( swizzle_w <= TGSI_SWIZZLE_W );
 819    assert( negate <= 1 );
 820    assert( index >= -0x8000 && index <= 0x7FFF );
 821
 822    src_register.File = file;
 823    src_register.SwizzleX = swizzle_x;
 824    src_register.SwizzleY = swizzle_y;
 825    src_register.SwizzleZ = swizzle_z;
 826    src_register.SwizzleW = swizzle_w;
 827    src_register.Negate = negate;
 828    src_register.Absolute = absolute;
 829    src_register.Indirect = indirect;
 830    src_register.Dimension = dimension;
 831    src_register.Index = index;
 832
 833    instruction_grow( instruction, header );
 834
 835    return src_register;
 836 }
 837
 838 static struct tgsi_dimension
 839 tgsi_default_dimension( void )
 840 {
 841    struct tgsi_dimension dimension;
 842
 843    dimension.Indirect = 0;
 844    dimension.Dimension = 0;
 845    dimension.Padding = 0;
 846    dimension.Index = 0;
 847
 848    return dimension;
 849 }
 850
 851 static struct tgsi_full_src_register
 852 tgsi_default_full_src_register( void )
 853 {
 854    struct tgsi_full_src_register full_src_register;
 855
 856    full_src_register.Register = tgsi_default_src_register();
 857    full_src_register.Indirect = tgsi_default_src_register();
 858    full_src_register.Dimension = tgsi_default_dimension();
 859    full_src_register.DimIndirect = tgsi_default_src_register();
 860
 861    return full_src_register;
 862 }
 863
 864 static struct tgsi_dimension
 865 tgsi_build_dimension(
 866    unsigned indirect,
 867    unsigned index,
 868    struct tgsi_instruction *instruction,
 869    struct tgsi_header *header )
 870 {
 871    struct tgsi_dimension dimension;
 872
 873    dimension.Indirect = indirect;
 874    dimension.Dimension = 0;
 875    dimension.Padding = 0;
 876    dimension.Index = index;
 877
 878    instruction_grow( instruction, header );
 879
 880    return dimension;
 881 }
 882
 883 static struct tgsi_dst_register
 884 tgsi_default_dst_register( void )
 885 {
 886    struct tgsi_dst_register dst_register;
 887
 888    dst_register.File = TGSI_FILE_NULL;
 889    dst_register.WriteMask = TGSI_WRITEMASK_XYZW;
 890    dst_register.Indirect = 0;
 891    dst_register.Dimension = 0;
 892    dst_register.Index = 0;
 893    dst_register.Padding = 0;
 894
 895    return dst_register;
 896 }
 897
 898 static struct tgsi_dst_register
 899 tgsi_build_dst_register(
 900    unsigned file,
 901    unsigned mask,
 902    unsigned indirect,
 903    unsigned dimension,
 904    int index,
 905    struct tgsi_instruction *instruction,
 906    struct tgsi_header *header )
 907 {
 908    struct tgsi_dst_register dst_register;
 909
 910    assert( file < TGSI_FILE_COUNT );
 911    assert( mask <= TGSI_WRITEMASK_XYZW );
 912    assert( index >= -32768 && index <= 32767 );
 913
 914    dst_register.File = file;
 915    dst_register.WriteMask = mask;
 916    dst_register.Indirect = indirect;
 917    dst_register.Dimension = dimension;
 918    dst_register.Index = index;
 919    dst_register.Padding = 0;
 920
 921    instruction_grow( instruction, header );
 922
 923    return dst_register;
 924 }
 925
 926 static struct tgsi_full_dst_register
 927 tgsi_default_full_dst_register( void )
 928 {
 929    struct tgsi_full_dst_register full_dst_register;
 930
 931    full_dst_register.Register = tgsi_default_dst_register();
 932    full_dst_register.Indirect = tgsi_default_src_register();
 933    full_dst_register.Dimension = tgsi_default_dimension();
 934    full_dst_register.DimIndirect = tgsi_default_src_register();
 935
 936    return full_dst_register;
 937 }
 938
 939 struct tgsi_full_instruction
 940 tgsi_default_full_instruction( void )
 941 {
 942    struct tgsi_full_instruction full_instruction;
 943    unsigned i;
 944
 945    full_instruction.Instruction = tgsi_default_instruction();
 946    full_instruction.Predicate = tgsi_default_instruction_predicate();
 947    full_instruction.Label = tgsi_default_instruction_label();
 948    full_instruction.Texture = tgsi_default_instruction_texture();
 949    for( i = 0;  i < TGSI_FULL_MAX_TEX_OFFSETS; i++ ) {
 950       full_instruction.TexOffsets[i] = tgsi_default_texture_offset();
 951    }
 952    for( i = 0;  i < TGSI_FULL_MAX_DST_REGISTERS; i++ ) {
 953       full_instruction.Dst[i] = tgsi_default_full_dst_register();
 954    }
 955    for( i = 0;  i < TGSI_FULL_MAX_SRC_REGISTERS; i++ ) {
 956       full_instruction.Src[i] = tgsi_default_full_src_register();
 957    }
 958
 959    return full_instruction;
 960 }
 961
 962 unsigned
 963 tgsi_build_full_instruction(
 964    const struct tgsi_full_instruction *full_inst,
 965    struct  tgsi_token *tokens,
 966    struct  tgsi_header *header,
 967    unsigned  maxsize )
 968 {
 969    unsigned size = 0;
 970    unsigned i;
 971    struct tgsi_instruction *instruction;
 972    struct tgsi_token *prev_token;
 973
 974    if( maxsize <= size )
 975       return 0;
 976    instruction = (struct tgsi_instruction *) &tokens[size];
 977    size++;
 978
 979    *instruction = tgsi_build_instruction(full_inst->Instruction.Opcode,
 980                                          full_inst->Instruction.Saturate,
 981                                          full_inst->Instruction.Predicate,
 982                                          full_inst->Instruction.NumDstRegs,
 983                                          full_inst->Instruction.NumSrcRegs,
 984                                          header);
 985    prev_token = (struct tgsi_token  *) instruction;
 986
 987    if (full_inst->Instruction.Predicate) {
 988       struct tgsi_instruction_predicate *instruction_predicate;
 989
 990       if (maxsize <= size) {
 991          return 0;
 992       }
 993       instruction_predicate = (struct tgsi_instruction_predicate *)&tokens[size];
 994       size++;
 995
 996       *instruction_predicate =
 997          tgsi_build_instruction_predicate(full_inst->Predicate.Index,
 998                                           full_inst->Predicate.Negate,
 999                                           full_inst->Predicate.SwizzleX,
1000                                           full_inst->Predicate.SwizzleY,
1001                                           full_inst->Predicate.SwizzleZ,
1002                                           full_inst->Predicate.SwizzleW,
1003                                           instruction,
1004                                           header);
1005    }
1006
1007    if (full_inst->Instruction.Label) {
1008       struct tgsi_instruction_label *instruction_label;
1009
1010       if( maxsize <= size )
1011          return 0;
1012       instruction_label =
1013          (struct  tgsi_instruction_label *) &tokens[size];
1014       size++;
1015
1016       *instruction_label = tgsi_build_instruction_label(
1017          full_inst->Label.Label,
1018          prev_token,
1019          instruction,
1020          header );
1021       prev_token = (struct tgsi_token  *) instruction_label;
1022    }
1023
1024    if (full_inst->Instruction.Texture) {
1025       struct tgsi_instruction_texture *instruction_texture;
1026
1027       if( maxsize <= size )
1028          return 0;
1029       instruction_texture =
1030          (struct  tgsi_instruction_texture *) &tokens[size];
1031       size++;
1032
1033       *instruction_texture = tgsi_build_instruction_texture(
1034          full_inst->Texture.Texture,
1035          full_inst->Texture.NumOffsets,
1036          prev_token,
1037          instruction,
1038          header   );
1039       prev_token = (struct tgsi_token  *) instruction_texture;
1040
1041       for (i = 0; i < full_inst->Texture.NumOffsets; i++) {
1042          struct tgsi_texture_offset *texture_offset;
1043
1044          if ( maxsize <= size )
1045             return 0;
1046          texture_offset = (struct tgsi_texture_offset *)&tokens[size];
1047          size++;
1048          *texture_offset = tgsi_build_texture_offset(
1049             full_inst->TexOffsets[i].Index,
1050             full_inst->TexOffsets[i].File,
1051             full_inst->TexOffsets[i].SwizzleX,
1052             full_inst->TexOffsets[i].SwizzleY,
1053             full_inst->TexOffsets[i].SwizzleZ,
1054             prev_token,
1055             instruction,
1056             header);
1057          prev_token = (struct tgsi_token *) texture_offset;
1058       }
1059    }
1060    for( i = 0;  i <   full_inst->Instruction.NumDstRegs; i++ ) {
1061       const struct tgsi_full_dst_register *reg = &full_inst->Dst[i];
1062       struct tgsi_dst_register *dst_register;
1063
1064       if( maxsize <= size )
1065          return 0;
1066       dst_register = (struct tgsi_dst_register *) &tokens[size];
1067       size++;
1068
1069       *dst_register = tgsi_build_dst_register(
1070          reg->Register.File,
1071          reg->Register.WriteMask,
1072          reg->Register.Indirect,
1073          reg->Register.Dimension,
1074          reg->Register.Index,
1075          instruction,
1076          header );
1077
1078       if( reg->Register.Indirect ) {
1079          struct tgsi_src_register *ind;
1080
1081          if( maxsize <= size )
1082             return 0;
1083          ind = (struct tgsi_src_register *) &tokens[size];
1084          size++;
1085
1086          *ind = tgsi_build_src_register(
1087             reg->Indirect.File,
1088             reg->Indirect.SwizzleX,
1089             reg->Indirect.SwizzleY,
1090             reg->Indirect.SwizzleZ,
1091             reg->Indirect.SwizzleW,
1092             reg->Indirect.Negate,
1093             reg->Indirect.Absolute,
1094             reg->Indirect.Indirect,
1095             reg->Indirect.Dimension,
1096             reg->Indirect.Index,
1097             instruction,
1098             header );
1099       }
1100
1101       if( reg->Register.Dimension ) {
1102          struct  tgsi_dimension *dim;
1103
1104          assert( !reg->Dimension.Dimension );
1105
1106          if( maxsize <= size )
1107             return 0;
1108          dim = (struct tgsi_dimension *) &tokens[size];
1109          size++;
1110
1111          *dim = tgsi_build_dimension(
1112             reg->Dimension.Indirect,
1113             reg->Dimension.Index,
1114             instruction,
1115             header );
1116
1117          if( reg->Dimension.Indirect ) {
1118             struct tgsi_src_register *ind;
1119
1120             if( maxsize <= size )
1121                return 0;
1122             ind = (struct tgsi_src_register *) &tokens[size];
1123             size++;
1124
1125             *ind = tgsi_build_src_register(
1126                reg->DimIndirect.File,
1127                reg->DimIndirect.SwizzleX,
1128                reg->DimIndirect.SwizzleY,
1129                reg->DimIndirect.SwizzleZ,
1130                reg->DimIndirect.SwizzleW,
1131                reg->DimIndirect.Negate,
1132                reg->DimIndirect.Absolute,
1133                reg->DimIndirect.Indirect,
1134                reg->DimIndirect.Dimension,
1135                reg->DimIndirect.Index,
1136                instruction,
1137                header );
1138          }
1139       }
1140    }
1141
1142    for( i = 0;  i < full_inst->Instruction.NumSrcRegs; i++ ) {
1143       const struct tgsi_full_src_register *reg = &full_inst->Src[i];
1144       struct tgsi_src_register *src_register;
1145
1146       if( maxsize <= size )
1147          return 0;
1148       src_register = (struct tgsi_src_register *)  &tokens[size];
1149       size++;
1150
1151       *src_register = tgsi_build_src_register(
1152          reg->Register.File,
1153          reg->Register.SwizzleX,
1154          reg->Register.SwizzleY,
1155          reg->Register.SwizzleZ,
1156          reg->Register.SwizzleW,
1157          reg->Register.Negate,
1158          reg->Register.Absolute,
1159          reg->Register.Indirect,
1160          reg->Register.Dimension,
1161          reg->Register.Index,
1162          instruction,
1163          header );
1164
1165       if( reg->Register.Indirect ) {
1166          struct  tgsi_src_register *ind;
1167
1168          if( maxsize <= size )
1169             return 0;
1170          ind = (struct tgsi_src_register *) &tokens[size];
1171          size++;
1172
1173          *ind = tgsi_build_src_register(
1174             reg->Indirect.File,
1175             reg->Indirect.SwizzleX,
1176             reg->Indirect.SwizzleY,
1177             reg->Indirect.SwizzleZ,
1178             reg->Indirect.SwizzleW,
1179             reg->Indirect.Negate,
1180             reg->Indirect.Absolute,
1181             reg->Indirect.Indirect,
1182             reg->Indirect.Dimension,
1183             reg->Indirect.Index,
1184             instruction,
1185             header );
1186       }
1187
1188       if( reg->Register.Dimension ) {
1189          struct  tgsi_dimension *dim;
1190
1191          assert( !reg->Dimension.Dimension );
1192
1193          if( maxsize <= size )
1194             return 0;
1195          dim = (struct tgsi_dimension *) &tokens[size];
1196          size++;
1197
1198          *dim = tgsi_build_dimension(
1199             reg->Dimension.Indirect,
1200             reg->Dimension.Index,
1201             instruction,
1202             header );
1203
1204          if( reg->Dimension.Indirect ) {
1205             struct tgsi_src_register *ind;
1206
1207             if( maxsize <= size )
1208                return 0;
1209             ind = (struct tgsi_src_register *) &tokens[size];
1210             size++;
1211
1212             *ind = tgsi_build_src_register(
1213                reg->DimIndirect.File,
1214                reg->DimIndirect.SwizzleX,
1215                reg->DimIndirect.SwizzleY,
1216                reg->DimIndirect.SwizzleZ,
1217                reg->DimIndirect.SwizzleW,
1218                reg->DimIndirect.Negate,
1219                reg->DimIndirect.Absolute,
1220                reg->DimIndirect.Indirect,
1221                reg->DimIndirect.Dimension,
1222                reg->DimIndirect.Index,
1223                instruction,
1224                header );
1225          }
1226       }
1227    }
1228
1229    return size;
1230 }
1231
1232 static struct tgsi_property
1233 tgsi_default_property( void )
1234 {
1235    struct tgsi_property property;
1236
1237    property.Type = TGSI_TOKEN_TYPE_PROPERTY;
1238    property.NrTokens = 1;
1239    property.PropertyName = TGSI_PROPERTY_GS_INPUT_PRIM;
1240    property.Padding = 0;
1241
1242    return property;
1243 }
1244
1245 static struct tgsi_property
1246 tgsi_build_property(unsigned property_name,
1247                     struct tgsi_header *header)
1248 {
1249    struct tgsi_property property;
1250
1251    property = tgsi_default_property();
1252    property.PropertyName = property_name;
1253
1254    header_bodysize_grow( header );
1255
1256    return property;
1257 }
1258
1259
1260 struct tgsi_full_property
1261 tgsi_default_full_property( void )
1262 {
1263    struct tgsi_full_property  full_property;
1264
1265    full_property.Property  = tgsi_default_property();
1266    memset(full_property.u, 0,
1267           sizeof(struct tgsi_property_data) * 8);
1268
1269    return full_property;
1270 }
1271
1272 static void
1273 property_grow(
1274    struct tgsi_property *property,
1275    struct tgsi_header *header )
1276 {
1277    assert( property->NrTokens < 0xFF );
1278
1279    property->NrTokens++;
1280
1281    header_bodysize_grow( header );
1282 }
1283
1284 static struct tgsi_property_data
1285 tgsi_build_property_data(
1286    unsigned value,
1287    struct tgsi_property *property,
1288    struct tgsi_header *header )
1289 {
1290    struct tgsi_property_data property_data;
1291
1292    property_data.Data = value;
1293
1294    property_grow( property, header );
1295
1296    return property_data;
1297 }
1298
1299 unsigned
1300 tgsi_build_full_property(
1301    const struct tgsi_full_property *full_prop,
1302    struct tgsi_token *tokens,
1303    struct tgsi_header *header,
1304    unsigned maxsize )
1305 {
1306    unsigned size = 0, i;
1307    struct tgsi_property *property;
1308
1309    if( maxsize <= size )
1310       return 0;
1311    property = (struct tgsi_property *) &tokens[size];
1312    size++;
1313
1314    *property = tgsi_build_property(
1315       full_prop->Property.PropertyName,
1316       header );
1317
1318    assert( full_prop->Property.NrTokens <= 8 + 1 );
1319
1320    for( i = 0; i < full_prop->Property.NrTokens - 1; i++ ) {
1321       struct tgsi_property_data *data;
1322
1323       if( maxsize <= size )
1324          return  0;
1325       data = (struct tgsi_property_data *) &tokens[size];
1326       size++;
1327
1328       *data = tgsi_build_property_data(
1329          full_prop->u[i].Data,
1330          property,
1331          header );
1332    }
1333
1334    return size;
1335 }