1 /**************************************************************************
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
28 #include "util/u_debug.h"
29 #include "pipe/p_shader_tokens.h"
30 #include "tgsi_build.h"
31 #include "tgsi_parse.h"
38 tgsi_build_version( void )
40 struct tgsi_version version;
42 version.MajorVersion = 1;
43 version.MinorVersion = 1;
54 tgsi_build_header( void )
56 struct tgsi_header header;
58 header.HeaderSize = 1;
65 header_headersize_grow( struct tgsi_header *header )
67 assert( header->HeaderSize < 0xFF );
68 assert( header->BodySize == 0 );
74 header_bodysize_grow( struct tgsi_header *header )
76 assert( header->BodySize < 0xFFFFFF );
82 tgsi_default_processor( void )
84 struct tgsi_processor processor;
86 processor.Processor = TGSI_PROCESSOR_FRAGMENT;
87 processor.Padding = 0;
95 struct tgsi_header *header )
97 struct tgsi_processor processor;
99 processor = tgsi_default_processor();
100 processor.Processor = type;
102 header_headersize_grow( header );
111 struct tgsi_declaration
112 tgsi_default_declaration( void )
114 struct tgsi_declaration declaration;
116 declaration.Type = TGSI_TOKEN_TYPE_DECLARATION;
117 declaration.NrTokens = 1;
118 declaration.File = TGSI_FILE_NULL;
119 declaration.UsageMask = TGSI_WRITEMASK_XYZW;
120 declaration.Interpolate = TGSI_INTERPOLATE_CONSTANT;
121 declaration.Semantic = 0;
122 declaration.Centroid = 0;
123 declaration.Invariant = 0;
124 declaration.Padding = 0;
125 declaration.Extended = 0;
130 struct tgsi_declaration
131 tgsi_build_declaration(
134 unsigned interpolate,
138 struct tgsi_header *header )
140 struct tgsi_declaration declaration;
142 assert( file < TGSI_FILE_COUNT );
143 assert( interpolate < TGSI_INTERPOLATE_COUNT );
145 declaration = tgsi_default_declaration();
146 declaration.File = file;
147 declaration.UsageMask = usage_mask;
148 declaration.Interpolate = interpolate;
149 declaration.Semantic = semantic;
150 declaration.Centroid = centroid;
151 declaration.Invariant = invariant;
153 header_bodysize_grow( header );
160 struct tgsi_declaration *declaration,
161 struct tgsi_header *header )
163 assert( declaration->NrTokens < 0xFF );
165 declaration->NrTokens++;
167 header_bodysize_grow( header );
170 struct tgsi_full_declaration
171 tgsi_default_full_declaration( void )
173 struct tgsi_full_declaration full_declaration;
175 full_declaration.Declaration = tgsi_default_declaration();
176 full_declaration.DeclarationRange = tgsi_default_declaration_range();
177 full_declaration.Semantic = tgsi_default_declaration_semantic();
179 return full_declaration;
183 tgsi_build_full_declaration(
184 const struct tgsi_full_declaration *full_decl,
185 struct tgsi_token *tokens,
186 struct tgsi_header *header,
190 struct tgsi_declaration *declaration;
191 struct tgsi_declaration_range *dr;
193 if( maxsize <= size )
195 declaration = (struct tgsi_declaration *) &tokens[size];
198 *declaration = tgsi_build_declaration(
199 full_decl->Declaration.File,
200 full_decl->Declaration.UsageMask,
201 full_decl->Declaration.Interpolate,
202 full_decl->Declaration.Semantic,
203 full_decl->Declaration.Centroid,
204 full_decl->Declaration.Invariant,
209 dr = (struct tgsi_declaration_range *) &tokens[size];
212 *dr = tgsi_build_declaration_range(
213 full_decl->DeclarationRange.First,
214 full_decl->DeclarationRange.Last,
218 if( full_decl->Declaration.Semantic ) {
219 struct tgsi_declaration_semantic *ds;
221 if( maxsize <= size )
223 ds = (struct tgsi_declaration_semantic *) &tokens[size];
226 *ds = tgsi_build_declaration_semantic(
227 full_decl->Semantic.SemanticName,
228 full_decl->Semantic.SemanticIndex,
236 struct tgsi_declaration_range
237 tgsi_default_declaration_range( void )
239 struct tgsi_declaration_range dr;
247 struct tgsi_declaration_range
248 tgsi_build_declaration_range(
251 struct tgsi_declaration *declaration,
252 struct tgsi_header *header )
254 struct tgsi_declaration_range declaration_range;
256 assert( last >= first );
257 assert( last <= 0xFFFF );
259 declaration_range = tgsi_default_declaration_range();
260 declaration_range.First = first;
261 declaration_range.Last = last;
263 declaration_grow( declaration, header );
265 return declaration_range;
268 struct tgsi_declaration_semantic
269 tgsi_default_declaration_semantic( void )
271 struct tgsi_declaration_semantic ds;
273 ds.SemanticName = TGSI_SEMANTIC_POSITION;
274 ds.SemanticIndex = 0;
280 struct tgsi_declaration_semantic
281 tgsi_build_declaration_semantic(
282 unsigned semantic_name,
283 unsigned semantic_index,
284 struct tgsi_declaration *declaration,
285 struct tgsi_header *header )
287 struct tgsi_declaration_semantic ds;
289 assert( semantic_name <= TGSI_SEMANTIC_COUNT );
290 assert( semantic_index <= 0xFFFF );
292 ds = tgsi_default_declaration_semantic();
293 ds.SemanticName = semantic_name;
294 ds.SemanticIndex = semantic_index;
296 declaration_grow( declaration, header );
305 struct tgsi_immediate
306 tgsi_default_immediate( void )
308 struct tgsi_immediate immediate;
310 immediate.Type = TGSI_TOKEN_TYPE_IMMEDIATE;
311 immediate.NrTokens = 1;
312 immediate.DataType = TGSI_IMM_FLOAT32;
313 immediate.Padding = 0;
314 immediate.Extended = 0;
319 struct tgsi_immediate
320 tgsi_build_immediate(
321 struct tgsi_header *header )
323 struct tgsi_immediate immediate;
325 immediate = tgsi_default_immediate();
327 header_bodysize_grow( header );
332 struct tgsi_full_immediate
333 tgsi_default_full_immediate( void )
335 struct tgsi_full_immediate fullimm;
337 fullimm.Immediate = tgsi_default_immediate();
338 fullimm.u[0].Float = 0.0f;
339 fullimm.u[1].Float = 0.0f;
340 fullimm.u[2].Float = 0.0f;
341 fullimm.u[3].Float = 0.0f;
348 struct tgsi_immediate *immediate,
349 struct tgsi_header *header )
351 assert( immediate->NrTokens < 0xFF );
353 immediate->NrTokens++;
355 header_bodysize_grow( header );
358 union tgsi_immediate_data
359 tgsi_build_immediate_float32(
361 struct tgsi_immediate *immediate,
362 struct tgsi_header *header )
364 union tgsi_immediate_data immediate_data;
366 immediate_data.Float = value;
368 immediate_grow( immediate, header );
370 return immediate_data;
374 tgsi_build_full_immediate(
375 const struct tgsi_full_immediate *full_imm,
376 struct tgsi_token *tokens,
377 struct tgsi_header *header,
380 unsigned size = 0, i;
381 struct tgsi_immediate *immediate;
383 if( maxsize <= size )
385 immediate = (struct tgsi_immediate *) &tokens[size];
388 *immediate = tgsi_build_immediate( header );
390 assert( full_imm->Immediate.NrTokens <= 4 + 1 );
392 for( i = 0; i < full_imm->Immediate.NrTokens - 1; i++ ) {
393 union tgsi_immediate_data *data;
395 if( maxsize <= size )
397 data = (union tgsi_immediate_data *) &tokens[size];
400 *data = tgsi_build_immediate_float32(
401 full_imm->u[i].Float,
413 struct tgsi_instruction
414 tgsi_default_instruction( void )
416 struct tgsi_instruction instruction;
418 instruction.Type = TGSI_TOKEN_TYPE_INSTRUCTION;
419 instruction.NrTokens = 1;
420 instruction.Opcode = TGSI_OPCODE_MOV;
421 instruction.Saturate = TGSI_SAT_NONE;
422 instruction.NumDstRegs = 1;
423 instruction.NumSrcRegs = 1;
424 instruction.Padding = 0;
425 instruction.Extended = 0;
430 struct tgsi_instruction
431 tgsi_build_instruction(
434 unsigned num_dst_regs,
435 unsigned num_src_regs,
436 struct tgsi_header *header )
438 struct tgsi_instruction instruction;
440 assert (opcode <= TGSI_OPCODE_LAST);
441 assert (saturate <= TGSI_SAT_MINUS_PLUS_ONE);
442 assert (num_dst_regs <= 3);
443 assert (num_src_regs <= 15);
445 instruction = tgsi_default_instruction();
446 instruction.Opcode = opcode;
447 instruction.Saturate = saturate;
448 instruction.NumDstRegs = num_dst_regs;
449 instruction.NumSrcRegs = num_src_regs;
451 header_bodysize_grow( header );
458 struct tgsi_instruction *instruction,
459 struct tgsi_header *header )
461 assert (instruction->NrTokens < 0xFF);
463 instruction->NrTokens++;
465 header_bodysize_grow( header );
468 struct tgsi_full_instruction
469 tgsi_default_full_instruction( void )
471 struct tgsi_full_instruction full_instruction;
474 full_instruction.Instruction = tgsi_default_instruction();
475 full_instruction.InstructionExtNv = tgsi_default_instruction_ext_nv();
476 full_instruction.InstructionExtLabel = tgsi_default_instruction_ext_label();
477 full_instruction.InstructionExtTexture = tgsi_default_instruction_ext_texture();
478 for( i = 0; i < TGSI_FULL_MAX_DST_REGISTERS; i++ ) {
479 full_instruction.FullDstRegisters[i] = tgsi_default_full_dst_register();
481 for( i = 0; i < TGSI_FULL_MAX_SRC_REGISTERS; i++ ) {
482 full_instruction.FullSrcRegisters[i] = tgsi_default_full_src_register();
485 return full_instruction;
489 tgsi_build_full_instruction(
490 const struct tgsi_full_instruction *full_inst,
491 struct tgsi_token *tokens,
492 struct tgsi_header *header,
497 struct tgsi_instruction *instruction;
498 struct tgsi_token *prev_token;
500 if( maxsize <= size )
502 instruction = (struct tgsi_instruction *) &tokens[size];
505 *instruction = tgsi_build_instruction(
506 full_inst->Instruction.Opcode,
507 full_inst->Instruction.Saturate,
508 full_inst->Instruction.NumDstRegs,
509 full_inst->Instruction.NumSrcRegs,
511 prev_token = (struct tgsi_token *) instruction;
513 if( tgsi_compare_instruction_ext_nv(
514 full_inst->InstructionExtNv,
515 tgsi_default_instruction_ext_nv() ) ) {
516 struct tgsi_instruction_ext_nv *instruction_ext_nv;
518 if( maxsize <= size )
521 (struct tgsi_instruction_ext_nv *) &tokens[size];
524 *instruction_ext_nv = tgsi_build_instruction_ext_nv(
525 full_inst->InstructionExtNv.Precision,
526 full_inst->InstructionExtNv.CondDstIndex,
527 full_inst->InstructionExtNv.CondFlowIndex,
528 full_inst->InstructionExtNv.CondMask,
529 full_inst->InstructionExtNv.CondSwizzleX,
530 full_inst->InstructionExtNv.CondSwizzleY,
531 full_inst->InstructionExtNv.CondSwizzleZ,
532 full_inst->InstructionExtNv.CondSwizzleW,
533 full_inst->InstructionExtNv.CondDstUpdate,
534 full_inst->InstructionExtNv.CondFlowEnable,
538 prev_token = (struct tgsi_token *) instruction_ext_nv;
541 if( tgsi_compare_instruction_ext_label(
542 full_inst->InstructionExtLabel,
543 tgsi_default_instruction_ext_label() ) ) {
544 struct tgsi_instruction_ext_label *instruction_ext_label;
546 if( maxsize <= size )
548 instruction_ext_label =
549 (struct tgsi_instruction_ext_label *) &tokens[size];
552 *instruction_ext_label = tgsi_build_instruction_ext_label(
553 full_inst->InstructionExtLabel.Label,
557 prev_token = (struct tgsi_token *) instruction_ext_label;
560 if( tgsi_compare_instruction_ext_texture(
561 full_inst->InstructionExtTexture,
562 tgsi_default_instruction_ext_texture() ) ) {
563 struct tgsi_instruction_ext_texture *instruction_ext_texture;
565 if( maxsize <= size )
567 instruction_ext_texture =
568 (struct tgsi_instruction_ext_texture *) &tokens[size];
571 *instruction_ext_texture = tgsi_build_instruction_ext_texture(
572 full_inst->InstructionExtTexture.Texture,
576 prev_token = (struct tgsi_token *) instruction_ext_texture;
579 for( i = 0; i < full_inst->Instruction.NumDstRegs; i++ ) {
580 const struct tgsi_full_dst_register *reg = &full_inst->FullDstRegisters[i];
581 struct tgsi_dst_register *dst_register;
582 struct tgsi_token *prev_token;
584 if( maxsize <= size )
586 dst_register = (struct tgsi_dst_register *) &tokens[size];
589 *dst_register = tgsi_build_dst_register(
590 reg->DstRegister.File,
591 reg->DstRegister.WriteMask,
592 reg->DstRegister.Indirect,
593 reg->DstRegister.Index,
596 prev_token = (struct tgsi_token *) dst_register;
598 if( tgsi_compare_dst_register_ext_concode(
599 reg->DstRegisterExtConcode,
600 tgsi_default_dst_register_ext_concode() ) ) {
601 struct tgsi_dst_register_ext_concode *dst_register_ext_concode;
603 if( maxsize <= size )
605 dst_register_ext_concode =
606 (struct tgsi_dst_register_ext_concode *) &tokens[size];
609 *dst_register_ext_concode = tgsi_build_dst_register_ext_concode(
610 reg->DstRegisterExtConcode.CondMask,
611 reg->DstRegisterExtConcode.CondSwizzleX,
612 reg->DstRegisterExtConcode.CondSwizzleY,
613 reg->DstRegisterExtConcode.CondSwizzleZ,
614 reg->DstRegisterExtConcode.CondSwizzleW,
615 reg->DstRegisterExtConcode.CondSrcIndex,
619 prev_token = (struct tgsi_token *) dst_register_ext_concode;
622 if( tgsi_compare_dst_register_ext_modulate(
623 reg->DstRegisterExtModulate,
624 tgsi_default_dst_register_ext_modulate() ) ) {
625 struct tgsi_dst_register_ext_modulate *dst_register_ext_modulate;
627 if( maxsize <= size )
629 dst_register_ext_modulate =
630 (struct tgsi_dst_register_ext_modulate *) &tokens[size];
633 *dst_register_ext_modulate = tgsi_build_dst_register_ext_modulate(
634 reg->DstRegisterExtModulate.Modulate,
638 prev_token = (struct tgsi_token *) dst_register_ext_modulate;
641 if( reg->DstRegister.Indirect ) {
642 struct tgsi_src_register *ind;
644 if( maxsize <= size )
646 ind = (struct tgsi_src_register *) &tokens[size];
649 *ind = tgsi_build_src_register(
650 reg->DstRegisterInd.File,
651 reg->DstRegisterInd.SwizzleX,
652 reg->DstRegisterInd.SwizzleY,
653 reg->DstRegisterInd.SwizzleZ,
654 reg->DstRegisterInd.SwizzleW,
655 reg->DstRegisterInd.Negate,
656 reg->DstRegisterInd.Indirect,
657 reg->DstRegisterInd.Dimension,
658 reg->DstRegisterInd.Index,
664 for( i = 0; i < full_inst->Instruction.NumSrcRegs; i++ ) {
665 const struct tgsi_full_src_register *reg = &full_inst->FullSrcRegisters[i];
666 struct tgsi_src_register *src_register;
667 struct tgsi_token *prev_token;
669 if( maxsize <= size )
671 src_register = (struct tgsi_src_register *) &tokens[size];
674 *src_register = tgsi_build_src_register(
675 reg->SrcRegister.File,
676 reg->SrcRegister.SwizzleX,
677 reg->SrcRegister.SwizzleY,
678 reg->SrcRegister.SwizzleZ,
679 reg->SrcRegister.SwizzleW,
680 reg->SrcRegister.Negate,
681 reg->SrcRegister.Indirect,
682 reg->SrcRegister.Dimension,
683 reg->SrcRegister.Index,
686 prev_token = (struct tgsi_token *) src_register;
688 if( tgsi_compare_src_register_ext_swz(
689 reg->SrcRegisterExtSwz,
690 tgsi_default_src_register_ext_swz() ) ) {
691 struct tgsi_src_register_ext_swz *src_register_ext_swz;
693 /* Use of the extended swizzle requires the simple swizzle to be identity.
695 assert( reg->SrcRegister.SwizzleX == TGSI_SWIZZLE_X );
696 assert( reg->SrcRegister.SwizzleY == TGSI_SWIZZLE_Y );
697 assert( reg->SrcRegister.SwizzleZ == TGSI_SWIZZLE_Z );
698 assert( reg->SrcRegister.SwizzleW == TGSI_SWIZZLE_W );
699 assert( reg->SrcRegister.Negate == FALSE );
701 if( maxsize <= size )
703 src_register_ext_swz =
704 (struct tgsi_src_register_ext_swz *) &tokens[size];
707 *src_register_ext_swz = tgsi_build_src_register_ext_swz(
708 reg->SrcRegisterExtSwz.ExtSwizzleX,
709 reg->SrcRegisterExtSwz.ExtSwizzleY,
710 reg->SrcRegisterExtSwz.ExtSwizzleZ,
711 reg->SrcRegisterExtSwz.ExtSwizzleW,
712 reg->SrcRegisterExtSwz.NegateX,
713 reg->SrcRegisterExtSwz.NegateY,
714 reg->SrcRegisterExtSwz.NegateZ,
715 reg->SrcRegisterExtSwz.NegateW,
719 prev_token = (struct tgsi_token *) src_register_ext_swz;
722 if( tgsi_compare_src_register_ext_mod(
723 reg->SrcRegisterExtMod,
724 tgsi_default_src_register_ext_mod() ) ) {
725 struct tgsi_src_register_ext_mod *src_register_ext_mod;
727 if( maxsize <= size )
729 src_register_ext_mod =
730 (struct tgsi_src_register_ext_mod *) &tokens[size];
733 *src_register_ext_mod = tgsi_build_src_register_ext_mod(
734 reg->SrcRegisterExtMod.Complement,
735 reg->SrcRegisterExtMod.Bias,
736 reg->SrcRegisterExtMod.Scale2X,
737 reg->SrcRegisterExtMod.Absolute,
738 reg->SrcRegisterExtMod.Negate,
742 prev_token = (struct tgsi_token *) src_register_ext_mod;
745 if( reg->SrcRegister.Indirect ) {
746 struct tgsi_src_register *ind;
748 if( maxsize <= size )
750 ind = (struct tgsi_src_register *) &tokens[size];
753 *ind = tgsi_build_src_register(
754 reg->SrcRegisterInd.File,
755 reg->SrcRegisterInd.SwizzleX,
756 reg->SrcRegisterInd.SwizzleY,
757 reg->SrcRegisterInd.SwizzleZ,
758 reg->SrcRegisterInd.SwizzleW,
759 reg->SrcRegisterInd.Negate,
760 reg->SrcRegisterInd.Indirect,
761 reg->SrcRegisterInd.Dimension,
762 reg->SrcRegisterInd.Index,
767 if( reg->SrcRegister.Dimension ) {
768 struct tgsi_dimension *dim;
770 assert( !reg->SrcRegisterDim.Dimension );
772 if( maxsize <= size )
774 dim = (struct tgsi_dimension *) &tokens[size];
777 *dim = tgsi_build_dimension(
778 reg->SrcRegisterDim.Indirect,
779 reg->SrcRegisterDim.Index,
783 if( reg->SrcRegisterDim.Indirect ) {
784 struct tgsi_src_register *ind;
786 if( maxsize <= size )
788 ind = (struct tgsi_src_register *) &tokens[size];
791 *ind = tgsi_build_src_register(
792 reg->SrcRegisterDimInd.File,
793 reg->SrcRegisterDimInd.SwizzleX,
794 reg->SrcRegisterDimInd.SwizzleY,
795 reg->SrcRegisterDimInd.SwizzleZ,
796 reg->SrcRegisterDimInd.SwizzleW,
797 reg->SrcRegisterDimInd.Negate,
798 reg->SrcRegisterDimInd.Indirect,
799 reg->SrcRegisterDimInd.Dimension,
800 reg->SrcRegisterDimInd.Index,
810 struct tgsi_instruction_ext_nv
811 tgsi_default_instruction_ext_nv( void )
813 struct tgsi_instruction_ext_nv instruction_ext_nv;
815 instruction_ext_nv.Type = TGSI_INSTRUCTION_EXT_TYPE_NV;
816 instruction_ext_nv.Precision = TGSI_PRECISION_DEFAULT;
817 instruction_ext_nv.CondDstIndex = 0;
818 instruction_ext_nv.CondFlowIndex = 0;
819 instruction_ext_nv.CondMask = TGSI_CC_TR;
820 instruction_ext_nv.CondSwizzleX = TGSI_SWIZZLE_X;
821 instruction_ext_nv.CondSwizzleY = TGSI_SWIZZLE_Y;
822 instruction_ext_nv.CondSwizzleZ = TGSI_SWIZZLE_Z;
823 instruction_ext_nv.CondSwizzleW = TGSI_SWIZZLE_W;
824 instruction_ext_nv.CondDstUpdate = 0;
825 instruction_ext_nv.CondFlowEnable = 0;
826 instruction_ext_nv.Padding = 0;
827 instruction_ext_nv.Extended = 0;
829 return instruction_ext_nv;
833 /** test for inequality of 32-bit values pointed to by a and b */
834 static INLINE boolean
835 compare32(const void *a, const void *b)
837 return *((uint32_t *) a) != *((uint32_t *) b);
842 tgsi_compare_instruction_ext_nv(
843 struct tgsi_instruction_ext_nv a,
844 struct tgsi_instruction_ext_nv b )
846 a.Padding = b.Padding = 0;
847 a.Extended = b.Extended = 0;
848 return compare32(&a, &b);
851 struct tgsi_instruction_ext_nv
852 tgsi_build_instruction_ext_nv(
854 unsigned cond_dst_index,
855 unsigned cond_flow_index,
857 unsigned cond_swizzle_x,
858 unsigned cond_swizzle_y,
859 unsigned cond_swizzle_z,
860 unsigned cond_swizzle_w,
861 unsigned cond_dst_update,
862 unsigned cond_flow_enable,
863 struct tgsi_token *prev_token,
864 struct tgsi_instruction *instruction,
865 struct tgsi_header *header )
867 struct tgsi_instruction_ext_nv instruction_ext_nv;
869 instruction_ext_nv = tgsi_default_instruction_ext_nv();
870 instruction_ext_nv.Precision = precision;
871 instruction_ext_nv.CondDstIndex = cond_dst_index;
872 instruction_ext_nv.CondFlowIndex = cond_flow_index;
873 instruction_ext_nv.CondMask = cond_mask;
874 instruction_ext_nv.CondSwizzleX = cond_swizzle_x;
875 instruction_ext_nv.CondSwizzleY = cond_swizzle_y;
876 instruction_ext_nv.CondSwizzleZ = cond_swizzle_z;
877 instruction_ext_nv.CondSwizzleW = cond_swizzle_w;
878 instruction_ext_nv.CondDstUpdate = cond_dst_update;
879 instruction_ext_nv.CondFlowEnable = cond_flow_enable;
881 prev_token->Extended = 1;
882 instruction_grow( instruction, header );
884 return instruction_ext_nv;
887 struct tgsi_instruction_ext_label
888 tgsi_default_instruction_ext_label( void )
890 struct tgsi_instruction_ext_label instruction_ext_label;
892 instruction_ext_label.Type = TGSI_INSTRUCTION_EXT_TYPE_LABEL;
893 instruction_ext_label.Label = 0;
894 instruction_ext_label.Padding = 0;
895 instruction_ext_label.Extended = 0;
897 return instruction_ext_label;
901 tgsi_compare_instruction_ext_label(
902 struct tgsi_instruction_ext_label a,
903 struct tgsi_instruction_ext_label b )
905 a.Padding = b.Padding = 0;
906 a.Extended = b.Extended = 0;
907 return compare32(&a, &b);
910 struct tgsi_instruction_ext_label
911 tgsi_build_instruction_ext_label(
913 struct tgsi_token *prev_token,
914 struct tgsi_instruction *instruction,
915 struct tgsi_header *header )
917 struct tgsi_instruction_ext_label instruction_ext_label;
919 instruction_ext_label = tgsi_default_instruction_ext_label();
920 instruction_ext_label.Label = label;
922 prev_token->Extended = 1;
923 instruction_grow( instruction, header );
925 return instruction_ext_label;
928 struct tgsi_instruction_ext_texture
929 tgsi_default_instruction_ext_texture( void )
931 struct tgsi_instruction_ext_texture instruction_ext_texture;
933 instruction_ext_texture.Type = TGSI_INSTRUCTION_EXT_TYPE_TEXTURE;
934 instruction_ext_texture.Texture = TGSI_TEXTURE_UNKNOWN;
935 instruction_ext_texture.Padding = 0;
936 instruction_ext_texture.Extended = 0;
938 return instruction_ext_texture;
942 tgsi_compare_instruction_ext_texture(
943 struct tgsi_instruction_ext_texture a,
944 struct tgsi_instruction_ext_texture b )
946 a.Padding = b.Padding = 0;
947 a.Extended = b.Extended = 0;
948 return compare32(&a, &b);
951 struct tgsi_instruction_ext_texture
952 tgsi_build_instruction_ext_texture(
954 struct tgsi_token *prev_token,
955 struct tgsi_instruction *instruction,
956 struct tgsi_header *header )
958 struct tgsi_instruction_ext_texture instruction_ext_texture;
960 instruction_ext_texture = tgsi_default_instruction_ext_texture();
961 instruction_ext_texture.Texture = texture;
963 prev_token->Extended = 1;
964 instruction_grow( instruction, header );
966 return instruction_ext_texture;
969 struct tgsi_src_register
970 tgsi_default_src_register( void )
972 struct tgsi_src_register src_register;
974 src_register.File = TGSI_FILE_NULL;
975 src_register.SwizzleX = TGSI_SWIZZLE_X;
976 src_register.SwizzleY = TGSI_SWIZZLE_Y;
977 src_register.SwizzleZ = TGSI_SWIZZLE_Z;
978 src_register.SwizzleW = TGSI_SWIZZLE_W;
979 src_register.Negate = 0;
980 src_register.Indirect = 0;
981 src_register.Dimension = 0;
982 src_register.Index = 0;
983 src_register.Extended = 0;
988 struct tgsi_src_register
989 tgsi_build_src_register(
999 struct tgsi_instruction *instruction,
1000 struct tgsi_header *header )
1002 struct tgsi_src_register src_register;
1004 assert( file < TGSI_FILE_COUNT );
1005 assert( swizzle_x <= TGSI_SWIZZLE_W );
1006 assert( swizzle_y <= TGSI_SWIZZLE_W );
1007 assert( swizzle_z <= TGSI_SWIZZLE_W );
1008 assert( swizzle_w <= TGSI_SWIZZLE_W );
1009 assert( negate <= 1 );
1010 assert( index >= -0x8000 && index <= 0x7FFF );
1012 src_register = tgsi_default_src_register();
1013 src_register.File = file;
1014 src_register.SwizzleX = swizzle_x;
1015 src_register.SwizzleY = swizzle_y;
1016 src_register.SwizzleZ = swizzle_z;
1017 src_register.SwizzleW = swizzle_w;
1018 src_register.Negate = negate;
1019 src_register.Indirect = indirect;
1020 src_register.Dimension = dimension;
1021 src_register.Index = index;
1023 instruction_grow( instruction, header );
1025 return src_register;
1028 struct tgsi_full_src_register
1029 tgsi_default_full_src_register( void )
1031 struct tgsi_full_src_register full_src_register;
1033 full_src_register.SrcRegister = tgsi_default_src_register();
1034 full_src_register.SrcRegisterExtSwz = tgsi_default_src_register_ext_swz();
1035 full_src_register.SrcRegisterExtMod = tgsi_default_src_register_ext_mod();
1036 full_src_register.SrcRegisterInd = tgsi_default_src_register();
1037 full_src_register.SrcRegisterDim = tgsi_default_dimension();
1038 full_src_register.SrcRegisterDimInd = tgsi_default_src_register();
1040 return full_src_register;
1043 struct tgsi_src_register_ext_swz
1044 tgsi_default_src_register_ext_swz( void )
1046 struct tgsi_src_register_ext_swz src_register_ext_swz;
1048 src_register_ext_swz.Type = TGSI_SRC_REGISTER_EXT_TYPE_SWZ;
1049 src_register_ext_swz.ExtSwizzleX = TGSI_EXTSWIZZLE_X;
1050 src_register_ext_swz.ExtSwizzleY = TGSI_EXTSWIZZLE_Y;
1051 src_register_ext_swz.ExtSwizzleZ = TGSI_EXTSWIZZLE_Z;
1052 src_register_ext_swz.ExtSwizzleW = TGSI_EXTSWIZZLE_W;
1053 src_register_ext_swz.NegateX = 0;
1054 src_register_ext_swz.NegateY = 0;
1055 src_register_ext_swz.NegateZ = 0;
1056 src_register_ext_swz.NegateW = 0;
1057 src_register_ext_swz.Padding = 0;
1058 src_register_ext_swz.Extended = 0;
1060 return src_register_ext_swz;
1064 tgsi_compare_src_register_ext_swz(
1065 struct tgsi_src_register_ext_swz a,
1066 struct tgsi_src_register_ext_swz b )
1068 a.Padding = b.Padding = 0;
1069 a.Extended = b.Extended = 0;
1070 return compare32(&a, &b);
1073 struct tgsi_src_register_ext_swz
1074 tgsi_build_src_register_ext_swz(
1075 unsigned ext_swizzle_x,
1076 unsigned ext_swizzle_y,
1077 unsigned ext_swizzle_z,
1078 unsigned ext_swizzle_w,
1083 struct tgsi_token *prev_token,
1084 struct tgsi_instruction *instruction,
1085 struct tgsi_header *header )
1087 struct tgsi_src_register_ext_swz src_register_ext_swz;
1089 assert( ext_swizzle_x <= TGSI_EXTSWIZZLE_ONE );
1090 assert( ext_swizzle_y <= TGSI_EXTSWIZZLE_ONE );
1091 assert( ext_swizzle_z <= TGSI_EXTSWIZZLE_ONE );
1092 assert( ext_swizzle_w <= TGSI_EXTSWIZZLE_ONE );
1093 assert( negate_x <= 1 );
1094 assert( negate_y <= 1 );
1095 assert( negate_z <= 1 );
1096 assert( negate_w <= 1 );
1098 src_register_ext_swz = tgsi_default_src_register_ext_swz();
1099 src_register_ext_swz.ExtSwizzleX = ext_swizzle_x;
1100 src_register_ext_swz.ExtSwizzleY = ext_swizzle_y;
1101 src_register_ext_swz.ExtSwizzleZ = ext_swizzle_z;
1102 src_register_ext_swz.ExtSwizzleW = ext_swizzle_w;
1103 src_register_ext_swz.NegateX = negate_x;
1104 src_register_ext_swz.NegateY = negate_y;
1105 src_register_ext_swz.NegateZ = negate_z;
1106 src_register_ext_swz.NegateW = negate_w;
1108 prev_token->Extended = 1;
1109 instruction_grow( instruction, header );
1111 return src_register_ext_swz;
1114 struct tgsi_src_register_ext_mod
1115 tgsi_default_src_register_ext_mod( void )
1117 struct tgsi_src_register_ext_mod src_register_ext_mod;
1119 src_register_ext_mod.Type = TGSI_SRC_REGISTER_EXT_TYPE_MOD;
1120 src_register_ext_mod.Complement = 0;
1121 src_register_ext_mod.Bias = 0;
1122 src_register_ext_mod.Scale2X = 0;
1123 src_register_ext_mod.Absolute = 0;
1124 src_register_ext_mod.Negate = 0;
1125 src_register_ext_mod.Padding = 0;
1126 src_register_ext_mod.Extended = 0;
1128 return src_register_ext_mod;
1132 tgsi_compare_src_register_ext_mod(
1133 struct tgsi_src_register_ext_mod a,
1134 struct tgsi_src_register_ext_mod b )
1136 a.Padding = b.Padding = 0;
1137 a.Extended = b.Extended = 0;
1138 return compare32(&a, &b);
1141 struct tgsi_src_register_ext_mod
1142 tgsi_build_src_register_ext_mod(
1143 unsigned complement,
1148 struct tgsi_token *prev_token,
1149 struct tgsi_instruction *instruction,
1150 struct tgsi_header *header )
1152 struct tgsi_src_register_ext_mod src_register_ext_mod;
1154 assert( complement <= 1 );
1155 assert( bias <= 1 );
1156 assert( scale_2x <= 1 );
1157 assert( absolute <= 1 );
1158 assert( negate <= 1 );
1160 src_register_ext_mod = tgsi_default_src_register_ext_mod();
1161 src_register_ext_mod.Complement = complement;
1162 src_register_ext_mod.Bias = bias;
1163 src_register_ext_mod.Scale2X = scale_2x;
1164 src_register_ext_mod.Absolute = absolute;
1165 src_register_ext_mod.Negate = negate;
1167 prev_token->Extended = 1;
1168 instruction_grow( instruction, header );
1170 return src_register_ext_mod;
1173 struct tgsi_dimension
1174 tgsi_default_dimension( void )
1176 struct tgsi_dimension dimension;
1178 dimension.Indirect = 0;
1179 dimension.Dimension = 0;
1180 dimension.Padding = 0;
1181 dimension.Index = 0;
1182 dimension.Extended = 0;
1187 struct tgsi_dimension
1188 tgsi_build_dimension(
1191 struct tgsi_instruction *instruction,
1192 struct tgsi_header *header )
1194 struct tgsi_dimension dimension;
1196 dimension = tgsi_default_dimension();
1197 dimension.Indirect = indirect;
1198 dimension.Index = index;
1200 instruction_grow( instruction, header );
1205 struct tgsi_dst_register
1206 tgsi_default_dst_register( void )
1208 struct tgsi_dst_register dst_register;
1210 dst_register.File = TGSI_FILE_NULL;
1211 dst_register.WriteMask = TGSI_WRITEMASK_XYZW;
1212 dst_register.Indirect = 0;
1213 dst_register.Dimension = 0;
1214 dst_register.Index = 0;
1215 dst_register.Padding = 0;
1216 dst_register.Extended = 0;
1218 return dst_register;
1221 struct tgsi_dst_register
1222 tgsi_build_dst_register(
1227 struct tgsi_instruction *instruction,
1228 struct tgsi_header *header )
1230 struct tgsi_dst_register dst_register;
1232 assert( file < TGSI_FILE_COUNT );
1233 assert( mask <= TGSI_WRITEMASK_XYZW );
1234 assert( index >= -32768 && index <= 32767 );
1236 dst_register = tgsi_default_dst_register();
1237 dst_register.File = file;
1238 dst_register.WriteMask = mask;
1239 dst_register.Index = index;
1240 dst_register.Indirect = indirect;
1242 instruction_grow( instruction, header );
1244 return dst_register;
1247 struct tgsi_full_dst_register
1248 tgsi_default_full_dst_register( void )
1250 struct tgsi_full_dst_register full_dst_register;
1252 full_dst_register.DstRegister = tgsi_default_dst_register();
1253 full_dst_register.DstRegisterInd = tgsi_default_src_register();
1254 full_dst_register.DstRegisterExtConcode =
1255 tgsi_default_dst_register_ext_concode();
1256 full_dst_register.DstRegisterExtModulate =
1257 tgsi_default_dst_register_ext_modulate();
1259 return full_dst_register;
1262 struct tgsi_dst_register_ext_concode
1263 tgsi_default_dst_register_ext_concode( void )
1265 struct tgsi_dst_register_ext_concode dst_register_ext_concode;
1267 dst_register_ext_concode.Type = TGSI_DST_REGISTER_EXT_TYPE_CONDCODE;
1268 dst_register_ext_concode.CondMask = TGSI_CC_TR;
1269 dst_register_ext_concode.CondSwizzleX = TGSI_SWIZZLE_X;
1270 dst_register_ext_concode.CondSwizzleY = TGSI_SWIZZLE_Y;
1271 dst_register_ext_concode.CondSwizzleZ = TGSI_SWIZZLE_Z;
1272 dst_register_ext_concode.CondSwizzleW = TGSI_SWIZZLE_W;
1273 dst_register_ext_concode.CondSrcIndex = 0;
1274 dst_register_ext_concode.Padding = 0;
1275 dst_register_ext_concode.Extended = 0;
1277 return dst_register_ext_concode;
1281 tgsi_compare_dst_register_ext_concode(
1282 struct tgsi_dst_register_ext_concode a,
1283 struct tgsi_dst_register_ext_concode b )
1285 a.Padding = b.Padding = 0;
1286 a.Extended = b.Extended = 0;
1287 return compare32(&a, &b);
1290 struct tgsi_dst_register_ext_concode
1291 tgsi_build_dst_register_ext_concode(
1298 struct tgsi_token *prev_token,
1299 struct tgsi_instruction *instruction,
1300 struct tgsi_header *header )
1302 struct tgsi_dst_register_ext_concode dst_register_ext_concode;
1304 assert( cc <= TGSI_CC_FL );
1305 assert( swizzle_x <= TGSI_SWIZZLE_W );
1306 assert( swizzle_y <= TGSI_SWIZZLE_W );
1307 assert( swizzle_z <= TGSI_SWIZZLE_W );
1308 assert( swizzle_w <= TGSI_SWIZZLE_W );
1309 assert( index >= -32768 && index <= 32767 );
1311 dst_register_ext_concode = tgsi_default_dst_register_ext_concode();
1312 dst_register_ext_concode.CondMask = cc;
1313 dst_register_ext_concode.CondSwizzleX = swizzle_x;
1314 dst_register_ext_concode.CondSwizzleY = swizzle_y;
1315 dst_register_ext_concode.CondSwizzleZ = swizzle_z;
1316 dst_register_ext_concode.CondSwizzleW = swizzle_w;
1317 dst_register_ext_concode.CondSrcIndex = index;
1319 prev_token->Extended = 1;
1320 instruction_grow( instruction, header );
1322 return dst_register_ext_concode;
1325 struct tgsi_dst_register_ext_modulate
1326 tgsi_default_dst_register_ext_modulate( void )
1328 struct tgsi_dst_register_ext_modulate dst_register_ext_modulate;
1330 dst_register_ext_modulate.Type = TGSI_DST_REGISTER_EXT_TYPE_MODULATE;
1331 dst_register_ext_modulate.Modulate = TGSI_MODULATE_1X;
1332 dst_register_ext_modulate.Padding = 0;
1333 dst_register_ext_modulate.Extended = 0;
1335 return dst_register_ext_modulate;
1339 tgsi_compare_dst_register_ext_modulate(
1340 struct tgsi_dst_register_ext_modulate a,
1341 struct tgsi_dst_register_ext_modulate b )
1343 a.Padding = b.Padding = 0;
1344 a.Extended = b.Extended = 0;
1345 return compare32(&a, &b);
1348 struct tgsi_dst_register_ext_modulate
1349 tgsi_build_dst_register_ext_modulate(
1351 struct tgsi_token *prev_token,
1352 struct tgsi_instruction *instruction,
1353 struct tgsi_header *header )
1355 struct tgsi_dst_register_ext_modulate dst_register_ext_modulate;
1357 assert( modulate <= TGSI_MODULATE_EIGHTH );
1359 dst_register_ext_modulate = tgsi_default_dst_register_ext_modulate();
1360 dst_register_ext_modulate.Modulate = modulate;
1362 prev_token->Extended = 1;
1363 instruction_grow( instruction, header );
1365 return dst_register_ext_modulate;