1 /**************************************************************************
3 * Copyright 2009-2010 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_screen.h"
30 #include "pipe/p_context.h"
31 #include "pipe/p_state.h"
32 #include "tgsi/tgsi_ureg.h"
33 #include "tgsi/tgsi_build.h"
34 #include "tgsi/tgsi_info.h"
35 #include "tgsi/tgsi_dump.h"
36 #include "tgsi/tgsi_sanity.h"
37 #include "util/u_debug.h"
38 #include "util/u_inlines.h"
39 #include "util/u_memory.h"
40 #include "util/u_math.h"
41 #include "util/u_bitmask.h"
43 union tgsi_any_token
{
44 struct tgsi_header header
;
45 struct tgsi_processor processor
;
46 struct tgsi_token token
;
47 struct tgsi_property prop
;
48 struct tgsi_property_data prop_data
;
49 struct tgsi_declaration decl
;
50 struct tgsi_declaration_range decl_range
;
51 struct tgsi_declaration_dimension decl_dim
;
52 struct tgsi_declaration_interp decl_interp
;
53 struct tgsi_declaration_image decl_image
;
54 struct tgsi_declaration_semantic decl_semantic
;
55 struct tgsi_declaration_sampler_view decl_sampler_view
;
56 struct tgsi_declaration_array array
;
57 struct tgsi_immediate imm
;
58 union tgsi_immediate_data imm_data
;
59 struct tgsi_instruction insn
;
60 struct tgsi_instruction_predicate insn_predicate
;
61 struct tgsi_instruction_label insn_label
;
62 struct tgsi_instruction_texture insn_texture
;
63 struct tgsi_instruction_memory insn_memory
;
64 struct tgsi_texture_offset insn_texture_offset
;
65 struct tgsi_src_register src
;
66 struct tgsi_ind_register ind
;
67 struct tgsi_dimension dim
;
68 struct tgsi_dst_register dst
;
74 union tgsi_any_token
*tokens
;
80 #define UREG_MAX_INPUT (4 * PIPE_MAX_SHADER_INPUTS)
81 #define UREG_MAX_SYSTEM_VALUE PIPE_MAX_ATTRIBS
82 #define UREG_MAX_OUTPUT (4 * PIPE_MAX_SHADER_OUTPUTS)
83 #define UREG_MAX_CONSTANT_RANGE 32
84 #define UREG_MAX_IMMEDIATE 4096
85 #define UREG_MAX_ADDR 3
86 #define UREG_MAX_PRED 1
87 #define UREG_MAX_ARRAY_TEMPS 256
93 } constant_range
[UREG_MAX_CONSTANT_RANGE
];
94 unsigned nr_constant_ranges
;
103 bool supports_any_inout_decl_range
;
104 int next_shader_processor
;
107 unsigned semantic_name
;
108 unsigned semantic_index
;
110 unsigned char cylindrical_wrap
;
111 unsigned char usage_mask
;
112 unsigned interp_location
;
116 } input
[UREG_MAX_INPUT
];
117 unsigned nr_inputs
, nr_input_regs
;
119 unsigned vs_inputs
[PIPE_MAX_ATTRIBS
/32];
122 unsigned semantic_name
;
123 unsigned semantic_index
;
124 } system_value
[UREG_MAX_SYSTEM_VALUE
];
125 unsigned nr_system_values
;
128 unsigned semantic_name
;
129 unsigned semantic_index
;
130 unsigned usage_mask
; /* = TGSI_WRITEMASK_* */
134 } output
[UREG_MAX_OUTPUT
];
135 unsigned nr_outputs
, nr_output_regs
;
145 } immediate
[UREG_MAX_IMMEDIATE
];
146 unsigned nr_immediates
;
148 struct ureg_src sampler
[PIPE_MAX_SAMPLERS
];
149 unsigned nr_samplers
;
154 unsigned return_type_x
;
155 unsigned return_type_y
;
156 unsigned return_type_z
;
157 unsigned return_type_w
;
158 } sampler_view
[PIPE_MAX_SHADER_SAMPLER_VIEWS
];
159 unsigned nr_sampler_views
;
167 } image
[PIPE_MAX_SHADER_IMAGES
];
173 } buffer
[PIPE_MAX_SHADER_BUFFERS
];
176 struct util_bitmask
*free_temps
;
177 struct util_bitmask
*local_temps
;
178 struct util_bitmask
*decl_temps
;
181 unsigned array_temps
[UREG_MAX_ARRAY_TEMPS
];
182 unsigned nr_array_temps
;
184 struct const_decl const_decls
;
185 struct const_decl const_decls2D
[PIPE_MAX_CONSTANT_BUFFERS
];
187 unsigned properties
[TGSI_PROPERTY_COUNT
];
191 unsigned nr_instructions
;
193 struct ureg_tokens domain
[2];
195 bool use_memory
[TGSI_MEMORY_TYPE_COUNT
];
198 static union tgsi_any_token error_tokens
[32];
200 static void tokens_error( struct ureg_tokens
*tokens
)
202 if (tokens
->tokens
&& tokens
->tokens
!= error_tokens
)
203 FREE(tokens
->tokens
);
205 tokens
->tokens
= error_tokens
;
206 tokens
->size
= ARRAY_SIZE(error_tokens
);
211 static void tokens_expand( struct ureg_tokens
*tokens
,
214 unsigned old_size
= tokens
->size
* sizeof(unsigned);
216 if (tokens
->tokens
== error_tokens
) {
220 while (tokens
->count
+ count
> tokens
->size
) {
221 tokens
->size
= (1 << ++tokens
->order
);
224 tokens
->tokens
= REALLOC(tokens
->tokens
,
226 tokens
->size
* sizeof(unsigned));
227 if (tokens
->tokens
== NULL
) {
228 tokens_error(tokens
);
232 static void set_bad( struct ureg_program
*ureg
)
234 tokens_error(&ureg
->domain
[0]);
239 static union tgsi_any_token
*get_tokens( struct ureg_program
*ureg
,
243 struct ureg_tokens
*tokens
= &ureg
->domain
[domain
];
244 union tgsi_any_token
*result
;
246 if (tokens
->count
+ count
> tokens
->size
)
247 tokens_expand(tokens
, count
);
249 result
= &tokens
->tokens
[tokens
->count
];
250 tokens
->count
+= count
;
255 static union tgsi_any_token
*retrieve_token( struct ureg_program
*ureg
,
259 if (ureg
->domain
[domain
].tokens
== error_tokens
)
260 return &error_tokens
[0];
262 return &ureg
->domain
[domain
].tokens
[nr
];
266 ureg_property(struct ureg_program
*ureg
, unsigned name
, unsigned value
)
268 assert(name
< ARRAY_SIZE(ureg
->properties
));
269 ureg
->properties
[name
] = value
;
273 ureg_DECL_fs_input_cyl_centroid_layout(struct ureg_program
*ureg
,
274 unsigned semantic_name
,
275 unsigned semantic_index
,
276 unsigned interp_mode
,
277 unsigned cylindrical_wrap
,
278 unsigned interp_location
,
286 assert(usage_mask
!= 0);
287 assert(usage_mask
<= TGSI_WRITEMASK_XYZW
);
289 for (i
= 0; i
< ureg
->nr_inputs
; i
++) {
290 if (ureg
->input
[i
].semantic_name
== semantic_name
&&
291 ureg
->input
[i
].semantic_index
== semantic_index
) {
292 assert(ureg
->input
[i
].interp
== interp_mode
);
293 assert(ureg
->input
[i
].cylindrical_wrap
== cylindrical_wrap
);
294 assert(ureg
->input
[i
].interp_location
== interp_location
);
295 if (ureg
->input
[i
].array_id
== array_id
) {
296 ureg
->input
[i
].usage_mask
|= usage_mask
;
299 assert((ureg
->input
[i
].usage_mask
& usage_mask
) == 0);
303 if (ureg
->nr_inputs
< UREG_MAX_INPUT
) {
304 assert(array_size
>= 1);
305 ureg
->input
[i
].semantic_name
= semantic_name
;
306 ureg
->input
[i
].semantic_index
= semantic_index
;
307 ureg
->input
[i
].interp
= interp_mode
;
308 ureg
->input
[i
].cylindrical_wrap
= cylindrical_wrap
;
309 ureg
->input
[i
].interp_location
= interp_location
;
310 ureg
->input
[i
].first
= index
;
311 ureg
->input
[i
].last
= index
+ array_size
- 1;
312 ureg
->input
[i
].array_id
= array_id
;
313 ureg
->input
[i
].usage_mask
= usage_mask
;
314 ureg
->nr_input_regs
= MAX2(ureg
->nr_input_regs
, index
+ array_size
);
321 return ureg_src_array_register(TGSI_FILE_INPUT
, ureg
->input
[i
].first
,
326 ureg_DECL_fs_input_cyl_centroid(struct ureg_program
*ureg
,
327 unsigned semantic_name
,
328 unsigned semantic_index
,
329 unsigned interp_mode
,
330 unsigned cylindrical_wrap
,
331 unsigned interp_location
,
335 return ureg_DECL_fs_input_cyl_centroid_layout(ureg
,
336 semantic_name
, semantic_index
, interp_mode
, cylindrical_wrap
, interp_location
,
337 ureg
->nr_input_regs
, TGSI_WRITEMASK_XYZW
, array_id
, array_size
);
342 ureg_DECL_vs_input( struct ureg_program
*ureg
,
345 assert(ureg
->processor
== PIPE_SHADER_VERTEX
);
346 assert(index
/ 32 < ARRAY_SIZE(ureg
->vs_inputs
));
348 ureg
->vs_inputs
[index
/32] |= 1 << (index
% 32);
349 return ureg_src_register( TGSI_FILE_INPUT
, index
);
354 ureg_DECL_input_layout(struct ureg_program
*ureg
,
355 unsigned semantic_name
,
356 unsigned semantic_index
,
362 return ureg_DECL_fs_input_cyl_centroid_layout(ureg
,
363 semantic_name
, semantic_index
, 0, 0, 0,
364 index
, usage_mask
, array_id
, array_size
);
369 ureg_DECL_input(struct ureg_program
*ureg
,
370 unsigned semantic_name
,
371 unsigned semantic_index
,
375 return ureg_DECL_fs_input_cyl_centroid(ureg
, semantic_name
, semantic_index
,
376 0, 0, 0, array_id
, array_size
);
381 ureg_DECL_system_value(struct ureg_program
*ureg
,
382 unsigned semantic_name
,
383 unsigned semantic_index
)
387 for (i
= 0; i
< ureg
->nr_system_values
; i
++) {
388 if (ureg
->system_value
[i
].semantic_name
== semantic_name
&&
389 ureg
->system_value
[i
].semantic_index
== semantic_index
) {
394 if (ureg
->nr_system_values
< UREG_MAX_SYSTEM_VALUE
) {
395 ureg
->system_value
[ureg
->nr_system_values
].semantic_name
= semantic_name
;
396 ureg
->system_value
[ureg
->nr_system_values
].semantic_index
= semantic_index
;
397 i
= ureg
->nr_system_values
;
398 ureg
->nr_system_values
++;
404 return ureg_src_register(TGSI_FILE_SYSTEM_VALUE
, i
);
409 ureg_DECL_output_layout(struct ureg_program
*ureg
,
410 unsigned semantic_name
,
411 unsigned semantic_index
,
419 assert(usage_mask
!= 0);
421 for (i
= 0; i
< ureg
->nr_outputs
; i
++) {
422 if (ureg
->output
[i
].semantic_name
== semantic_name
&&
423 ureg
->output
[i
].semantic_index
== semantic_index
) {
424 if (ureg
->output
[i
].array_id
== array_id
) {
425 ureg
->output
[i
].usage_mask
|= usage_mask
;
428 assert((ureg
->output
[i
].usage_mask
& usage_mask
) == 0);
432 if (ureg
->nr_outputs
< UREG_MAX_OUTPUT
) {
433 ureg
->output
[i
].semantic_name
= semantic_name
;
434 ureg
->output
[i
].semantic_index
= semantic_index
;
435 ureg
->output
[i
].usage_mask
= usage_mask
;
436 ureg
->output
[i
].first
= index
;
437 ureg
->output
[i
].last
= index
+ array_size
- 1;
438 ureg
->output
[i
].array_id
= array_id
;
439 ureg
->nr_output_regs
= MAX2(ureg
->nr_output_regs
, index
+ array_size
);
447 return ureg_dst_array_register(TGSI_FILE_OUTPUT
, ureg
->output
[i
].first
,
453 ureg_DECL_output_masked(struct ureg_program
*ureg
,
460 return ureg_DECL_output_layout(ureg
, name
, index
,
461 ureg
->nr_output_regs
, usage_mask
, array_id
, array_size
);
466 ureg_DECL_output(struct ureg_program
*ureg
,
470 return ureg_DECL_output_masked(ureg
, name
, index
, TGSI_WRITEMASK_XYZW
,
475 ureg_DECL_output_array(struct ureg_program
*ureg
,
476 unsigned semantic_name
,
477 unsigned semantic_index
,
481 return ureg_DECL_output_masked(ureg
, semantic_name
, semantic_index
,
483 array_id
, array_size
);
487 /* Returns a new constant register. Keep track of which have been
488 * referred to so that we can emit decls later.
490 * Constant operands declared with this function must be addressed
491 * with a two-dimensional index.
493 * There is nothing in this code to bind this constant to any tracked
494 * value or manage any constant_buffer contents -- that's the
495 * resposibility of the calling code.
498 ureg_DECL_constant2D(struct ureg_program
*ureg
,
503 struct const_decl
*decl
= &ureg
->const_decls2D
[index2D
];
505 assert(index2D
< PIPE_MAX_CONSTANT_BUFFERS
);
507 if (decl
->nr_constant_ranges
< UREG_MAX_CONSTANT_RANGE
) {
508 uint i
= decl
->nr_constant_ranges
++;
510 decl
->constant_range
[i
].first
= first
;
511 decl
->constant_range
[i
].last
= last
;
516 /* A one-dimensional, deprecated version of ureg_DECL_constant2D().
518 * Constant operands declared with this function must be addressed
519 * with a one-dimensional index.
522 ureg_DECL_constant(struct ureg_program
*ureg
,
525 struct const_decl
*decl
= &ureg
->const_decls
;
526 unsigned minconst
= index
, maxconst
= index
;
529 /* Inside existing range?
531 for (i
= 0; i
< decl
->nr_constant_ranges
; i
++) {
532 if (decl
->constant_range
[i
].first
<= index
&&
533 decl
->constant_range
[i
].last
>= index
) {
538 /* Extend existing range?
540 for (i
= 0; i
< decl
->nr_constant_ranges
; i
++) {
541 if (decl
->constant_range
[i
].last
== index
- 1) {
542 decl
->constant_range
[i
].last
= index
;
546 if (decl
->constant_range
[i
].first
== index
+ 1) {
547 decl
->constant_range
[i
].first
= index
;
551 minconst
= MIN2(minconst
, decl
->constant_range
[i
].first
);
552 maxconst
= MAX2(maxconst
, decl
->constant_range
[i
].last
);
557 if (decl
->nr_constant_ranges
< UREG_MAX_CONSTANT_RANGE
) {
558 i
= decl
->nr_constant_ranges
++;
559 decl
->constant_range
[i
].first
= index
;
560 decl
->constant_range
[i
].last
= index
;
564 /* Collapse all ranges down to one:
567 decl
->constant_range
[0].first
= minconst
;
568 decl
->constant_range
[0].last
= maxconst
;
569 decl
->nr_constant_ranges
= 1;
572 assert(i
< decl
->nr_constant_ranges
);
573 assert(decl
->constant_range
[i
].first
<= index
);
574 assert(decl
->constant_range
[i
].last
>= index
);
575 return ureg_src_register(TGSI_FILE_CONSTANT
, index
);
578 static struct ureg_dst
alloc_temporary( struct ureg_program
*ureg
,
583 /* Look for a released temporary.
585 for (i
= util_bitmask_get_first_index(ureg
->free_temps
);
586 i
!= UTIL_BITMASK_INVALID_INDEX
;
587 i
= util_bitmask_get_next_index(ureg
->free_temps
, i
+ 1)) {
588 if (util_bitmask_get(ureg
->local_temps
, i
) == local
)
592 /* Or allocate a new one.
594 if (i
== UTIL_BITMASK_INVALID_INDEX
) {
595 i
= ureg
->nr_temps
++;
598 util_bitmask_set(ureg
->local_temps
, i
);
600 /* Start a new declaration when the local flag changes */
601 if (!i
|| util_bitmask_get(ureg
->local_temps
, i
- 1) != local
)
602 util_bitmask_set(ureg
->decl_temps
, i
);
605 util_bitmask_clear(ureg
->free_temps
, i
);
607 return ureg_dst_register( TGSI_FILE_TEMPORARY
, i
);
610 struct ureg_dst
ureg_DECL_temporary( struct ureg_program
*ureg
)
612 return alloc_temporary(ureg
, FALSE
);
615 struct ureg_dst
ureg_DECL_local_temporary( struct ureg_program
*ureg
)
617 return alloc_temporary(ureg
, TRUE
);
620 struct ureg_dst
ureg_DECL_array_temporary( struct ureg_program
*ureg
,
624 unsigned i
= ureg
->nr_temps
;
625 struct ureg_dst dst
= ureg_dst_register( TGSI_FILE_TEMPORARY
, i
);
628 util_bitmask_set(ureg
->local_temps
, i
);
630 /* Always start a new declaration at the start */
631 util_bitmask_set(ureg
->decl_temps
, i
);
633 ureg
->nr_temps
+= size
;
635 /* and also at the end of the array */
636 util_bitmask_set(ureg
->decl_temps
, ureg
->nr_temps
);
638 if (ureg
->nr_array_temps
< UREG_MAX_ARRAY_TEMPS
) {
639 ureg
->array_temps
[ureg
->nr_array_temps
++] = i
;
640 dst
.ArrayID
= ureg
->nr_array_temps
;
646 void ureg_release_temporary( struct ureg_program
*ureg
,
647 struct ureg_dst tmp
)
649 if(tmp
.File
== TGSI_FILE_TEMPORARY
)
650 util_bitmask_set(ureg
->free_temps
, tmp
.Index
);
654 /* Allocate a new address register.
656 struct ureg_dst
ureg_DECL_address( struct ureg_program
*ureg
)
658 if (ureg
->nr_addrs
< UREG_MAX_ADDR
)
659 return ureg_dst_register( TGSI_FILE_ADDRESS
, ureg
->nr_addrs
++ );
662 return ureg_dst_register( TGSI_FILE_ADDRESS
, 0 );
665 /* Allocate a new predicate register.
668 ureg_DECL_predicate(struct ureg_program
*ureg
)
670 if (ureg
->nr_preds
< UREG_MAX_PRED
) {
671 return ureg_dst_register(TGSI_FILE_PREDICATE
, ureg
->nr_preds
++);
675 return ureg_dst_register(TGSI_FILE_PREDICATE
, 0);
678 /* Allocate a new sampler.
680 struct ureg_src
ureg_DECL_sampler( struct ureg_program
*ureg
,
685 for (i
= 0; i
< ureg
->nr_samplers
; i
++)
686 if (ureg
->sampler
[i
].Index
== nr
)
687 return ureg
->sampler
[i
];
689 if (i
< PIPE_MAX_SAMPLERS
) {
690 ureg
->sampler
[i
] = ureg_src_register( TGSI_FILE_SAMPLER
, nr
);
692 return ureg
->sampler
[i
];
696 return ureg
->sampler
[0];
700 * Allocate a new shader sampler view.
703 ureg_DECL_sampler_view(struct ureg_program
*ureg
,
706 unsigned return_type_x
,
707 unsigned return_type_y
,
708 unsigned return_type_z
,
709 unsigned return_type_w
)
711 struct ureg_src reg
= ureg_src_register(TGSI_FILE_SAMPLER_VIEW
, index
);
714 for (i
= 0; i
< ureg
->nr_sampler_views
; i
++) {
715 if (ureg
->sampler_view
[i
].index
== index
) {
720 if (i
< PIPE_MAX_SHADER_SAMPLER_VIEWS
) {
721 ureg
->sampler_view
[i
].index
= index
;
722 ureg
->sampler_view
[i
].target
= target
;
723 ureg
->sampler_view
[i
].return_type_x
= return_type_x
;
724 ureg
->sampler_view
[i
].return_type_y
= return_type_y
;
725 ureg
->sampler_view
[i
].return_type_z
= return_type_z
;
726 ureg
->sampler_view
[i
].return_type_w
= return_type_w
;
727 ureg
->nr_sampler_views
++;
735 /* Allocate a new image.
738 ureg_DECL_image(struct ureg_program
*ureg
,
745 struct ureg_src reg
= ureg_src_register(TGSI_FILE_IMAGE
, index
);
748 for (i
= 0; i
< ureg
->nr_images
; i
++)
749 if (ureg
->image
[i
].index
== index
)
752 if (i
< PIPE_MAX_SHADER_IMAGES
) {
753 ureg
->image
[i
].index
= index
;
754 ureg
->image
[i
].target
= target
;
755 ureg
->image
[i
].wr
= wr
;
756 ureg
->image
[i
].raw
= raw
;
757 ureg
->image
[i
].format
= format
;
766 /* Allocate a new buffer.
768 struct ureg_src
ureg_DECL_buffer(struct ureg_program
*ureg
, unsigned nr
,
771 struct ureg_src reg
= ureg_src_register(TGSI_FILE_BUFFER
, nr
);
774 for (i
= 0; i
< ureg
->nr_buffers
; i
++)
775 if (ureg
->buffer
[i
].index
== nr
)
778 if (i
< PIPE_MAX_SHADER_BUFFERS
) {
779 ureg
->buffer
[i
].index
= nr
;
780 ureg
->buffer
[i
].atomic
= atomic
;
789 /* Allocate a memory area.
791 struct ureg_src
ureg_DECL_memory(struct ureg_program
*ureg
,
792 unsigned memory_type
)
794 struct ureg_src reg
= ureg_src_register(TGSI_FILE_MEMORY
, memory_type
);
796 ureg
->use_memory
[memory_type
] = true;
801 match_or_expand_immediate64( const unsigned *v
,
808 unsigned nr2
= *pnr2
;
812 for (i
= 0; i
< nr
; i
+= 2) {
813 boolean found
= FALSE
;
815 for (j
= 0; j
< nr2
&& !found
; j
+= 2) {
816 if (v
[i
] == v2
[j
] && v
[i
+ 1] == v2
[j
+ 1]) {
817 *swizzle
|= (j
<< (i
* 2)) | ((j
+ 1) << ((i
+ 1) * 2));
827 v2
[nr2
+ 1] = v
[i
+ 1];
829 *swizzle
|= (nr2
<< (i
* 2)) | ((nr2
+ 1) << ((i
+ 1) * 2));
834 /* Actually expand immediate only when fully succeeded.
841 match_or_expand_immediate( const unsigned *v
,
848 unsigned nr2
= *pnr2
;
851 if (type
== TGSI_IMM_FLOAT64
||
852 type
== TGSI_IMM_UINT64
||
853 type
== TGSI_IMM_INT64
)
854 return match_or_expand_immediate64(v
, type
, nr
, v2
, pnr2
, swizzle
);
858 for (i
= 0; i
< nr
; i
++) {
859 boolean found
= FALSE
;
861 for (j
= 0; j
< nr2
&& !found
; j
++) {
863 *swizzle
|= j
<< (i
* 2);
874 *swizzle
|= nr2
<< (i
* 2);
879 /* Actually expand immediate only when fully succeeded.
886 static struct ureg_src
887 decl_immediate( struct ureg_program
*ureg
,
893 unsigned swizzle
= 0;
895 /* Could do a first pass where we examine all existing immediates
899 for (i
= 0; i
< ureg
->nr_immediates
; i
++) {
900 if (ureg
->immediate
[i
].type
!= type
) {
903 if (match_or_expand_immediate(v
,
906 ureg
->immediate
[i
].value
.u
,
907 &ureg
->immediate
[i
].nr
,
913 if (ureg
->nr_immediates
< UREG_MAX_IMMEDIATE
) {
914 i
= ureg
->nr_immediates
++;
915 ureg
->immediate
[i
].type
= type
;
916 if (match_or_expand_immediate(v
,
919 ureg
->immediate
[i
].value
.u
,
920 &ureg
->immediate
[i
].nr
,
929 /* Make sure that all referenced elements are from this immediate.
930 * Has the effect of making size-one immediates into scalars.
932 if (type
== TGSI_IMM_FLOAT64
||
933 type
== TGSI_IMM_UINT64
||
934 type
== TGSI_IMM_INT64
) {
935 for (j
= nr
; j
< 4; j
+=2) {
936 swizzle
|= (swizzle
& 0xf) << (j
* 2);
939 for (j
= nr
; j
< 4; j
++) {
940 swizzle
|= (swizzle
& 0x3) << (j
* 2);
943 return ureg_swizzle(ureg_src_register(TGSI_FILE_IMMEDIATE
, i
),
944 (swizzle
>> 0) & 0x3,
945 (swizzle
>> 2) & 0x3,
946 (swizzle
>> 4) & 0x3,
947 (swizzle
>> 6) & 0x3);
952 ureg_DECL_immediate( struct ureg_program
*ureg
,
962 for (i
= 0; i
< nr
; i
++) {
966 return decl_immediate(ureg
, fu
.u
, nr
, TGSI_IMM_FLOAT32
);
970 ureg_DECL_immediate_f64( struct ureg_program
*ureg
,
980 assert((nr
/ 2) < 3);
981 for (i
= 0; i
< nr
/ 2; i
++) {
985 return decl_immediate(ureg
, fu
.u
, nr
, TGSI_IMM_FLOAT64
);
989 ureg_DECL_immediate_uint( struct ureg_program
*ureg
,
993 return decl_immediate(ureg
, v
, nr
, TGSI_IMM_UINT32
);
998 ureg_DECL_immediate_block_uint( struct ureg_program
*ureg
,
1005 if (ureg
->nr_immediates
+ (nr
+ 3) / 4 > UREG_MAX_IMMEDIATE
) {
1007 return ureg_src_register(TGSI_FILE_IMMEDIATE
, 0);
1010 index
= ureg
->nr_immediates
;
1011 ureg
->nr_immediates
+= (nr
+ 3) / 4;
1013 for (i
= index
; i
< ureg
->nr_immediates
; i
++) {
1014 ureg
->immediate
[i
].type
= TGSI_IMM_UINT32
;
1015 ureg
->immediate
[i
].nr
= nr
> 4 ? 4 : nr
;
1016 memcpy(ureg
->immediate
[i
].value
.u
,
1017 &v
[(i
- index
) * 4],
1018 ureg
->immediate
[i
].nr
* sizeof(uint
));
1022 return ureg_src_register(TGSI_FILE_IMMEDIATE
, index
);
1027 ureg_DECL_immediate_int( struct ureg_program
*ureg
,
1031 return decl_immediate(ureg
, (const unsigned *)v
, nr
, TGSI_IMM_INT32
);
1035 ureg_DECL_immediate_uint64( struct ureg_program
*ureg
,
1045 assert((nr
/ 2) < 3);
1046 for (i
= 0; i
< nr
/ 2; i
++) {
1050 return decl_immediate(ureg
, fu
.u
, nr
, TGSI_IMM_UINT64
);
1054 ureg_DECL_immediate_int64( struct ureg_program
*ureg
,
1064 assert((nr
/ 2) < 3);
1065 for (i
= 0; i
< nr
/ 2; i
++) {
1069 return decl_immediate(ureg
, fu
.u
, nr
, TGSI_IMM_INT64
);
1073 ureg_emit_src( struct ureg_program
*ureg
,
1074 struct ureg_src src
)
1076 unsigned size
= 1 + (src
.Indirect
? 1 : 0) +
1077 (src
.Dimension
? (src
.DimIndirect
? 2 : 1) : 0);
1079 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_INSN
, size
);
1082 assert(src
.File
!= TGSI_FILE_NULL
);
1083 assert(src
.File
< TGSI_FILE_COUNT
);
1086 out
[n
].src
.File
= src
.File
;
1087 out
[n
].src
.SwizzleX
= src
.SwizzleX
;
1088 out
[n
].src
.SwizzleY
= src
.SwizzleY
;
1089 out
[n
].src
.SwizzleZ
= src
.SwizzleZ
;
1090 out
[n
].src
.SwizzleW
= src
.SwizzleW
;
1091 out
[n
].src
.Index
= src
.Index
;
1092 out
[n
].src
.Negate
= src
.Negate
;
1093 out
[0].src
.Absolute
= src
.Absolute
;
1097 out
[0].src
.Indirect
= 1;
1099 out
[n
].ind
.File
= src
.IndirectFile
;
1100 out
[n
].ind
.Swizzle
= src
.IndirectSwizzle
;
1101 out
[n
].ind
.Index
= src
.IndirectIndex
;
1102 if (!ureg
->supports_any_inout_decl_range
&&
1103 (src
.File
== TGSI_FILE_INPUT
|| src
.File
== TGSI_FILE_OUTPUT
))
1104 out
[n
].ind
.ArrayID
= 0;
1106 out
[n
].ind
.ArrayID
= src
.ArrayID
;
1110 if (src
.Dimension
) {
1111 out
[0].src
.Dimension
= 1;
1112 out
[n
].dim
.Dimension
= 0;
1113 out
[n
].dim
.Padding
= 0;
1114 if (src
.DimIndirect
) {
1115 out
[n
].dim
.Indirect
= 1;
1116 out
[n
].dim
.Index
= src
.DimensionIndex
;
1119 out
[n
].ind
.File
= src
.DimIndFile
;
1120 out
[n
].ind
.Swizzle
= src
.DimIndSwizzle
;
1121 out
[n
].ind
.Index
= src
.DimIndIndex
;
1122 if (!ureg
->supports_any_inout_decl_range
&&
1123 (src
.File
== TGSI_FILE_INPUT
|| src
.File
== TGSI_FILE_OUTPUT
))
1124 out
[n
].ind
.ArrayID
= 0;
1126 out
[n
].ind
.ArrayID
= src
.ArrayID
;
1128 out
[n
].dim
.Indirect
= 0;
1129 out
[n
].dim
.Index
= src
.DimensionIndex
;
1139 ureg_emit_dst( struct ureg_program
*ureg
,
1140 struct ureg_dst dst
)
1142 unsigned size
= 1 + (dst
.Indirect
? 1 : 0) +
1143 (dst
.Dimension
? (dst
.DimIndirect
? 2 : 1) : 0);
1145 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_INSN
, size
);
1148 assert(dst
.File
!= TGSI_FILE_NULL
);
1149 assert(dst
.File
!= TGSI_FILE_CONSTANT
);
1150 assert(dst
.File
!= TGSI_FILE_INPUT
);
1151 assert(dst
.File
!= TGSI_FILE_SAMPLER
);
1152 assert(dst
.File
!= TGSI_FILE_SAMPLER_VIEW
);
1153 assert(dst
.File
!= TGSI_FILE_IMMEDIATE
);
1154 assert(dst
.File
< TGSI_FILE_COUNT
);
1157 out
[n
].dst
.File
= dst
.File
;
1158 out
[n
].dst
.WriteMask
= dst
.WriteMask
;
1159 out
[n
].dst
.Indirect
= dst
.Indirect
;
1160 out
[n
].dst
.Index
= dst
.Index
;
1165 out
[n
].ind
.File
= dst
.IndirectFile
;
1166 out
[n
].ind
.Swizzle
= dst
.IndirectSwizzle
;
1167 out
[n
].ind
.Index
= dst
.IndirectIndex
;
1168 if (!ureg
->supports_any_inout_decl_range
&&
1169 (dst
.File
== TGSI_FILE_INPUT
|| dst
.File
== TGSI_FILE_OUTPUT
))
1170 out
[n
].ind
.ArrayID
= 0;
1172 out
[n
].ind
.ArrayID
= dst
.ArrayID
;
1176 if (dst
.Dimension
) {
1177 out
[0].dst
.Dimension
= 1;
1178 out
[n
].dim
.Dimension
= 0;
1179 out
[n
].dim
.Padding
= 0;
1180 if (dst
.DimIndirect
) {
1181 out
[n
].dim
.Indirect
= 1;
1182 out
[n
].dim
.Index
= dst
.DimensionIndex
;
1185 out
[n
].ind
.File
= dst
.DimIndFile
;
1186 out
[n
].ind
.Swizzle
= dst
.DimIndSwizzle
;
1187 out
[n
].ind
.Index
= dst
.DimIndIndex
;
1188 if (!ureg
->supports_any_inout_decl_range
&&
1189 (dst
.File
== TGSI_FILE_INPUT
|| dst
.File
== TGSI_FILE_OUTPUT
))
1190 out
[n
].ind
.ArrayID
= 0;
1192 out
[n
].ind
.ArrayID
= dst
.ArrayID
;
1194 out
[n
].dim
.Indirect
= 0;
1195 out
[n
].dim
.Index
= dst
.DimensionIndex
;
1204 static void validate( unsigned opcode
,
1209 const struct tgsi_opcode_info
*info
= tgsi_get_opcode_info( opcode
);
1212 assert(nr_dst
== info
->num_dst
);
1213 assert(nr_src
== info
->num_src
);
1218 struct ureg_emit_insn_result
1219 ureg_emit_insn(struct ureg_program
*ureg
,
1223 boolean pred_negate
,
1224 unsigned pred_swizzle_x
,
1225 unsigned pred_swizzle_y
,
1226 unsigned pred_swizzle_z
,
1227 unsigned pred_swizzle_w
,
1231 union tgsi_any_token
*out
;
1232 uint count
= predicate
? 2 : 1;
1233 struct ureg_emit_insn_result result
;
1235 validate( opcode
, num_dst
, num_src
);
1237 out
= get_tokens( ureg
, DOMAIN_INSN
, count
);
1238 out
[0].insn
= tgsi_default_instruction();
1239 out
[0].insn
.Opcode
= opcode
;
1240 out
[0].insn
.Saturate
= saturate
;
1241 out
[0].insn
.NumDstRegs
= num_dst
;
1242 out
[0].insn
.NumSrcRegs
= num_src
;
1244 result
.insn_token
= ureg
->domain
[DOMAIN_INSN
].count
- count
;
1245 result
.extended_token
= result
.insn_token
;
1248 out
[0].insn
.Predicate
= 1;
1249 out
[1].insn_predicate
= tgsi_default_instruction_predicate();
1250 out
[1].insn_predicate
.Negate
= pred_negate
;
1251 out
[1].insn_predicate
.SwizzleX
= pred_swizzle_x
;
1252 out
[1].insn_predicate
.SwizzleY
= pred_swizzle_y
;
1253 out
[1].insn_predicate
.SwizzleZ
= pred_swizzle_z
;
1254 out
[1].insn_predicate
.SwizzleW
= pred_swizzle_w
;
1257 ureg
->nr_instructions
++;
1264 * Emit a label token.
1265 * \param label_token returns a token number indicating where the label
1266 * needs to be patched later. Later, this value should be passed to the
1267 * ureg_fixup_label() function.
1270 ureg_emit_label(struct ureg_program
*ureg
,
1271 unsigned extended_token
,
1272 unsigned *label_token
)
1274 union tgsi_any_token
*out
, *insn
;
1279 out
= get_tokens( ureg
, DOMAIN_INSN
, 1 );
1282 insn
= retrieve_token( ureg
, DOMAIN_INSN
, extended_token
);
1283 insn
->insn
.Label
= 1;
1285 *label_token
= ureg
->domain
[DOMAIN_INSN
].count
- 1;
1288 /* Will return a number which can be used in a label to point to the
1289 * next instruction to be emitted.
1292 ureg_get_instruction_number( struct ureg_program
*ureg
)
1294 return ureg
->nr_instructions
;
1297 /* Patch a given label (expressed as a token number) to point to a
1298 * given instruction (expressed as an instruction number).
1301 ureg_fixup_label(struct ureg_program
*ureg
,
1302 unsigned label_token
,
1303 unsigned instruction_number
)
1305 union tgsi_any_token
*out
= retrieve_token( ureg
, DOMAIN_INSN
, label_token
);
1307 out
->insn_label
.Label
= instruction_number
;
1312 ureg_emit_texture(struct ureg_program
*ureg
,
1313 unsigned extended_token
,
1314 unsigned target
, unsigned num_offsets
)
1316 union tgsi_any_token
*out
, *insn
;
1318 out
= get_tokens( ureg
, DOMAIN_INSN
, 1 );
1319 insn
= retrieve_token( ureg
, DOMAIN_INSN
, extended_token
);
1321 insn
->insn
.Texture
= 1;
1324 out
[0].insn_texture
.Texture
= target
;
1325 out
[0].insn_texture
.NumOffsets
= num_offsets
;
1329 ureg_emit_texture_offset(struct ureg_program
*ureg
,
1330 const struct tgsi_texture_offset
*offset
)
1332 union tgsi_any_token
*out
;
1334 out
= get_tokens( ureg
, DOMAIN_INSN
, 1);
1337 out
[0].insn_texture_offset
= *offset
;
1342 ureg_emit_memory(struct ureg_program
*ureg
,
1343 unsigned extended_token
,
1348 union tgsi_any_token
*out
, *insn
;
1350 out
= get_tokens( ureg
, DOMAIN_INSN
, 1 );
1351 insn
= retrieve_token( ureg
, DOMAIN_INSN
, extended_token
);
1353 insn
->insn
.Memory
= 1;
1356 out
[0].insn_memory
.Qualifier
= qualifier
;
1357 out
[0].insn_memory
.Texture
= texture
;
1358 out
[0].insn_memory
.Format
= format
;
1362 ureg_fixup_insn_size(struct ureg_program
*ureg
,
1365 union tgsi_any_token
*out
= retrieve_token( ureg
, DOMAIN_INSN
, insn
);
1367 assert(out
->insn
.Type
== TGSI_TOKEN_TYPE_INSTRUCTION
);
1368 out
->insn
.NrTokens
= ureg
->domain
[DOMAIN_INSN
].count
- insn
- 1;
1373 ureg_insn(struct ureg_program
*ureg
,
1375 const struct ureg_dst
*dst
,
1377 const struct ureg_src
*src
,
1380 struct ureg_emit_insn_result insn
;
1384 boolean negate
= FALSE
;
1385 unsigned swizzle
[4] = { 0 };
1387 if (nr_dst
&& ureg_dst_is_empty(dst
[0])) {
1391 saturate
= nr_dst
? dst
[0].Saturate
: FALSE
;
1392 predicate
= nr_dst
? dst
[0].Predicate
: FALSE
;
1394 negate
= dst
[0].PredNegate
;
1395 swizzle
[0] = dst
[0].PredSwizzleX
;
1396 swizzle
[1] = dst
[0].PredSwizzleY
;
1397 swizzle
[2] = dst
[0].PredSwizzleZ
;
1398 swizzle
[3] = dst
[0].PredSwizzleW
;
1401 insn
= ureg_emit_insn(ureg
,
1413 for (i
= 0; i
< nr_dst
; i
++)
1414 ureg_emit_dst( ureg
, dst
[i
] );
1416 for (i
= 0; i
< nr_src
; i
++)
1417 ureg_emit_src( ureg
, src
[i
] );
1419 ureg_fixup_insn_size( ureg
, insn
.insn_token
);
1423 ureg_tex_insn(struct ureg_program
*ureg
,
1425 const struct ureg_dst
*dst
,
1428 const struct tgsi_texture_offset
*texoffsets
,
1430 const struct ureg_src
*src
,
1433 struct ureg_emit_insn_result insn
;
1437 boolean negate
= FALSE
;
1438 unsigned swizzle
[4] = { 0 };
1440 if (nr_dst
&& ureg_dst_is_empty(dst
[0])) {
1444 saturate
= nr_dst
? dst
[0].Saturate
: FALSE
;
1445 predicate
= nr_dst
? dst
[0].Predicate
: FALSE
;
1447 negate
= dst
[0].PredNegate
;
1448 swizzle
[0] = dst
[0].PredSwizzleX
;
1449 swizzle
[1] = dst
[0].PredSwizzleY
;
1450 swizzle
[2] = dst
[0].PredSwizzleZ
;
1451 swizzle
[3] = dst
[0].PredSwizzleW
;
1454 insn
= ureg_emit_insn(ureg
,
1466 ureg_emit_texture( ureg
, insn
.extended_token
, target
, nr_offset
);
1468 for (i
= 0; i
< nr_offset
; i
++)
1469 ureg_emit_texture_offset( ureg
, &texoffsets
[i
]);
1471 for (i
= 0; i
< nr_dst
; i
++)
1472 ureg_emit_dst( ureg
, dst
[i
] );
1474 for (i
= 0; i
< nr_src
; i
++)
1475 ureg_emit_src( ureg
, src
[i
] );
1477 ureg_fixup_insn_size( ureg
, insn
.insn_token
);
1482 ureg_label_insn(struct ureg_program
*ureg
,
1484 const struct ureg_src
*src
,
1486 unsigned *label_token
)
1488 struct ureg_emit_insn_result insn
;
1491 insn
= ureg_emit_insn(ureg
,
1503 ureg_emit_label( ureg
, insn
.extended_token
, label_token
);
1505 for (i
= 0; i
< nr_src
; i
++)
1506 ureg_emit_src( ureg
, src
[i
] );
1508 ureg_fixup_insn_size( ureg
, insn
.insn_token
);
1513 ureg_memory_insn(struct ureg_program
*ureg
,
1515 const struct ureg_dst
*dst
,
1517 const struct ureg_src
*src
,
1523 struct ureg_emit_insn_result insn
;
1526 insn
= ureg_emit_insn(ureg
,
1538 ureg_emit_memory(ureg
, insn
.extended_token
, qualifier
, texture
, format
);
1540 for (i
= 0; i
< nr_dst
; i
++)
1541 ureg_emit_dst(ureg
, dst
[i
]);
1543 for (i
= 0; i
< nr_src
; i
++)
1544 ureg_emit_src(ureg
, src
[i
]);
1546 ureg_fixup_insn_size(ureg
, insn
.insn_token
);
1551 emit_decl_semantic(struct ureg_program
*ureg
,
1555 unsigned semantic_name
,
1556 unsigned semantic_index
,
1557 unsigned usage_mask
,
1560 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, array_id
? 4 : 3);
1563 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1564 out
[0].decl
.NrTokens
= 3;
1565 out
[0].decl
.File
= file
;
1566 out
[0].decl
.UsageMask
= usage_mask
;
1567 out
[0].decl
.Semantic
= 1;
1568 out
[0].decl
.Array
= array_id
!= 0;
1571 out
[1].decl_range
.First
= first
;
1572 out
[1].decl_range
.Last
= last
;
1575 out
[2].decl_semantic
.Name
= semantic_name
;
1576 out
[2].decl_semantic
.Index
= semantic_index
;
1580 out
[3].array
.ArrayID
= array_id
;
1586 emit_decl_fs(struct ureg_program
*ureg
,
1590 unsigned semantic_name
,
1591 unsigned semantic_index
,
1592 unsigned interpolate
,
1593 unsigned cylindrical_wrap
,
1594 unsigned interpolate_location
,
1596 unsigned usage_mask
)
1598 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
,
1602 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1603 out
[0].decl
.NrTokens
= 4;
1604 out
[0].decl
.File
= file
;
1605 out
[0].decl
.UsageMask
= usage_mask
;
1606 out
[0].decl
.Interpolate
= 1;
1607 out
[0].decl
.Semantic
= 1;
1608 out
[0].decl
.Array
= array_id
!= 0;
1611 out
[1].decl_range
.First
= first
;
1612 out
[1].decl_range
.Last
= last
;
1615 out
[2].decl_interp
.Interpolate
= interpolate
;
1616 out
[2].decl_interp
.CylindricalWrap
= cylindrical_wrap
;
1617 out
[2].decl_interp
.Location
= interpolate_location
;
1620 out
[3].decl_semantic
.Name
= semantic_name
;
1621 out
[3].decl_semantic
.Index
= semantic_index
;
1625 out
[4].array
.ArrayID
= array_id
;
1630 emit_decl_temps( struct ureg_program
*ureg
,
1631 unsigned first
, unsigned last
,
1635 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
,
1639 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1640 out
[0].decl
.NrTokens
= 2;
1641 out
[0].decl
.File
= TGSI_FILE_TEMPORARY
;
1642 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1643 out
[0].decl
.Local
= local
;
1646 out
[1].decl_range
.First
= first
;
1647 out
[1].decl_range
.Last
= last
;
1650 out
[0].decl
.Array
= 1;
1652 out
[2].array
.ArrayID
= arrayid
;
1656 static void emit_decl_range( struct ureg_program
*ureg
,
1661 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 2 );
1664 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1665 out
[0].decl
.NrTokens
= 2;
1666 out
[0].decl
.File
= file
;
1667 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1668 out
[0].decl
.Semantic
= 0;
1671 out
[1].decl_range
.First
= first
;
1672 out
[1].decl_range
.Last
= first
+ count
- 1;
1676 emit_decl_range2D(struct ureg_program
*ureg
,
1682 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 3);
1685 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1686 out
[0].decl
.NrTokens
= 3;
1687 out
[0].decl
.File
= file
;
1688 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1689 out
[0].decl
.Dimension
= 1;
1692 out
[1].decl_range
.First
= first
;
1693 out
[1].decl_range
.Last
= last
;
1696 out
[2].decl_dim
.Index2D
= index2D
;
1700 emit_decl_sampler_view(struct ureg_program
*ureg
,
1703 unsigned return_type_x
,
1704 unsigned return_type_y
,
1705 unsigned return_type_z
,
1706 unsigned return_type_w
)
1708 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 3);
1711 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1712 out
[0].decl
.NrTokens
= 3;
1713 out
[0].decl
.File
= TGSI_FILE_SAMPLER_VIEW
;
1714 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1717 out
[1].decl_range
.First
= index
;
1718 out
[1].decl_range
.Last
= index
;
1721 out
[2].decl_sampler_view
.Resource
= target
;
1722 out
[2].decl_sampler_view
.ReturnTypeX
= return_type_x
;
1723 out
[2].decl_sampler_view
.ReturnTypeY
= return_type_y
;
1724 out
[2].decl_sampler_view
.ReturnTypeZ
= return_type_z
;
1725 out
[2].decl_sampler_view
.ReturnTypeW
= return_type_w
;
1729 emit_decl_image(struct ureg_program
*ureg
,
1736 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 3);
1739 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1740 out
[0].decl
.NrTokens
= 3;
1741 out
[0].decl
.File
= TGSI_FILE_IMAGE
;
1742 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1745 out
[1].decl_range
.First
= index
;
1746 out
[1].decl_range
.Last
= index
;
1749 out
[2].decl_image
.Resource
= target
;
1750 out
[2].decl_image
.Writable
= wr
;
1751 out
[2].decl_image
.Raw
= raw
;
1752 out
[2].decl_image
.Format
= format
;
1756 emit_decl_buffer(struct ureg_program
*ureg
,
1760 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 2);
1763 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1764 out
[0].decl
.NrTokens
= 2;
1765 out
[0].decl
.File
= TGSI_FILE_BUFFER
;
1766 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1767 out
[0].decl
.Atomic
= atomic
;
1770 out
[1].decl_range
.First
= index
;
1771 out
[1].decl_range
.Last
= index
;
1775 emit_decl_memory(struct ureg_program
*ureg
, unsigned memory_type
)
1777 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 2);
1780 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1781 out
[0].decl
.NrTokens
= 2;
1782 out
[0].decl
.File
= TGSI_FILE_MEMORY
;
1783 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1784 out
[0].decl
.MemType
= memory_type
;
1787 out
[1].decl_range
.First
= memory_type
;
1788 out
[1].decl_range
.Last
= memory_type
;
1792 emit_immediate( struct ureg_program
*ureg
,
1796 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 5 );
1799 out
[0].imm
.Type
= TGSI_TOKEN_TYPE_IMMEDIATE
;
1800 out
[0].imm
.NrTokens
= 5;
1801 out
[0].imm
.DataType
= type
;
1802 out
[0].imm
.Padding
= 0;
1804 out
[1].imm_data
.Uint
= v
[0];
1805 out
[2].imm_data
.Uint
= v
[1];
1806 out
[3].imm_data
.Uint
= v
[2];
1807 out
[4].imm_data
.Uint
= v
[3];
1811 emit_property(struct ureg_program
*ureg
,
1815 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 2);
1818 out
[0].prop
.Type
= TGSI_TOKEN_TYPE_PROPERTY
;
1819 out
[0].prop
.NrTokens
= 2;
1820 out
[0].prop
.PropertyName
= name
;
1822 out
[1].prop_data
.Data
= data
;
1826 static void emit_decls( struct ureg_program
*ureg
)
1830 for (i
= 0; i
< ARRAY_SIZE(ureg
->properties
); i
++)
1831 if (ureg
->properties
[i
] != ~0)
1832 emit_property(ureg
, i
, ureg
->properties
[i
]);
1834 if (ureg
->processor
== PIPE_SHADER_VERTEX
) {
1835 for (i
= 0; i
< PIPE_MAX_ATTRIBS
; i
++) {
1836 if (ureg
->vs_inputs
[i
/32] & (1u << (i
%32))) {
1837 emit_decl_range( ureg
, TGSI_FILE_INPUT
, i
, 1 );
1840 } else if (ureg
->processor
== PIPE_SHADER_FRAGMENT
) {
1841 if (ureg
->supports_any_inout_decl_range
) {
1842 for (i
= 0; i
< ureg
->nr_inputs
; i
++) {
1845 ureg
->input
[i
].first
,
1846 ureg
->input
[i
].last
,
1847 ureg
->input
[i
].semantic_name
,
1848 ureg
->input
[i
].semantic_index
,
1849 ureg
->input
[i
].interp
,
1850 ureg
->input
[i
].cylindrical_wrap
,
1851 ureg
->input
[i
].interp_location
,
1852 ureg
->input
[i
].array_id
,
1853 ureg
->input
[i
].usage_mask
);
1857 for (i
= 0; i
< ureg
->nr_inputs
; i
++) {
1858 for (j
= ureg
->input
[i
].first
; j
<= ureg
->input
[i
].last
; j
++) {
1862 ureg
->input
[i
].semantic_name
,
1863 ureg
->input
[i
].semantic_index
+
1864 (j
- ureg
->input
[i
].first
),
1865 ureg
->input
[i
].interp
,
1866 ureg
->input
[i
].cylindrical_wrap
,
1867 ureg
->input
[i
].interp_location
, 0,
1868 ureg
->input
[i
].usage_mask
);
1873 if (ureg
->supports_any_inout_decl_range
) {
1874 for (i
= 0; i
< ureg
->nr_inputs
; i
++) {
1875 emit_decl_semantic(ureg
,
1877 ureg
->input
[i
].first
,
1878 ureg
->input
[i
].last
,
1879 ureg
->input
[i
].semantic_name
,
1880 ureg
->input
[i
].semantic_index
,
1881 TGSI_WRITEMASK_XYZW
,
1882 ureg
->input
[i
].array_id
);
1886 for (i
= 0; i
< ureg
->nr_inputs
; i
++) {
1887 for (j
= ureg
->input
[i
].first
; j
<= ureg
->input
[i
].last
; j
++) {
1888 emit_decl_semantic(ureg
,
1891 ureg
->input
[i
].semantic_name
,
1892 ureg
->input
[i
].semantic_index
+
1893 (j
- ureg
->input
[i
].first
),
1894 TGSI_WRITEMASK_XYZW
, 0);
1900 for (i
= 0; i
< ureg
->nr_system_values
; i
++) {
1901 emit_decl_semantic(ureg
,
1902 TGSI_FILE_SYSTEM_VALUE
,
1905 ureg
->system_value
[i
].semantic_name
,
1906 ureg
->system_value
[i
].semantic_index
,
1907 TGSI_WRITEMASK_XYZW
, 0);
1910 if (ureg
->supports_any_inout_decl_range
) {
1911 for (i
= 0; i
< ureg
->nr_outputs
; i
++) {
1912 emit_decl_semantic(ureg
,
1914 ureg
->output
[i
].first
,
1915 ureg
->output
[i
].last
,
1916 ureg
->output
[i
].semantic_name
,
1917 ureg
->output
[i
].semantic_index
,
1918 ureg
->output
[i
].usage_mask
,
1919 ureg
->output
[i
].array_id
);
1923 for (i
= 0; i
< ureg
->nr_outputs
; i
++) {
1924 for (j
= ureg
->output
[i
].first
; j
<= ureg
->output
[i
].last
; j
++) {
1925 emit_decl_semantic(ureg
,
1928 ureg
->output
[i
].semantic_name
,
1929 ureg
->output
[i
].semantic_index
+
1930 (j
- ureg
->output
[i
].first
),
1931 ureg
->output
[i
].usage_mask
, 0);
1936 for (i
= 0; i
< ureg
->nr_samplers
; i
++) {
1937 emit_decl_range( ureg
,
1939 ureg
->sampler
[i
].Index
, 1 );
1942 for (i
= 0; i
< ureg
->nr_sampler_views
; i
++) {
1943 emit_decl_sampler_view(ureg
,
1944 ureg
->sampler_view
[i
].index
,
1945 ureg
->sampler_view
[i
].target
,
1946 ureg
->sampler_view
[i
].return_type_x
,
1947 ureg
->sampler_view
[i
].return_type_y
,
1948 ureg
->sampler_view
[i
].return_type_z
,
1949 ureg
->sampler_view
[i
].return_type_w
);
1952 for (i
= 0; i
< ureg
->nr_images
; i
++) {
1953 emit_decl_image(ureg
,
1954 ureg
->image
[i
].index
,
1955 ureg
->image
[i
].target
,
1956 ureg
->image
[i
].format
,
1958 ureg
->image
[i
].raw
);
1961 for (i
= 0; i
< ureg
->nr_buffers
; i
++) {
1962 emit_decl_buffer(ureg
, ureg
->buffer
[i
].index
, ureg
->buffer
[i
].atomic
);
1965 for (i
= 0; i
< TGSI_MEMORY_TYPE_COUNT
; i
++) {
1966 if (ureg
->use_memory
[i
])
1967 emit_decl_memory(ureg
, i
);
1970 if (ureg
->const_decls
.nr_constant_ranges
) {
1971 for (i
= 0; i
< ureg
->const_decls
.nr_constant_ranges
; i
++) {
1972 emit_decl_range(ureg
,
1974 ureg
->const_decls
.constant_range
[i
].first
,
1975 ureg
->const_decls
.constant_range
[i
].last
- ureg
->const_decls
.constant_range
[i
].first
+ 1);
1979 for (i
= 0; i
< PIPE_MAX_CONSTANT_BUFFERS
; i
++) {
1980 struct const_decl
*decl
= &ureg
->const_decls2D
[i
];
1982 if (decl
->nr_constant_ranges
) {
1985 for (j
= 0; j
< decl
->nr_constant_ranges
; j
++) {
1986 emit_decl_range2D(ureg
,
1988 decl
->constant_range
[j
].first
,
1989 decl
->constant_range
[j
].last
,
1995 if (ureg
->nr_temps
) {
1997 for (i
= 0; i
< ureg
->nr_temps
;) {
1998 boolean local
= util_bitmask_get(ureg
->local_temps
, i
);
2000 i
= util_bitmask_get_next_index(ureg
->decl_temps
, i
+ 1);
2001 if (i
== UTIL_BITMASK_INVALID_INDEX
)
2004 if (array
< ureg
->nr_array_temps
&& ureg
->array_temps
[array
] == first
)
2005 emit_decl_temps( ureg
, first
, i
- 1, local
, ++array
);
2007 emit_decl_temps( ureg
, first
, i
- 1, local
, 0 );
2011 if (ureg
->nr_addrs
) {
2012 emit_decl_range( ureg
,
2014 0, ureg
->nr_addrs
);
2017 if (ureg
->nr_preds
) {
2018 emit_decl_range(ureg
,
2019 TGSI_FILE_PREDICATE
,
2024 for (i
= 0; i
< ureg
->nr_immediates
; i
++) {
2025 emit_immediate( ureg
,
2026 ureg
->immediate
[i
].value
.u
,
2027 ureg
->immediate
[i
].type
);
2031 /* Append the instruction tokens onto the declarations to build a
2032 * contiguous stream suitable to send to the driver.
2034 static void copy_instructions( struct ureg_program
*ureg
)
2036 unsigned nr_tokens
= ureg
->domain
[DOMAIN_INSN
].count
;
2037 union tgsi_any_token
*out
= get_tokens( ureg
,
2042 ureg
->domain
[DOMAIN_INSN
].tokens
,
2043 nr_tokens
* sizeof out
[0] );
2048 fixup_header_size(struct ureg_program
*ureg
)
2050 union tgsi_any_token
*out
= retrieve_token( ureg
, DOMAIN_DECL
, 0 );
2052 out
->header
.BodySize
= ureg
->domain
[DOMAIN_DECL
].count
- 2;
2057 emit_header( struct ureg_program
*ureg
)
2059 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 2 );
2061 out
[0].header
.HeaderSize
= 2;
2062 out
[0].header
.BodySize
= 0;
2064 out
[1].processor
.Processor
= ureg
->processor
;
2065 out
[1].processor
.Padding
= 0;
2069 const struct tgsi_token
*ureg_finalize( struct ureg_program
*ureg
)
2071 const struct tgsi_token
*tokens
;
2073 switch (ureg
->processor
) {
2074 case PIPE_SHADER_VERTEX
:
2075 case PIPE_SHADER_TESS_EVAL
:
2076 ureg_property(ureg
, TGSI_PROPERTY_NEXT_SHADER
,
2077 ureg
->next_shader_processor
== -1 ?
2078 PIPE_SHADER_FRAGMENT
:
2079 ureg
->next_shader_processor
);
2083 emit_header( ureg
);
2085 copy_instructions( ureg
);
2086 fixup_header_size( ureg
);
2088 if (ureg
->domain
[0].tokens
== error_tokens
||
2089 ureg
->domain
[1].tokens
== error_tokens
) {
2090 debug_printf("%s: error in generated shader\n", __FUNCTION__
);
2095 tokens
= &ureg
->domain
[DOMAIN_DECL
].tokens
[0].token
;
2098 debug_printf("%s: emitted shader %d tokens:\n", __FUNCTION__
,
2099 ureg
->domain
[DOMAIN_DECL
].count
);
2100 tgsi_dump( tokens
, 0 );
2104 if (tokens
&& !tgsi_sanity_check(tokens
)) {
2105 debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n");
2106 tgsi_dump(tokens
, 0);
2116 void *ureg_create_shader( struct ureg_program
*ureg
,
2117 struct pipe_context
*pipe
,
2118 const struct pipe_stream_output_info
*so
)
2120 struct pipe_shader_state state
;
2122 pipe_shader_state_from_tgsi(&state
, ureg_finalize(ureg
));
2127 state
.stream_output
= *so
;
2129 switch (ureg
->processor
) {
2130 case PIPE_SHADER_VERTEX
:
2131 return pipe
->create_vs_state(pipe
, &state
);
2132 case PIPE_SHADER_TESS_CTRL
:
2133 return pipe
->create_tcs_state(pipe
, &state
);
2134 case PIPE_SHADER_TESS_EVAL
:
2135 return pipe
->create_tes_state(pipe
, &state
);
2136 case PIPE_SHADER_GEOMETRY
:
2137 return pipe
->create_gs_state(pipe
, &state
);
2138 case PIPE_SHADER_FRAGMENT
:
2139 return pipe
->create_fs_state(pipe
, &state
);
2146 const struct tgsi_token
*ureg_get_tokens( struct ureg_program
*ureg
,
2147 unsigned *nr_tokens
)
2149 const struct tgsi_token
*tokens
;
2151 ureg_finalize(ureg
);
2153 tokens
= &ureg
->domain
[DOMAIN_DECL
].tokens
[0].token
;
2156 *nr_tokens
= ureg
->domain
[DOMAIN_DECL
].size
;
2158 ureg
->domain
[DOMAIN_DECL
].tokens
= 0;
2159 ureg
->domain
[DOMAIN_DECL
].size
= 0;
2160 ureg
->domain
[DOMAIN_DECL
].order
= 0;
2161 ureg
->domain
[DOMAIN_DECL
].count
= 0;
2167 void ureg_free_tokens( const struct tgsi_token
*tokens
)
2169 FREE((struct tgsi_token
*)tokens
);
2173 struct ureg_program
*
2174 ureg_create(unsigned processor
)
2176 return ureg_create_with_screen(processor
, NULL
);
2180 struct ureg_program
*
2181 ureg_create_with_screen(unsigned processor
, struct pipe_screen
*screen
)
2184 struct ureg_program
*ureg
= CALLOC_STRUCT( ureg_program
);
2188 ureg
->processor
= processor
;
2189 ureg
->supports_any_inout_decl_range
=
2191 screen
->get_shader_param(screen
, processor
,
2192 PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE
) != 0;
2193 ureg
->next_shader_processor
= -1;
2195 for (i
= 0; i
< ARRAY_SIZE(ureg
->properties
); i
++)
2196 ureg
->properties
[i
] = ~0;
2198 ureg
->free_temps
= util_bitmask_create();
2199 if (ureg
->free_temps
== NULL
)
2202 ureg
->local_temps
= util_bitmask_create();
2203 if (ureg
->local_temps
== NULL
)
2204 goto no_local_temps
;
2206 ureg
->decl_temps
= util_bitmask_create();
2207 if (ureg
->decl_temps
== NULL
)
2213 util_bitmask_destroy(ureg
->local_temps
);
2215 util_bitmask_destroy(ureg
->free_temps
);
2224 ureg_set_next_shader_processor(struct ureg_program
*ureg
, unsigned processor
)
2226 ureg
->next_shader_processor
= processor
;
2231 ureg_get_nr_outputs( const struct ureg_program
*ureg
)
2235 return ureg
->nr_outputs
;
2239 void ureg_destroy( struct ureg_program
*ureg
)
2243 for (i
= 0; i
< ARRAY_SIZE(ureg
->domain
); i
++) {
2244 if (ureg
->domain
[i
].tokens
&&
2245 ureg
->domain
[i
].tokens
!= error_tokens
)
2246 FREE(ureg
->domain
[i
].tokens
);
2249 util_bitmask_destroy(ureg
->free_temps
);
2250 util_bitmask_destroy(ureg
->local_temps
);
2251 util_bitmask_destroy(ureg
->decl_temps
);