1 /**************************************************************************
3 * Copyright 2009 VMware, Inc.
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 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.
26 **************************************************************************/
29 #include "pipe/p_context.h"
30 #include "pipe/p_state.h"
31 #include "tgsi/tgsi_ureg.h"
32 #include "tgsi/tgsi_build.h"
33 #include "tgsi/tgsi_info.h"
34 #include "tgsi/tgsi_dump.h"
35 #include "tgsi/tgsi_sanity.h"
36 #include "util/u_memory.h"
37 #include "util/u_math.h"
39 union tgsi_any_token
{
40 struct tgsi_header header
;
41 struct tgsi_processor processor
;
42 struct tgsi_token token
;
43 struct tgsi_property prop
;
44 struct tgsi_property_data prop_data
;
45 struct tgsi_declaration decl
;
46 struct tgsi_declaration_range decl_range
;
47 struct tgsi_declaration_dimension decl_dim
;
48 struct tgsi_declaration_semantic decl_semantic
;
49 struct tgsi_immediate imm
;
50 union tgsi_immediate_data imm_data
;
51 struct tgsi_instruction insn
;
52 struct tgsi_instruction_predicate insn_predicate
;
53 struct tgsi_instruction_label insn_label
;
54 struct tgsi_instruction_texture insn_texture
;
55 struct tgsi_src_register src
;
56 struct tgsi_dimension dim
;
57 struct tgsi_dst_register dst
;
63 union tgsi_any_token
*tokens
;
69 #define UREG_MAX_INPUT PIPE_MAX_ATTRIBS
70 #define UREG_MAX_SYSTEM_VALUE PIPE_MAX_ATTRIBS
71 #define UREG_MAX_OUTPUT PIPE_MAX_ATTRIBS
72 #define UREG_MAX_CONSTANT_RANGE 32
73 #define UREG_MAX_IMMEDIATE 32
74 #define UREG_MAX_TEMP 256
75 #define UREG_MAX_ADDR 2
76 #define UREG_MAX_LOOP 1
77 #define UREG_MAX_PRED 1
83 } constant_range
[UREG_MAX_CONSTANT_RANGE
];
84 unsigned nr_constant_ranges
;
93 struct pipe_context
*pipe
;
96 unsigned semantic_name
;
97 unsigned semantic_index
;
99 } fs_input
[UREG_MAX_INPUT
];
100 unsigned nr_fs_inputs
;
102 unsigned vs_inputs
[UREG_MAX_INPUT
/32];
106 } gs_input
[UREG_MAX_INPUT
];
107 unsigned nr_gs_inputs
;
111 unsigned semantic_name
;
112 unsigned semantic_index
;
113 } system_value
[UREG_MAX_SYSTEM_VALUE
];
114 unsigned nr_system_values
;
117 unsigned semantic_name
;
118 unsigned semantic_index
;
119 } output
[UREG_MAX_OUTPUT
];
130 } immediate
[UREG_MAX_IMMEDIATE
];
131 unsigned nr_immediates
;
133 struct ureg_src sampler
[PIPE_MAX_SAMPLERS
];
134 unsigned nr_samplers
;
136 unsigned temps_active
[UREG_MAX_TEMP
/ 32];
139 struct const_decl const_decls
[PIPE_MAX_CONSTANT
];
141 unsigned property_gs_input_prim
;
146 unsigned nr_instructions
;
148 struct ureg_tokens domain
[2];
151 static union tgsi_any_token error_tokens
[32];
153 static void tokens_error( struct ureg_tokens
*tokens
)
155 if (tokens
->tokens
&& tokens
->tokens
!= error_tokens
)
156 FREE(tokens
->tokens
);
158 tokens
->tokens
= error_tokens
;
159 tokens
->size
= Elements(error_tokens
);
164 static void tokens_expand( struct ureg_tokens
*tokens
,
167 unsigned old_size
= tokens
->size
* sizeof(unsigned);
169 if (tokens
->tokens
== error_tokens
) {
173 while (tokens
->count
+ count
> tokens
->size
) {
174 tokens
->size
= (1 << ++tokens
->order
);
177 tokens
->tokens
= REALLOC(tokens
->tokens
,
179 tokens
->size
* sizeof(unsigned));
180 if (tokens
->tokens
== NULL
) {
181 tokens_error(tokens
);
185 static void set_bad( struct ureg_program
*ureg
)
187 tokens_error(&ureg
->domain
[0]);
192 static union tgsi_any_token
*get_tokens( struct ureg_program
*ureg
,
196 struct ureg_tokens
*tokens
= &ureg
->domain
[domain
];
197 union tgsi_any_token
*result
;
199 if (tokens
->count
+ count
> tokens
->size
)
200 tokens_expand(tokens
, count
);
202 result
= &tokens
->tokens
[tokens
->count
];
203 tokens
->count
+= count
;
208 static union tgsi_any_token
*retrieve_token( struct ureg_program
*ureg
,
212 if (ureg
->domain
[domain
].tokens
== error_tokens
)
213 return &error_tokens
[0];
215 return &ureg
->domain
[domain
].tokens
[nr
];
220 static INLINE
struct ureg_dst
221 ureg_dst_register( unsigned file
,
227 dst
.WriteMask
= TGSI_WRITEMASK_XYZW
;
229 dst
.IndirectIndex
= 0;
230 dst
.IndirectSwizzle
= 0;
234 dst
.PredSwizzleX
= TGSI_SWIZZLE_X
;
235 dst
.PredSwizzleY
= TGSI_SWIZZLE_Y
;
236 dst
.PredSwizzleZ
= TGSI_SWIZZLE_Z
;
237 dst
.PredSwizzleW
= TGSI_SWIZZLE_W
;
245 ureg_property_gs_input_prim(struct ureg_program
*ureg
,
246 unsigned gs_input_prim
)
248 ureg
->property_gs_input_prim
= gs_input_prim
;
254 ureg_DECL_fs_input( struct ureg_program
*ureg
,
257 unsigned interp_mode
)
261 for (i
= 0; i
< ureg
->nr_fs_inputs
; i
++) {
262 if (ureg
->fs_input
[i
].semantic_name
== name
&&
263 ureg
->fs_input
[i
].semantic_index
== index
)
267 if (ureg
->nr_fs_inputs
< UREG_MAX_INPUT
) {
268 ureg
->fs_input
[i
].semantic_name
= name
;
269 ureg
->fs_input
[i
].semantic_index
= index
;
270 ureg
->fs_input
[i
].interp
= interp_mode
;
271 ureg
->nr_fs_inputs
++;
278 return ureg_src_register( TGSI_FILE_INPUT
, i
);
283 ureg_DECL_vs_input( struct ureg_program
*ureg
,
286 assert(ureg
->processor
== TGSI_PROCESSOR_VERTEX
);
288 ureg
->vs_inputs
[index
/32] |= 1 << (index
% 32);
289 return ureg_src_register( TGSI_FILE_INPUT
, index
);
294 ureg_DECL_gs_input(struct ureg_program
*ureg
,
297 if (ureg
->nr_gs_inputs
< UREG_MAX_INPUT
) {
298 ureg
->gs_input
[ureg
->nr_gs_inputs
].index
= index
;
299 ureg
->nr_gs_inputs
++;
304 /* XXX: Add suport for true 2D input registers. */
305 return ureg_src_register(TGSI_FILE_INPUT
, index
);
310 ureg_DECL_system_value(struct ureg_program
*ureg
,
312 unsigned semantic_name
,
313 unsigned semantic_index
)
315 if (ureg
->nr_system_values
< UREG_MAX_SYSTEM_VALUE
) {
316 ureg
->system_value
[ureg
->nr_system_values
].index
= index
;
317 ureg
->system_value
[ureg
->nr_system_values
].semantic_name
= semantic_name
;
318 ureg
->system_value
[ureg
->nr_system_values
].semantic_index
= semantic_index
;
319 ureg
->nr_system_values
++;
324 return ureg_src_register(TGSI_FILE_SYSTEM_VALUE
, index
);
329 ureg_DECL_output( struct ureg_program
*ureg
,
335 for (i
= 0; i
< ureg
->nr_outputs
; i
++) {
336 if (ureg
->output
[i
].semantic_name
== name
&&
337 ureg
->output
[i
].semantic_index
== index
)
341 if (ureg
->nr_outputs
< UREG_MAX_OUTPUT
) {
342 ureg
->output
[i
].semantic_name
= name
;
343 ureg
->output
[i
].semantic_index
= index
;
351 return ureg_dst_register( TGSI_FILE_OUTPUT
, i
);
355 /* Returns a new constant register. Keep track of which have been
356 * referred to so that we can emit decls later.
358 * There is nothing in this code to bind this constant to any tracked
359 * value or manage any constant_buffer contents -- that's the
360 * resposibility of the calling code.
363 ureg_DECL_constant2D(struct ureg_program
*ureg
,
368 struct const_decl
*decl
= &ureg
->const_decls
[index2D
];
370 assert(index2D
< PIPE_MAX_CONSTANT
);
372 if (decl
->nr_constant_ranges
< UREG_MAX_CONSTANT_RANGE
) {
373 uint i
= decl
->nr_constant_ranges
++;
375 decl
->constant_range
[i
].first
= first
;
376 decl
->constant_range
[i
].last
= last
;
382 ureg_DECL_constant(struct ureg_program
*ureg
,
385 struct const_decl
*decl
= &ureg
->const_decls
[0];
386 unsigned minconst
= index
, maxconst
= index
;
389 /* Inside existing range?
391 for (i
= 0; i
< decl
->nr_constant_ranges
; i
++) {
392 if (decl
->constant_range
[i
].first
<= index
&&
393 decl
->constant_range
[i
].last
>= index
) {
398 /* Extend existing range?
400 for (i
= 0; i
< decl
->nr_constant_ranges
; i
++) {
401 if (decl
->constant_range
[i
].last
== index
- 1) {
402 decl
->constant_range
[i
].last
= index
;
406 if (decl
->constant_range
[i
].first
== index
+ 1) {
407 decl
->constant_range
[i
].first
= index
;
411 minconst
= MIN2(minconst
, decl
->constant_range
[i
].first
);
412 maxconst
= MAX2(maxconst
, decl
->constant_range
[i
].last
);
417 if (decl
->nr_constant_ranges
< UREG_MAX_CONSTANT_RANGE
) {
418 i
= decl
->nr_constant_ranges
++;
419 decl
->constant_range
[i
].first
= index
;
420 decl
->constant_range
[i
].last
= index
;
424 /* Collapse all ranges down to one:
427 decl
->constant_range
[0].first
= minconst
;
428 decl
->constant_range
[0].last
= maxconst
;
429 decl
->nr_constant_ranges
= 1;
432 assert(i
< decl
->nr_constant_ranges
);
433 assert(decl
->constant_range
[i
].first
<= index
);
434 assert(decl
->constant_range
[i
].last
>= index
);
435 return ureg_src_register(TGSI_FILE_CONSTANT
, index
);
439 /* Allocate a new temporary. Temporaries greater than UREG_MAX_TEMP
440 * are legal, but will not be released.
442 struct ureg_dst
ureg_DECL_temporary( struct ureg_program
*ureg
)
446 for (i
= 0; i
< UREG_MAX_TEMP
; i
+= 32) {
447 int bit
= ffs(~ureg
->temps_active
[i
/32]);
454 /* No reusable temps, so allocate a new one:
456 i
= ureg
->nr_temps
++;
459 if (i
< UREG_MAX_TEMP
)
460 ureg
->temps_active
[i
/32] |= 1 << (i
% 32);
462 if (i
>= ureg
->nr_temps
)
463 ureg
->nr_temps
= i
+ 1;
465 return ureg_dst_register( TGSI_FILE_TEMPORARY
, i
);
469 void ureg_release_temporary( struct ureg_program
*ureg
,
470 struct ureg_dst tmp
)
472 if(tmp
.File
== TGSI_FILE_TEMPORARY
)
473 if (tmp
.Index
< UREG_MAX_TEMP
)
474 ureg
->temps_active
[tmp
.Index
/32] &= ~(1 << (tmp
.Index
% 32));
478 /* Allocate a new address register.
480 struct ureg_dst
ureg_DECL_address( struct ureg_program
*ureg
)
482 if (ureg
->nr_addrs
< UREG_MAX_ADDR
)
483 return ureg_dst_register( TGSI_FILE_ADDRESS
, ureg
->nr_addrs
++ );
486 return ureg_dst_register( TGSI_FILE_ADDRESS
, 0 );
489 /* Allocate a new loop register.
492 ureg_DECL_loop(struct ureg_program
*ureg
)
494 if (ureg
->nr_loops
< UREG_MAX_LOOP
) {
495 return ureg_dst_register(TGSI_FILE_LOOP
, ureg
->nr_loops
++);
499 return ureg_dst_register(TGSI_FILE_LOOP
, 0);
502 /* Allocate a new predicate register.
505 ureg_DECL_predicate(struct ureg_program
*ureg
)
507 if (ureg
->nr_preds
< UREG_MAX_PRED
) {
508 return ureg_dst_register(TGSI_FILE_PREDICATE
, ureg
->nr_preds
++);
512 return ureg_dst_register(TGSI_FILE_PREDICATE
, 0);
515 /* Allocate a new sampler.
517 struct ureg_src
ureg_DECL_sampler( struct ureg_program
*ureg
,
522 for (i
= 0; i
< ureg
->nr_samplers
; i
++)
523 if (ureg
->sampler
[i
].Index
== nr
)
524 return ureg
->sampler
[i
];
526 if (i
< PIPE_MAX_SAMPLERS
) {
527 ureg
->sampler
[i
] = ureg_src_register( TGSI_FILE_SAMPLER
, nr
);
529 return ureg
->sampler
[i
];
533 return ureg
->sampler
[0];
538 match_or_expand_immediate( const unsigned *v
,
544 unsigned nr2
= *pnr2
;
549 for (i
= 0; i
< nr
; i
++) {
550 boolean found
= FALSE
;
552 for (j
= 0; j
< nr2
&& !found
; j
++) {
554 *swizzle
|= j
<< (i
* 2);
565 *swizzle
|= nr2
<< (i
* 2);
570 /* Actually expand immediate only when fully succeeded.
577 static struct ureg_src
578 decl_immediate( struct ureg_program
*ureg
,
584 unsigned swizzle
= 0;
586 /* Could do a first pass where we examine all existing immediates
590 for (i
= 0; i
< ureg
->nr_immediates
; i
++) {
591 if (ureg
->immediate
[i
].type
!= type
) {
594 if (match_or_expand_immediate(v
,
596 ureg
->immediate
[i
].value
.u
,
597 &ureg
->immediate
[i
].nr
,
603 if (ureg
->nr_immediates
< UREG_MAX_IMMEDIATE
) {
604 i
= ureg
->nr_immediates
++;
605 ureg
->immediate
[i
].type
= type
;
606 if (match_or_expand_immediate(v
,
608 ureg
->immediate
[i
].value
.u
,
609 &ureg
->immediate
[i
].nr
,
618 /* Make sure that all referenced elements are from this immediate.
619 * Has the effect of making size-one immediates into scalars.
621 for (j
= nr
; j
< 4; j
++) {
622 swizzle
|= (swizzle
& 0x3) << (j
* 2);
625 return ureg_swizzle(ureg_src_register(TGSI_FILE_IMMEDIATE
, i
),
626 (swizzle
>> 0) & 0x3,
627 (swizzle
>> 2) & 0x3,
628 (swizzle
>> 4) & 0x3,
629 (swizzle
>> 6) & 0x3);
634 ureg_DECL_immediate( struct ureg_program
*ureg
,
644 for (i
= 0; i
< nr
; i
++) {
648 return decl_immediate(ureg
, fu
.u
, nr
, TGSI_IMM_FLOAT32
);
653 ureg_DECL_immediate_uint( struct ureg_program
*ureg
,
657 return decl_immediate(ureg
, v
, nr
, TGSI_IMM_UINT32
);
662 ureg_DECL_immediate_block_uint( struct ureg_program
*ureg
,
669 if (ureg
->nr_immediates
+ (nr
+ 3) / 4 > UREG_MAX_IMMEDIATE
) {
671 return ureg_src_register(TGSI_FILE_IMMEDIATE
, 0);
674 index
= ureg
->nr_immediates
;
675 ureg
->nr_immediates
+= (nr
+ 3) / 4;
677 for (i
= index
; i
< ureg
->nr_immediates
; i
++) {
678 ureg
->immediate
[i
].type
= TGSI_IMM_UINT32
;
679 ureg
->immediate
[i
].nr
= nr
> 4 ? 4 : nr
;
680 memcpy(ureg
->immediate
[i
].value
.u
,
682 ureg
->immediate
[i
].nr
* sizeof(uint
));
686 return ureg_src_register(TGSI_FILE_IMMEDIATE
, index
);
691 ureg_DECL_immediate_int( struct ureg_program
*ureg
,
695 return decl_immediate(ureg
, (const unsigned *)v
, nr
, TGSI_IMM_INT32
);
700 ureg_emit_src( struct ureg_program
*ureg
,
701 struct ureg_src src
)
703 unsigned size
= 1 + (src
.Indirect
? 1 : 0) + (src
.Dimension
? 1 : 0);
705 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_INSN
, size
);
708 assert(src
.File
!= TGSI_FILE_NULL
);
709 assert(src
.File
!= TGSI_FILE_OUTPUT
);
710 assert(src
.File
< TGSI_FILE_COUNT
);
713 out
[n
].src
.File
= src
.File
;
714 out
[n
].src
.SwizzleX
= src
.SwizzleX
;
715 out
[n
].src
.SwizzleY
= src
.SwizzleY
;
716 out
[n
].src
.SwizzleZ
= src
.SwizzleZ
;
717 out
[n
].src
.SwizzleW
= src
.SwizzleW
;
718 out
[n
].src
.Index
= src
.Index
;
719 out
[n
].src
.Negate
= src
.Negate
;
720 out
[0].src
.Absolute
= src
.Absolute
;
724 out
[0].src
.Indirect
= 1;
726 out
[n
].src
.File
= src
.IndirectFile
;
727 out
[n
].src
.SwizzleX
= src
.IndirectSwizzle
;
728 out
[n
].src
.SwizzleY
= src
.IndirectSwizzle
;
729 out
[n
].src
.SwizzleZ
= src
.IndirectSwizzle
;
730 out
[n
].src
.SwizzleW
= src
.IndirectSwizzle
;
731 out
[n
].src
.Index
= src
.IndirectIndex
;
736 out
[0].src
.Dimension
= 1;
737 out
[n
].dim
.Indirect
= 0;
738 out
[n
].dim
.Dimension
= 0;
739 out
[n
].dim
.Padding
= 0;
740 out
[n
].dim
.Index
= src
.DimensionIndex
;
749 ureg_emit_dst( struct ureg_program
*ureg
,
750 struct ureg_dst dst
)
753 (dst
.Indirect
? 1 : 0));
755 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_INSN
, size
);
758 assert(dst
.File
!= TGSI_FILE_NULL
);
759 assert(dst
.File
!= TGSI_FILE_CONSTANT
);
760 assert(dst
.File
!= TGSI_FILE_INPUT
);
761 assert(dst
.File
!= TGSI_FILE_SAMPLER
);
762 assert(dst
.File
!= TGSI_FILE_IMMEDIATE
);
763 assert(dst
.File
< TGSI_FILE_COUNT
);
766 out
[n
].dst
.File
= dst
.File
;
767 out
[n
].dst
.WriteMask
= dst
.WriteMask
;
768 out
[n
].dst
.Indirect
= dst
.Indirect
;
769 out
[n
].dst
.Index
= dst
.Index
;
774 out
[n
].src
.File
= TGSI_FILE_ADDRESS
;
775 out
[n
].src
.SwizzleX
= dst
.IndirectSwizzle
;
776 out
[n
].src
.SwizzleY
= dst
.IndirectSwizzle
;
777 out
[n
].src
.SwizzleZ
= dst
.IndirectSwizzle
;
778 out
[n
].src
.SwizzleW
= dst
.IndirectSwizzle
;
779 out
[n
].src
.Index
= dst
.IndirectIndex
;
787 static void validate( unsigned opcode
,
792 const struct tgsi_opcode_info
*info
= tgsi_get_opcode_info( opcode
);
795 assert(nr_dst
== info
->num_dst
);
796 assert(nr_src
== info
->num_src
);
801 struct ureg_emit_insn_result
802 ureg_emit_insn(struct ureg_program
*ureg
,
807 unsigned pred_swizzle_x
,
808 unsigned pred_swizzle_y
,
809 unsigned pred_swizzle_z
,
810 unsigned pred_swizzle_w
,
814 union tgsi_any_token
*out
;
815 uint count
= predicate
? 2 : 1;
816 struct ureg_emit_insn_result result
;
818 validate( opcode
, num_dst
, num_src
);
820 out
= get_tokens( ureg
, DOMAIN_INSN
, count
);
821 out
[0].insn
= tgsi_default_instruction();
822 out
[0].insn
.Opcode
= opcode
;
823 out
[0].insn
.Saturate
= saturate
;
824 out
[0].insn
.NumDstRegs
= num_dst
;
825 out
[0].insn
.NumSrcRegs
= num_src
;
827 result
.insn_token
= ureg
->domain
[DOMAIN_INSN
].count
- count
;
828 result
.extended_token
= result
.insn_token
;
831 out
[0].insn
.Predicate
= 1;
832 out
[1].insn_predicate
= tgsi_default_instruction_predicate();
833 out
[1].insn_predicate
.Negate
= pred_negate
;
834 out
[1].insn_predicate
.SwizzleX
= pred_swizzle_x
;
835 out
[1].insn_predicate
.SwizzleY
= pred_swizzle_y
;
836 out
[1].insn_predicate
.SwizzleZ
= pred_swizzle_z
;
837 out
[1].insn_predicate
.SwizzleW
= pred_swizzle_w
;
840 ureg
->nr_instructions
++;
847 ureg_emit_label(struct ureg_program
*ureg
,
848 unsigned extended_token
,
849 unsigned *label_token
)
851 union tgsi_any_token
*out
, *insn
;
856 out
= get_tokens( ureg
, DOMAIN_INSN
, 1 );
859 insn
= retrieve_token( ureg
, DOMAIN_INSN
, extended_token
);
860 insn
->insn
.Label
= 1;
862 *label_token
= ureg
->domain
[DOMAIN_INSN
].count
- 1;
865 /* Will return a number which can be used in a label to point to the
866 * next instruction to be emitted.
869 ureg_get_instruction_number( struct ureg_program
*ureg
)
871 return ureg
->nr_instructions
;
874 /* Patch a given label (expressed as a token number) to point to a
875 * given instruction (expressed as an instruction number).
878 ureg_fixup_label(struct ureg_program
*ureg
,
879 unsigned label_token
,
880 unsigned instruction_number
)
882 union tgsi_any_token
*out
= retrieve_token( ureg
, DOMAIN_INSN
, label_token
);
884 out
->insn_label
.Label
= instruction_number
;
889 ureg_emit_texture(struct ureg_program
*ureg
,
890 unsigned extended_token
,
893 union tgsi_any_token
*out
, *insn
;
895 out
= get_tokens( ureg
, DOMAIN_INSN
, 1 );
896 insn
= retrieve_token( ureg
, DOMAIN_INSN
, extended_token
);
898 insn
->insn
.Texture
= 1;
901 out
[0].insn_texture
.Texture
= target
;
906 ureg_fixup_insn_size(struct ureg_program
*ureg
,
909 union tgsi_any_token
*out
= retrieve_token( ureg
, DOMAIN_INSN
, insn
);
911 assert(out
->insn
.Type
== TGSI_TOKEN_TYPE_INSTRUCTION
);
912 out
->insn
.NrTokens
= ureg
->domain
[DOMAIN_INSN
].count
- insn
- 1;
917 ureg_insn(struct ureg_program
*ureg
,
919 const struct ureg_dst
*dst
,
921 const struct ureg_src
*src
,
924 struct ureg_emit_insn_result insn
;
928 boolean negate
= FALSE
;
929 unsigned swizzle
[4] = { 0 };
931 saturate
= nr_dst
? dst
[0].Saturate
: FALSE
;
932 predicate
= nr_dst
? dst
[0].Predicate
: FALSE
;
934 negate
= dst
[0].PredNegate
;
935 swizzle
[0] = dst
[0].PredSwizzleX
;
936 swizzle
[1] = dst
[0].PredSwizzleY
;
937 swizzle
[2] = dst
[0].PredSwizzleZ
;
938 swizzle
[3] = dst
[0].PredSwizzleW
;
941 insn
= ureg_emit_insn(ureg
,
953 for (i
= 0; i
< nr_dst
; i
++)
954 ureg_emit_dst( ureg
, dst
[i
] );
956 for (i
= 0; i
< nr_src
; i
++)
957 ureg_emit_src( ureg
, src
[i
] );
959 ureg_fixup_insn_size( ureg
, insn
.insn_token
);
963 ureg_tex_insn(struct ureg_program
*ureg
,
965 const struct ureg_dst
*dst
,
968 const struct ureg_src
*src
,
971 struct ureg_emit_insn_result insn
;
975 boolean negate
= FALSE
;
976 unsigned swizzle
[4] = { 0 };
978 saturate
= nr_dst
? dst
[0].Saturate
: FALSE
;
979 predicate
= nr_dst
? dst
[0].Predicate
: FALSE
;
981 negate
= dst
[0].PredNegate
;
982 swizzle
[0] = dst
[0].PredSwizzleX
;
983 swizzle
[1] = dst
[0].PredSwizzleY
;
984 swizzle
[2] = dst
[0].PredSwizzleZ
;
985 swizzle
[3] = dst
[0].PredSwizzleW
;
988 insn
= ureg_emit_insn(ureg
,
1000 ureg_emit_texture( ureg
, insn
.extended_token
, target
);
1002 for (i
= 0; i
< nr_dst
; i
++)
1003 ureg_emit_dst( ureg
, dst
[i
] );
1005 for (i
= 0; i
< nr_src
; i
++)
1006 ureg_emit_src( ureg
, src
[i
] );
1008 ureg_fixup_insn_size( ureg
, insn
.insn_token
);
1013 ureg_label_insn(struct ureg_program
*ureg
,
1015 const struct ureg_src
*src
,
1017 unsigned *label_token
)
1019 struct ureg_emit_insn_result insn
;
1022 insn
= ureg_emit_insn(ureg
,
1034 ureg_emit_label( ureg
, insn
.extended_token
, label_token
);
1036 for (i
= 0; i
< nr_src
; i
++)
1037 ureg_emit_src( ureg
, src
[i
] );
1039 ureg_fixup_insn_size( ureg
, insn
.insn_token
);
1044 static void emit_decl( struct ureg_program
*ureg
,
1047 unsigned semantic_name
,
1048 unsigned semantic_index
,
1051 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 3 );
1054 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1055 out
[0].decl
.NrTokens
= 3;
1056 out
[0].decl
.File
= file
;
1057 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
; /* FIXME! */
1058 out
[0].decl
.Interpolate
= interp
;
1059 out
[0].decl
.Semantic
= 1;
1062 out
[1].decl_range
.First
=
1063 out
[1].decl_range
.Last
= index
;
1066 out
[2].decl_semantic
.Name
= semantic_name
;
1067 out
[2].decl_semantic
.Index
= semantic_index
;
1072 static void emit_decl_range( struct ureg_program
*ureg
,
1077 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 2 );
1080 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1081 out
[0].decl
.NrTokens
= 2;
1082 out
[0].decl
.File
= file
;
1083 out
[0].decl
.UsageMask
= 0xf;
1084 out
[0].decl
.Interpolate
= TGSI_INTERPOLATE_CONSTANT
;
1085 out
[0].decl
.Semantic
= 0;
1088 out
[1].decl_range
.First
= first
;
1089 out
[1].decl_range
.Last
= first
+ count
- 1;
1093 emit_decl_range2D(struct ureg_program
*ureg
,
1099 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 3);
1102 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1103 out
[0].decl
.NrTokens
= 3;
1104 out
[0].decl
.File
= file
;
1105 out
[0].decl
.UsageMask
= 0xf;
1106 out
[0].decl
.Interpolate
= TGSI_INTERPOLATE_CONSTANT
;
1107 out
[0].decl
.Dimension
= 1;
1110 out
[1].decl_range
.First
= first
;
1111 out
[1].decl_range
.Last
= last
;
1114 out
[2].decl_dim
.Index2D
= index2D
;
1118 emit_immediate( struct ureg_program
*ureg
,
1122 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 5 );
1125 out
[0].imm
.Type
= TGSI_TOKEN_TYPE_IMMEDIATE
;
1126 out
[0].imm
.NrTokens
= 5;
1127 out
[0].imm
.DataType
= type
;
1128 out
[0].imm
.Padding
= 0;
1130 out
[1].imm_data
.Uint
= v
[0];
1131 out
[2].imm_data
.Uint
= v
[1];
1132 out
[3].imm_data
.Uint
= v
[2];
1133 out
[4].imm_data
.Uint
= v
[3];
1137 emit_property(struct ureg_program
*ureg
,
1141 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 2);
1144 out
[0].prop
.Type
= TGSI_TOKEN_TYPE_PROPERTY
;
1145 out
[0].prop
.NrTokens
= 2;
1146 out
[0].prop
.PropertyName
= name
;
1148 out
[1].prop_data
.Data
= data
;
1152 static void emit_decls( struct ureg_program
*ureg
)
1156 if (ureg
->property_gs_input_prim
!= ~0) {
1157 assert(ureg
->processor
== TGSI_PROCESSOR_GEOMETRY
);
1160 TGSI_PROPERTY_GS_INPUT_PRIM
,
1161 ureg
->property_gs_input_prim
);
1164 if (ureg
->processor
== TGSI_PROCESSOR_VERTEX
) {
1165 for (i
= 0; i
< UREG_MAX_INPUT
; i
++) {
1166 if (ureg
->vs_inputs
[i
/32] & (1 << (i
%32))) {
1167 emit_decl_range( ureg
, TGSI_FILE_INPUT
, i
, 1 );
1170 } else if (ureg
->processor
== TGSI_PROCESSOR_FRAGMENT
) {
1171 for (i
= 0; i
< ureg
->nr_fs_inputs
; i
++) {
1175 ureg
->fs_input
[i
].semantic_name
,
1176 ureg
->fs_input
[i
].semantic_index
,
1177 ureg
->fs_input
[i
].interp
);
1180 for (i
= 0; i
< ureg
->nr_gs_inputs
; i
++) {
1181 emit_decl_range(ureg
,
1183 ureg
->gs_input
[i
].index
,
1188 for (i
= 0; i
< ureg
->nr_system_values
; i
++) {
1190 TGSI_FILE_SYSTEM_VALUE
,
1191 ureg
->system_value
[i
].index
,
1192 ureg
->system_value
[i
].semantic_name
,
1193 ureg
->system_value
[i
].semantic_index
,
1194 TGSI_INTERPOLATE_CONSTANT
);
1197 for (i
= 0; i
< ureg
->nr_outputs
; i
++) {
1201 ureg
->output
[i
].semantic_name
,
1202 ureg
->output
[i
].semantic_index
,
1203 TGSI_INTERPOLATE_CONSTANT
);
1206 for (i
= 0; i
< ureg
->nr_samplers
; i
++) {
1207 emit_decl_range( ureg
,
1209 ureg
->sampler
[i
].Index
, 1 );
1212 for (i
= 0; i
< PIPE_MAX_CONSTANT
; i
++) {
1213 struct const_decl
*decl
= &ureg
->const_decls
[i
];
1215 if (decl
->nr_constant_ranges
) {
1218 for (j
= 0; j
< decl
->nr_constant_ranges
; j
++) {
1219 emit_decl_range2D(ureg
,
1221 decl
->constant_range
[j
].first
,
1222 decl
->constant_range
[j
].last
,
1228 if (ureg
->nr_temps
) {
1229 emit_decl_range( ureg
,
1230 TGSI_FILE_TEMPORARY
,
1231 0, ureg
->nr_temps
);
1234 if (ureg
->nr_addrs
) {
1235 emit_decl_range( ureg
,
1237 0, ureg
->nr_addrs
);
1240 if (ureg
->nr_loops
) {
1241 emit_decl_range(ureg
,
1247 if (ureg
->nr_preds
) {
1248 emit_decl_range(ureg
,
1249 TGSI_FILE_PREDICATE
,
1254 for (i
= 0; i
< ureg
->nr_immediates
; i
++) {
1255 emit_immediate( ureg
,
1256 ureg
->immediate
[i
].value
.u
,
1257 ureg
->immediate
[i
].type
);
1261 /* Append the instruction tokens onto the declarations to build a
1262 * contiguous stream suitable to send to the driver.
1264 static void copy_instructions( struct ureg_program
*ureg
)
1266 unsigned nr_tokens
= ureg
->domain
[DOMAIN_INSN
].count
;
1267 union tgsi_any_token
*out
= get_tokens( ureg
,
1272 ureg
->domain
[DOMAIN_INSN
].tokens
,
1273 nr_tokens
* sizeof out
[0] );
1278 fixup_header_size(struct ureg_program
*ureg
)
1280 union tgsi_any_token
*out
= retrieve_token( ureg
, DOMAIN_DECL
, 0 );
1282 out
->header
.BodySize
= ureg
->domain
[DOMAIN_DECL
].count
- 2;
1287 emit_header( struct ureg_program
*ureg
)
1289 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 2 );
1291 out
[0].header
.HeaderSize
= 2;
1292 out
[0].header
.BodySize
= 0;
1294 out
[1].processor
.Processor
= ureg
->processor
;
1295 out
[1].processor
.Padding
= 0;
1299 const struct tgsi_token
*ureg_finalize( struct ureg_program
*ureg
)
1301 const struct tgsi_token
*tokens
;
1303 emit_header( ureg
);
1305 copy_instructions( ureg
);
1306 fixup_header_size( ureg
);
1308 if (ureg
->domain
[0].tokens
== error_tokens
||
1309 ureg
->domain
[1].tokens
== error_tokens
) {
1310 debug_printf("%s: error in generated shader\n", __FUNCTION__
);
1315 tokens
= &ureg
->domain
[DOMAIN_DECL
].tokens
[0].token
;
1318 debug_printf("%s: emitted shader %d tokens:\n", __FUNCTION__
,
1319 ureg
->domain
[DOMAIN_DECL
].count
);
1320 tgsi_dump( tokens
, 0 );
1324 if (tokens
&& !tgsi_sanity_check(tokens
)) {
1325 debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n");
1326 tgsi_dump(tokens
, 0);
1336 void *ureg_create_shader( struct ureg_program
*ureg
,
1337 struct pipe_context
*pipe
)
1339 struct pipe_shader_state state
;
1341 state
.tokens
= ureg_finalize(ureg
);
1345 if (ureg
->processor
== TGSI_PROCESSOR_VERTEX
)
1346 return pipe
->create_vs_state( pipe
, &state
);
1348 return pipe
->create_fs_state( pipe
, &state
);
1352 const struct tgsi_token
*ureg_get_tokens( struct ureg_program
*ureg
,
1353 unsigned *nr_tokens
)
1355 const struct tgsi_token
*tokens
;
1357 ureg_finalize(ureg
);
1359 tokens
= &ureg
->domain
[DOMAIN_DECL
].tokens
[0].token
;
1362 *nr_tokens
= ureg
->domain
[DOMAIN_DECL
].size
;
1364 ureg
->domain
[DOMAIN_DECL
].tokens
= 0;
1365 ureg
->domain
[DOMAIN_DECL
].size
= 0;
1366 ureg
->domain
[DOMAIN_DECL
].order
= 0;
1367 ureg
->domain
[DOMAIN_DECL
].count
= 0;
1373 struct ureg_program
*ureg_create( unsigned processor
)
1375 struct ureg_program
*ureg
= CALLOC_STRUCT( ureg_program
);
1379 ureg
->processor
= processor
;
1380 ureg
->property_gs_input_prim
= ~0;
1385 void ureg_destroy( struct ureg_program
*ureg
)
1389 for (i
= 0; i
< Elements(ureg
->domain
); i
++) {
1390 if (ureg
->domain
[i
].tokens
&&
1391 ureg
->domain
[i
].tokens
!= error_tokens
)
1392 FREE(ureg
->domain
[i
].tokens
);