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_context.h"
30 #include "pipe/p_state.h"
31 #include "tgsi/tgsi_ureg.h"
32 #include "tgsi/tgsi_build.h"
33 #include "tgsi/tgsi_info.h"
34 #include "tgsi/tgsi_dump.h"
35 #include "tgsi/tgsi_sanity.h"
36 #include "util/u_debug.h"
37 #include "util/u_memory.h"
38 #include "util/u_math.h"
39 #include "util/u_bitmask.h"
41 union tgsi_any_token
{
42 struct tgsi_header header
;
43 struct tgsi_processor processor
;
44 struct tgsi_token token
;
45 struct tgsi_property prop
;
46 struct tgsi_property_data prop_data
;
47 struct tgsi_declaration decl
;
48 struct tgsi_declaration_range decl_range
;
49 struct tgsi_declaration_dimension decl_dim
;
50 struct tgsi_declaration_interp decl_interp
;
51 struct tgsi_declaration_semantic decl_semantic
;
52 struct tgsi_declaration_sampler_view decl_sampler_view
;
53 struct tgsi_declaration_array array
;
54 struct tgsi_immediate imm
;
55 union tgsi_immediate_data imm_data
;
56 struct tgsi_instruction insn
;
57 struct tgsi_instruction_predicate insn_predicate
;
58 struct tgsi_instruction_label insn_label
;
59 struct tgsi_instruction_texture insn_texture
;
60 struct tgsi_texture_offset insn_texture_offset
;
61 struct tgsi_src_register src
;
62 struct tgsi_ind_register ind
;
63 struct tgsi_dimension dim
;
64 struct tgsi_dst_register dst
;
70 union tgsi_any_token
*tokens
;
76 #define UREG_MAX_INPUT PIPE_MAX_ATTRIBS
77 #define UREG_MAX_SYSTEM_VALUE PIPE_MAX_ATTRIBS
78 #define UREG_MAX_OUTPUT PIPE_MAX_SHADER_OUTPUTS
79 #define UREG_MAX_CONSTANT_RANGE 32
80 #define UREG_MAX_IMMEDIATE 4096
81 #define UREG_MAX_ADDR 2
82 #define UREG_MAX_PRED 1
83 #define UREG_MAX_ARRAY_TEMPS 256
89 } constant_range
[UREG_MAX_CONSTANT_RANGE
];
90 unsigned nr_constant_ranges
;
99 struct pipe_context
*pipe
;
102 unsigned semantic_name
;
103 unsigned semantic_index
;
105 unsigned char cylindrical_wrap
;
106 unsigned char centroid
;
107 } fs_input
[UREG_MAX_INPUT
];
108 unsigned nr_fs_inputs
;
110 unsigned vs_inputs
[UREG_MAX_INPUT
/32];
114 unsigned semantic_name
;
115 unsigned semantic_index
;
116 } gs_input
[UREG_MAX_INPUT
];
117 unsigned nr_gs_inputs
;
121 unsigned semantic_name
;
122 unsigned semantic_index
;
123 } system_value
[UREG_MAX_SYSTEM_VALUE
];
124 unsigned nr_system_values
;
127 unsigned semantic_name
;
128 unsigned semantic_index
;
129 unsigned usage_mask
; /* = TGSI_WRITEMASK_* */
130 } output
[UREG_MAX_OUTPUT
];
141 } immediate
[UREG_MAX_IMMEDIATE
];
142 unsigned nr_immediates
;
144 struct ureg_src sampler
[PIPE_MAX_SAMPLERS
];
145 unsigned nr_samplers
;
150 unsigned return_type_x
;
151 unsigned return_type_y
;
152 unsigned return_type_z
;
153 unsigned return_type_w
;
154 } sampler_view
[PIPE_MAX_SHADER_SAMPLER_VIEWS
];
155 unsigned nr_sampler_views
;
157 struct util_bitmask
*free_temps
;
158 struct util_bitmask
*local_temps
;
159 struct util_bitmask
*decl_temps
;
162 unsigned array_temps
[UREG_MAX_ARRAY_TEMPS
];
163 unsigned nr_array_temps
;
165 struct const_decl const_decls
;
166 struct const_decl const_decls2D
[PIPE_MAX_CONSTANT_BUFFERS
];
168 unsigned property_gs_input_prim
;
169 unsigned property_gs_output_prim
;
170 unsigned property_gs_max_vertices
;
171 unsigned property_gs_invocations
;
172 unsigned char property_fs_coord_origin
; /* = TGSI_FS_COORD_ORIGIN_* */
173 unsigned char property_fs_coord_pixel_center
; /* = TGSI_FS_COORD_PIXEL_CENTER_* */
174 unsigned char property_fs_color0_writes_all_cbufs
; /* = TGSI_FS_COLOR0_WRITES_ALL_CBUFS * */
175 unsigned char property_fs_depth_layout
; /* TGSI_FS_DEPTH_LAYOUT */
176 boolean property_vs_window_space_position
; /* TGSI_VS_WINDOW_SPACE_POSITION */
180 unsigned nr_instructions
;
182 struct ureg_tokens domain
[2];
185 static union tgsi_any_token error_tokens
[32];
187 static void tokens_error( struct ureg_tokens
*tokens
)
189 if (tokens
->tokens
&& tokens
->tokens
!= error_tokens
)
190 FREE(tokens
->tokens
);
192 tokens
->tokens
= error_tokens
;
193 tokens
->size
= Elements(error_tokens
);
198 static void tokens_expand( struct ureg_tokens
*tokens
,
201 unsigned old_size
= tokens
->size
* sizeof(unsigned);
203 if (tokens
->tokens
== error_tokens
) {
207 while (tokens
->count
+ count
> tokens
->size
) {
208 tokens
->size
= (1 << ++tokens
->order
);
211 tokens
->tokens
= REALLOC(tokens
->tokens
,
213 tokens
->size
* sizeof(unsigned));
214 if (tokens
->tokens
== NULL
) {
215 tokens_error(tokens
);
219 static void set_bad( struct ureg_program
*ureg
)
221 tokens_error(&ureg
->domain
[0]);
226 static union tgsi_any_token
*get_tokens( struct ureg_program
*ureg
,
230 struct ureg_tokens
*tokens
= &ureg
->domain
[domain
];
231 union tgsi_any_token
*result
;
233 if (tokens
->count
+ count
> tokens
->size
)
234 tokens_expand(tokens
, count
);
236 result
= &tokens
->tokens
[tokens
->count
];
237 tokens
->count
+= count
;
242 static union tgsi_any_token
*retrieve_token( struct ureg_program
*ureg
,
246 if (ureg
->domain
[domain
].tokens
== error_tokens
)
247 return &error_tokens
[0];
249 return &ureg
->domain
[domain
].tokens
[nr
];
254 static INLINE
struct ureg_dst
255 ureg_dst_register( unsigned file
,
261 dst
.WriteMask
= TGSI_WRITEMASK_XYZW
;
263 dst
.IndirectFile
= TGSI_FILE_NULL
;
264 dst
.IndirectIndex
= 0;
265 dst
.IndirectSwizzle
= 0;
269 dst
.PredSwizzleX
= TGSI_SWIZZLE_X
;
270 dst
.PredSwizzleY
= TGSI_SWIZZLE_Y
;
271 dst
.PredSwizzleZ
= TGSI_SWIZZLE_Z
;
272 dst
.PredSwizzleW
= TGSI_SWIZZLE_W
;
281 ureg_property_gs_input_prim(struct ureg_program
*ureg
,
284 ureg
->property_gs_input_prim
= input_prim
;
288 ureg_property_gs_output_prim(struct ureg_program
*ureg
,
289 unsigned output_prim
)
291 ureg
->property_gs_output_prim
= output_prim
;
295 ureg_property_gs_max_vertices(struct ureg_program
*ureg
,
296 unsigned max_vertices
)
298 ureg
->property_gs_max_vertices
= max_vertices
;
301 ureg_property_gs_invocations(struct ureg_program
*ureg
,
302 unsigned invocations
)
304 ureg
->property_gs_invocations
= invocations
;
308 ureg_property_fs_coord_origin(struct ureg_program
*ureg
,
309 unsigned fs_coord_origin
)
311 ureg
->property_fs_coord_origin
= fs_coord_origin
;
315 ureg_property_fs_coord_pixel_center(struct ureg_program
*ureg
,
316 unsigned fs_coord_pixel_center
)
318 ureg
->property_fs_coord_pixel_center
= fs_coord_pixel_center
;
322 ureg_property_fs_color0_writes_all_cbufs(struct ureg_program
*ureg
,
323 unsigned fs_color0_writes_all_cbufs
)
325 ureg
->property_fs_color0_writes_all_cbufs
= fs_color0_writes_all_cbufs
;
329 ureg_property_fs_depth_layout(struct ureg_program
*ureg
,
330 unsigned fs_depth_layout
)
332 ureg
->property_fs_depth_layout
= fs_depth_layout
;
336 ureg_property_vs_window_space_position(struct ureg_program
*ureg
,
337 boolean vs_window_space_position
)
339 ureg
->property_vs_window_space_position
= vs_window_space_position
;
343 ureg_DECL_fs_input_cyl_centroid(struct ureg_program
*ureg
,
344 unsigned semantic_name
,
345 unsigned semantic_index
,
346 unsigned interp_mode
,
347 unsigned cylindrical_wrap
,
352 for (i
= 0; i
< ureg
->nr_fs_inputs
; i
++) {
353 if (ureg
->fs_input
[i
].semantic_name
== semantic_name
&&
354 ureg
->fs_input
[i
].semantic_index
== semantic_index
) {
359 if (ureg
->nr_fs_inputs
< UREG_MAX_INPUT
) {
360 ureg
->fs_input
[i
].semantic_name
= semantic_name
;
361 ureg
->fs_input
[i
].semantic_index
= semantic_index
;
362 ureg
->fs_input
[i
].interp
= interp_mode
;
363 ureg
->fs_input
[i
].cylindrical_wrap
= cylindrical_wrap
;
364 ureg
->fs_input
[i
].centroid
= centroid
;
365 ureg
->nr_fs_inputs
++;
371 return ureg_src_register(TGSI_FILE_INPUT
, i
);
376 ureg_DECL_vs_input( struct ureg_program
*ureg
,
379 assert(ureg
->processor
== TGSI_PROCESSOR_VERTEX
);
381 ureg
->vs_inputs
[index
/32] |= 1 << (index
% 32);
382 return ureg_src_register( TGSI_FILE_INPUT
, index
);
387 ureg_DECL_gs_input(struct ureg_program
*ureg
,
389 unsigned semantic_name
,
390 unsigned semantic_index
)
392 if (ureg
->nr_gs_inputs
< UREG_MAX_INPUT
) {
393 ureg
->gs_input
[ureg
->nr_gs_inputs
].index
= index
;
394 ureg
->gs_input
[ureg
->nr_gs_inputs
].semantic_name
= semantic_name
;
395 ureg
->gs_input
[ureg
->nr_gs_inputs
].semantic_index
= semantic_index
;
396 ureg
->nr_gs_inputs
++;
401 /* XXX: Add suport for true 2D input registers. */
402 return ureg_src_register(TGSI_FILE_INPUT
, index
);
407 ureg_DECL_system_value(struct ureg_program
*ureg
,
409 unsigned semantic_name
,
410 unsigned semantic_index
)
412 if (ureg
->nr_system_values
< UREG_MAX_SYSTEM_VALUE
) {
413 ureg
->system_value
[ureg
->nr_system_values
].index
= index
;
414 ureg
->system_value
[ureg
->nr_system_values
].semantic_name
= semantic_name
;
415 ureg
->system_value
[ureg
->nr_system_values
].semantic_index
= semantic_index
;
416 ureg
->nr_system_values
++;
421 return ureg_src_register(TGSI_FILE_SYSTEM_VALUE
, index
);
426 ureg_DECL_output_masked( struct ureg_program
*ureg
,
429 unsigned usage_mask
)
433 assert(usage_mask
!= 0);
435 for (i
= 0; i
< ureg
->nr_outputs
; i
++) {
436 if (ureg
->output
[i
].semantic_name
== name
&&
437 ureg
->output
[i
].semantic_index
== index
) {
438 ureg
->output
[i
].usage_mask
|= usage_mask
;
443 if (ureg
->nr_outputs
< UREG_MAX_OUTPUT
) {
444 ureg
->output
[i
].semantic_name
= name
;
445 ureg
->output
[i
].semantic_index
= index
;
446 ureg
->output
[i
].usage_mask
= usage_mask
;
454 return ureg_dst_register( TGSI_FILE_OUTPUT
, i
);
459 ureg_DECL_output( struct ureg_program
*ureg
,
463 return ureg_DECL_output_masked(ureg
, name
, index
, TGSI_WRITEMASK_XYZW
);
467 /* Returns a new constant register. Keep track of which have been
468 * referred to so that we can emit decls later.
470 * Constant operands declared with this function must be addressed
471 * with a two-dimensional index.
473 * There is nothing in this code to bind this constant to any tracked
474 * value or manage any constant_buffer contents -- that's the
475 * resposibility of the calling code.
478 ureg_DECL_constant2D(struct ureg_program
*ureg
,
483 struct const_decl
*decl
= &ureg
->const_decls2D
[index2D
];
485 assert(index2D
< PIPE_MAX_CONSTANT_BUFFERS
);
487 if (decl
->nr_constant_ranges
< UREG_MAX_CONSTANT_RANGE
) {
488 uint i
= decl
->nr_constant_ranges
++;
490 decl
->constant_range
[i
].first
= first
;
491 decl
->constant_range
[i
].last
= last
;
496 /* A one-dimensional, depricated version of ureg_DECL_constant2D().
498 * Constant operands declared with this function must be addressed
499 * with a one-dimensional index.
502 ureg_DECL_constant(struct ureg_program
*ureg
,
505 struct const_decl
*decl
= &ureg
->const_decls
;
506 unsigned minconst
= index
, maxconst
= index
;
509 /* Inside existing range?
511 for (i
= 0; i
< decl
->nr_constant_ranges
; i
++) {
512 if (decl
->constant_range
[i
].first
<= index
&&
513 decl
->constant_range
[i
].last
>= index
) {
518 /* Extend existing range?
520 for (i
= 0; i
< decl
->nr_constant_ranges
; i
++) {
521 if (decl
->constant_range
[i
].last
== index
- 1) {
522 decl
->constant_range
[i
].last
= index
;
526 if (decl
->constant_range
[i
].first
== index
+ 1) {
527 decl
->constant_range
[i
].first
= index
;
531 minconst
= MIN2(minconst
, decl
->constant_range
[i
].first
);
532 maxconst
= MAX2(maxconst
, decl
->constant_range
[i
].last
);
537 if (decl
->nr_constant_ranges
< UREG_MAX_CONSTANT_RANGE
) {
538 i
= decl
->nr_constant_ranges
++;
539 decl
->constant_range
[i
].first
= index
;
540 decl
->constant_range
[i
].last
= index
;
544 /* Collapse all ranges down to one:
547 decl
->constant_range
[0].first
= minconst
;
548 decl
->constant_range
[0].last
= maxconst
;
549 decl
->nr_constant_ranges
= 1;
552 assert(i
< decl
->nr_constant_ranges
);
553 assert(decl
->constant_range
[i
].first
<= index
);
554 assert(decl
->constant_range
[i
].last
>= index
);
555 return ureg_src_register(TGSI_FILE_CONSTANT
, index
);
558 static struct ureg_dst
alloc_temporary( struct ureg_program
*ureg
,
563 /* Look for a released temporary.
565 for (i
= util_bitmask_get_first_index(ureg
->free_temps
);
566 i
!= UTIL_BITMASK_INVALID_INDEX
;
567 i
= util_bitmask_get_next_index(ureg
->free_temps
, i
+ 1)) {
568 if (util_bitmask_get(ureg
->local_temps
, i
) == local
)
572 /* Or allocate a new one.
574 if (i
== UTIL_BITMASK_INVALID_INDEX
) {
575 i
= ureg
->nr_temps
++;
578 util_bitmask_set(ureg
->local_temps
, i
);
580 /* Start a new declaration when the local flag changes */
581 if (!i
|| util_bitmask_get(ureg
->local_temps
, i
- 1) != local
)
582 util_bitmask_set(ureg
->decl_temps
, i
);
585 util_bitmask_clear(ureg
->free_temps
, i
);
587 return ureg_dst_register( TGSI_FILE_TEMPORARY
, i
);
590 struct ureg_dst
ureg_DECL_temporary( struct ureg_program
*ureg
)
592 return alloc_temporary(ureg
, FALSE
);
595 struct ureg_dst
ureg_DECL_local_temporary( struct ureg_program
*ureg
)
597 return alloc_temporary(ureg
, TRUE
);
600 struct ureg_dst
ureg_DECL_array_temporary( struct ureg_program
*ureg
,
604 unsigned i
= ureg
->nr_temps
;
605 struct ureg_dst dst
= ureg_dst_register( TGSI_FILE_TEMPORARY
, i
);
608 util_bitmask_set(ureg
->local_temps
, i
);
610 /* Always start a new declaration at the start */
611 util_bitmask_set(ureg
->decl_temps
, i
);
613 ureg
->nr_temps
+= size
;
615 /* and also at the end of the array */
616 util_bitmask_set(ureg
->decl_temps
, ureg
->nr_temps
);
618 if (ureg
->nr_array_temps
< UREG_MAX_ARRAY_TEMPS
) {
619 ureg
->array_temps
[ureg
->nr_array_temps
++] = i
;
620 dst
.ArrayID
= ureg
->nr_array_temps
;
626 void ureg_release_temporary( struct ureg_program
*ureg
,
627 struct ureg_dst tmp
)
629 if(tmp
.File
== TGSI_FILE_TEMPORARY
)
630 util_bitmask_set(ureg
->free_temps
, tmp
.Index
);
634 /* Allocate a new address register.
636 struct ureg_dst
ureg_DECL_address( struct ureg_program
*ureg
)
638 if (ureg
->nr_addrs
< UREG_MAX_ADDR
)
639 return ureg_dst_register( TGSI_FILE_ADDRESS
, ureg
->nr_addrs
++ );
642 return ureg_dst_register( TGSI_FILE_ADDRESS
, 0 );
645 /* Allocate a new predicate register.
648 ureg_DECL_predicate(struct ureg_program
*ureg
)
650 if (ureg
->nr_preds
< UREG_MAX_PRED
) {
651 return ureg_dst_register(TGSI_FILE_PREDICATE
, ureg
->nr_preds
++);
655 return ureg_dst_register(TGSI_FILE_PREDICATE
, 0);
658 /* Allocate a new sampler.
660 struct ureg_src
ureg_DECL_sampler( struct ureg_program
*ureg
,
665 for (i
= 0; i
< ureg
->nr_samplers
; i
++)
666 if (ureg
->sampler
[i
].Index
== nr
)
667 return ureg
->sampler
[i
];
669 if (i
< PIPE_MAX_SAMPLERS
) {
670 ureg
->sampler
[i
] = ureg_src_register( TGSI_FILE_SAMPLER
, nr
);
672 return ureg
->sampler
[i
];
676 return ureg
->sampler
[0];
680 * Allocate a new shader sampler view.
683 ureg_DECL_sampler_view(struct ureg_program
*ureg
,
686 unsigned return_type_x
,
687 unsigned return_type_y
,
688 unsigned return_type_z
,
689 unsigned return_type_w
)
691 struct ureg_src reg
= ureg_src_register(TGSI_FILE_SAMPLER_VIEW
, index
);
694 for (i
= 0; i
< ureg
->nr_sampler_views
; i
++) {
695 if (ureg
->sampler_view
[i
].index
== index
) {
700 if (i
< PIPE_MAX_SHADER_SAMPLER_VIEWS
) {
701 ureg
->sampler_view
[i
].index
= index
;
702 ureg
->sampler_view
[i
].target
= target
;
703 ureg
->sampler_view
[i
].return_type_x
= return_type_x
;
704 ureg
->sampler_view
[i
].return_type_y
= return_type_y
;
705 ureg
->sampler_view
[i
].return_type_z
= return_type_z
;
706 ureg
->sampler_view
[i
].return_type_w
= return_type_w
;
707 ureg
->nr_sampler_views
++;
716 match_or_expand_immediate( const unsigned *v
,
722 unsigned nr2
= *pnr2
;
727 for (i
= 0; i
< nr
; i
++) {
728 boolean found
= FALSE
;
730 for (j
= 0; j
< nr2
&& !found
; j
++) {
732 *swizzle
|= j
<< (i
* 2);
743 *swizzle
|= nr2
<< (i
* 2);
748 /* Actually expand immediate only when fully succeeded.
755 static struct ureg_src
756 decl_immediate( struct ureg_program
*ureg
,
762 unsigned swizzle
= 0;
764 /* Could do a first pass where we examine all existing immediates
768 for (i
= 0; i
< ureg
->nr_immediates
; i
++) {
769 if (ureg
->immediate
[i
].type
!= type
) {
772 if (match_or_expand_immediate(v
,
774 ureg
->immediate
[i
].value
.u
,
775 &ureg
->immediate
[i
].nr
,
781 if (ureg
->nr_immediates
< UREG_MAX_IMMEDIATE
) {
782 i
= ureg
->nr_immediates
++;
783 ureg
->immediate
[i
].type
= type
;
784 if (match_or_expand_immediate(v
,
786 ureg
->immediate
[i
].value
.u
,
787 &ureg
->immediate
[i
].nr
,
796 /* Make sure that all referenced elements are from this immediate.
797 * Has the effect of making size-one immediates into scalars.
799 for (j
= nr
; j
< 4; j
++) {
800 swizzle
|= (swizzle
& 0x3) << (j
* 2);
803 return ureg_swizzle(ureg_src_register(TGSI_FILE_IMMEDIATE
, i
),
804 (swizzle
>> 0) & 0x3,
805 (swizzle
>> 2) & 0x3,
806 (swizzle
>> 4) & 0x3,
807 (swizzle
>> 6) & 0x3);
812 ureg_DECL_immediate( struct ureg_program
*ureg
,
822 for (i
= 0; i
< nr
; i
++) {
826 return decl_immediate(ureg
, fu
.u
, nr
, TGSI_IMM_FLOAT32
);
831 ureg_DECL_immediate_uint( struct ureg_program
*ureg
,
835 return decl_immediate(ureg
, v
, nr
, TGSI_IMM_UINT32
);
840 ureg_DECL_immediate_block_uint( struct ureg_program
*ureg
,
847 if (ureg
->nr_immediates
+ (nr
+ 3) / 4 > UREG_MAX_IMMEDIATE
) {
849 return ureg_src_register(TGSI_FILE_IMMEDIATE
, 0);
852 index
= ureg
->nr_immediates
;
853 ureg
->nr_immediates
+= (nr
+ 3) / 4;
855 for (i
= index
; i
< ureg
->nr_immediates
; i
++) {
856 ureg
->immediate
[i
].type
= TGSI_IMM_UINT32
;
857 ureg
->immediate
[i
].nr
= nr
> 4 ? 4 : nr
;
858 memcpy(ureg
->immediate
[i
].value
.u
,
860 ureg
->immediate
[i
].nr
* sizeof(uint
));
864 return ureg_src_register(TGSI_FILE_IMMEDIATE
, index
);
869 ureg_DECL_immediate_int( struct ureg_program
*ureg
,
873 return decl_immediate(ureg
, (const unsigned *)v
, nr
, TGSI_IMM_INT32
);
878 ureg_emit_src( struct ureg_program
*ureg
,
879 struct ureg_src src
)
881 unsigned size
= 1 + (src
.Indirect
? 1 : 0) +
882 (src
.Dimension
? (src
.DimIndirect
? 2 : 1) : 0);
884 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_INSN
, size
);
887 assert(src
.File
!= TGSI_FILE_NULL
);
888 assert(src
.File
< TGSI_FILE_COUNT
);
891 out
[n
].src
.File
= src
.File
;
892 out
[n
].src
.SwizzleX
= src
.SwizzleX
;
893 out
[n
].src
.SwizzleY
= src
.SwizzleY
;
894 out
[n
].src
.SwizzleZ
= src
.SwizzleZ
;
895 out
[n
].src
.SwizzleW
= src
.SwizzleW
;
896 out
[n
].src
.Index
= src
.Index
;
897 out
[n
].src
.Negate
= src
.Negate
;
898 out
[0].src
.Absolute
= src
.Absolute
;
902 out
[0].src
.Indirect
= 1;
904 out
[n
].ind
.File
= src
.IndirectFile
;
905 out
[n
].ind
.Swizzle
= src
.IndirectSwizzle
;
906 out
[n
].ind
.Index
= src
.IndirectIndex
;
907 out
[n
].ind
.ArrayID
= src
.ArrayID
;
912 out
[0].src
.Dimension
= 1;
913 out
[n
].dim
.Dimension
= 0;
914 out
[n
].dim
.Padding
= 0;
915 if (src
.DimIndirect
) {
916 out
[n
].dim
.Indirect
= 1;
917 out
[n
].dim
.Index
= src
.DimensionIndex
;
920 out
[n
].ind
.File
= src
.DimIndFile
;
921 out
[n
].ind
.Swizzle
= src
.DimIndSwizzle
;
922 out
[n
].ind
.Index
= src
.DimIndIndex
;
923 out
[n
].ind
.ArrayID
= src
.ArrayID
;
925 out
[n
].dim
.Indirect
= 0;
926 out
[n
].dim
.Index
= src
.DimensionIndex
;
936 ureg_emit_dst( struct ureg_program
*ureg
,
937 struct ureg_dst dst
)
940 (dst
.Indirect
? 1 : 0));
942 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_INSN
, size
);
945 assert(dst
.File
!= TGSI_FILE_NULL
);
946 assert(dst
.File
!= TGSI_FILE_CONSTANT
);
947 assert(dst
.File
!= TGSI_FILE_INPUT
);
948 assert(dst
.File
!= TGSI_FILE_SAMPLER
);
949 assert(dst
.File
!= TGSI_FILE_SAMPLER_VIEW
);
950 assert(dst
.File
!= TGSI_FILE_IMMEDIATE
);
951 assert(dst
.File
< TGSI_FILE_COUNT
);
954 out
[n
].dst
.File
= dst
.File
;
955 out
[n
].dst
.WriteMask
= dst
.WriteMask
;
956 out
[n
].dst
.Indirect
= dst
.Indirect
;
957 out
[n
].dst
.Index
= dst
.Index
;
962 out
[n
].ind
.File
= dst
.IndirectFile
;
963 out
[n
].ind
.Swizzle
= dst
.IndirectSwizzle
;
964 out
[n
].ind
.Index
= dst
.IndirectIndex
;
965 out
[n
].ind
.ArrayID
= dst
.ArrayID
;
973 static void validate( unsigned opcode
,
978 const struct tgsi_opcode_info
*info
= tgsi_get_opcode_info( opcode
);
981 assert(nr_dst
== info
->num_dst
);
982 assert(nr_src
== info
->num_src
);
987 struct ureg_emit_insn_result
988 ureg_emit_insn(struct ureg_program
*ureg
,
993 unsigned pred_swizzle_x
,
994 unsigned pred_swizzle_y
,
995 unsigned pred_swizzle_z
,
996 unsigned pred_swizzle_w
,
1000 union tgsi_any_token
*out
;
1001 uint count
= predicate
? 2 : 1;
1002 struct ureg_emit_insn_result result
;
1004 validate( opcode
, num_dst
, num_src
);
1006 out
= get_tokens( ureg
, DOMAIN_INSN
, count
);
1007 out
[0].insn
= tgsi_default_instruction();
1008 out
[0].insn
.Opcode
= opcode
;
1009 out
[0].insn
.Saturate
= saturate
;
1010 out
[0].insn
.NumDstRegs
= num_dst
;
1011 out
[0].insn
.NumSrcRegs
= num_src
;
1013 result
.insn_token
= ureg
->domain
[DOMAIN_INSN
].count
- count
;
1014 result
.extended_token
= result
.insn_token
;
1017 out
[0].insn
.Predicate
= 1;
1018 out
[1].insn_predicate
= tgsi_default_instruction_predicate();
1019 out
[1].insn_predicate
.Negate
= pred_negate
;
1020 out
[1].insn_predicate
.SwizzleX
= pred_swizzle_x
;
1021 out
[1].insn_predicate
.SwizzleY
= pred_swizzle_y
;
1022 out
[1].insn_predicate
.SwizzleZ
= pred_swizzle_z
;
1023 out
[1].insn_predicate
.SwizzleW
= pred_swizzle_w
;
1026 ureg
->nr_instructions
++;
1033 ureg_emit_label(struct ureg_program
*ureg
,
1034 unsigned extended_token
,
1035 unsigned *label_token
)
1037 union tgsi_any_token
*out
, *insn
;
1042 out
= get_tokens( ureg
, DOMAIN_INSN
, 1 );
1045 insn
= retrieve_token( ureg
, DOMAIN_INSN
, extended_token
);
1046 insn
->insn
.Label
= 1;
1048 *label_token
= ureg
->domain
[DOMAIN_INSN
].count
- 1;
1051 /* Will return a number which can be used in a label to point to the
1052 * next instruction to be emitted.
1055 ureg_get_instruction_number( struct ureg_program
*ureg
)
1057 return ureg
->nr_instructions
;
1060 /* Patch a given label (expressed as a token number) to point to a
1061 * given instruction (expressed as an instruction number).
1064 ureg_fixup_label(struct ureg_program
*ureg
,
1065 unsigned label_token
,
1066 unsigned instruction_number
)
1068 union tgsi_any_token
*out
= retrieve_token( ureg
, DOMAIN_INSN
, label_token
);
1070 out
->insn_label
.Label
= instruction_number
;
1075 ureg_emit_texture(struct ureg_program
*ureg
,
1076 unsigned extended_token
,
1077 unsigned target
, unsigned num_offsets
)
1079 union tgsi_any_token
*out
, *insn
;
1081 out
= get_tokens( ureg
, DOMAIN_INSN
, 1 );
1082 insn
= retrieve_token( ureg
, DOMAIN_INSN
, extended_token
);
1084 insn
->insn
.Texture
= 1;
1087 out
[0].insn_texture
.Texture
= target
;
1088 out
[0].insn_texture
.NumOffsets
= num_offsets
;
1092 ureg_emit_texture_offset(struct ureg_program
*ureg
,
1093 const struct tgsi_texture_offset
*offset
)
1095 union tgsi_any_token
*out
;
1097 out
= get_tokens( ureg
, DOMAIN_INSN
, 1);
1100 out
[0].insn_texture_offset
= *offset
;
1106 ureg_fixup_insn_size(struct ureg_program
*ureg
,
1109 union tgsi_any_token
*out
= retrieve_token( ureg
, DOMAIN_INSN
, insn
);
1111 assert(out
->insn
.Type
== TGSI_TOKEN_TYPE_INSTRUCTION
);
1112 out
->insn
.NrTokens
= ureg
->domain
[DOMAIN_INSN
].count
- insn
- 1;
1117 ureg_insn(struct ureg_program
*ureg
,
1119 const struct ureg_dst
*dst
,
1121 const struct ureg_src
*src
,
1124 struct ureg_emit_insn_result insn
;
1128 boolean negate
= FALSE
;
1129 unsigned swizzle
[4] = { 0 };
1131 if (nr_dst
&& ureg_dst_is_empty(dst
[0])) {
1135 saturate
= nr_dst
? dst
[0].Saturate
: FALSE
;
1136 predicate
= nr_dst
? dst
[0].Predicate
: FALSE
;
1138 negate
= dst
[0].PredNegate
;
1139 swizzle
[0] = dst
[0].PredSwizzleX
;
1140 swizzle
[1] = dst
[0].PredSwizzleY
;
1141 swizzle
[2] = dst
[0].PredSwizzleZ
;
1142 swizzle
[3] = dst
[0].PredSwizzleW
;
1145 insn
= ureg_emit_insn(ureg
,
1157 for (i
= 0; i
< nr_dst
; i
++)
1158 ureg_emit_dst( ureg
, dst
[i
] );
1160 for (i
= 0; i
< nr_src
; i
++)
1161 ureg_emit_src( ureg
, src
[i
] );
1163 ureg_fixup_insn_size( ureg
, insn
.insn_token
);
1167 ureg_tex_insn(struct ureg_program
*ureg
,
1169 const struct ureg_dst
*dst
,
1172 const struct tgsi_texture_offset
*texoffsets
,
1174 const struct ureg_src
*src
,
1177 struct ureg_emit_insn_result insn
;
1181 boolean negate
= FALSE
;
1182 unsigned swizzle
[4] = { 0 };
1184 if (nr_dst
&& ureg_dst_is_empty(dst
[0])) {
1188 saturate
= nr_dst
? dst
[0].Saturate
: FALSE
;
1189 predicate
= nr_dst
? dst
[0].Predicate
: FALSE
;
1191 negate
= dst
[0].PredNegate
;
1192 swizzle
[0] = dst
[0].PredSwizzleX
;
1193 swizzle
[1] = dst
[0].PredSwizzleY
;
1194 swizzle
[2] = dst
[0].PredSwizzleZ
;
1195 swizzle
[3] = dst
[0].PredSwizzleW
;
1198 insn
= ureg_emit_insn(ureg
,
1210 ureg_emit_texture( ureg
, insn
.extended_token
, target
, nr_offset
);
1212 for (i
= 0; i
< nr_offset
; i
++)
1213 ureg_emit_texture_offset( ureg
, &texoffsets
[i
]);
1215 for (i
= 0; i
< nr_dst
; i
++)
1216 ureg_emit_dst( ureg
, dst
[i
] );
1218 for (i
= 0; i
< nr_src
; i
++)
1219 ureg_emit_src( ureg
, src
[i
] );
1221 ureg_fixup_insn_size( ureg
, insn
.insn_token
);
1226 ureg_label_insn(struct ureg_program
*ureg
,
1228 const struct ureg_src
*src
,
1230 unsigned *label_token
)
1232 struct ureg_emit_insn_result insn
;
1235 insn
= ureg_emit_insn(ureg
,
1247 ureg_emit_label( ureg
, insn
.extended_token
, label_token
);
1249 for (i
= 0; i
< nr_src
; i
++)
1250 ureg_emit_src( ureg
, src
[i
] );
1252 ureg_fixup_insn_size( ureg
, insn
.insn_token
);
1257 emit_decl_semantic(struct ureg_program
*ureg
,
1260 unsigned semantic_name
,
1261 unsigned semantic_index
,
1262 unsigned usage_mask
)
1264 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 3);
1267 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1268 out
[0].decl
.NrTokens
= 3;
1269 out
[0].decl
.File
= file
;
1270 out
[0].decl
.UsageMask
= usage_mask
;
1271 out
[0].decl
.Semantic
= 1;
1274 out
[1].decl_range
.First
= index
;
1275 out
[1].decl_range
.Last
= index
;
1278 out
[2].decl_semantic
.Name
= semantic_name
;
1279 out
[2].decl_semantic
.Index
= semantic_index
;
1284 emit_decl_fs(struct ureg_program
*ureg
,
1287 unsigned semantic_name
,
1288 unsigned semantic_index
,
1289 unsigned interpolate
,
1290 unsigned cylindrical_wrap
,
1293 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 4);
1296 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1297 out
[0].decl
.NrTokens
= 4;
1298 out
[0].decl
.File
= file
;
1299 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
; /* FIXME! */
1300 out
[0].decl
.Interpolate
= 1;
1301 out
[0].decl
.Semantic
= 1;
1304 out
[1].decl_range
.First
= index
;
1305 out
[1].decl_range
.Last
= index
;
1308 out
[2].decl_interp
.Interpolate
= interpolate
;
1309 out
[2].decl_interp
.CylindricalWrap
= cylindrical_wrap
;
1310 out
[2].decl_interp
.Centroid
= centroid
;
1313 out
[3].decl_semantic
.Name
= semantic_name
;
1314 out
[3].decl_semantic
.Index
= semantic_index
;
1318 emit_decl_temps( struct ureg_program
*ureg
,
1319 unsigned first
, unsigned last
,
1323 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
,
1327 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1328 out
[0].decl
.NrTokens
= 2;
1329 out
[0].decl
.File
= TGSI_FILE_TEMPORARY
;
1330 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1331 out
[0].decl
.Local
= local
;
1334 out
[1].decl_range
.First
= first
;
1335 out
[1].decl_range
.Last
= last
;
1338 out
[0].decl
.Array
= 1;
1340 out
[2].array
.ArrayID
= arrayid
;
1344 static void emit_decl_range( struct ureg_program
*ureg
,
1349 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 2 );
1352 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1353 out
[0].decl
.NrTokens
= 2;
1354 out
[0].decl
.File
= file
;
1355 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1356 out
[0].decl
.Semantic
= 0;
1359 out
[1].decl_range
.First
= first
;
1360 out
[1].decl_range
.Last
= first
+ count
- 1;
1364 emit_decl_range2D(struct ureg_program
*ureg
,
1370 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 3);
1373 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1374 out
[0].decl
.NrTokens
= 3;
1375 out
[0].decl
.File
= file
;
1376 out
[0].decl
.UsageMask
= TGSI_WRITEMASK_XYZW
;
1377 out
[0].decl
.Dimension
= 1;
1380 out
[1].decl_range
.First
= first
;
1381 out
[1].decl_range
.Last
= last
;
1384 out
[2].decl_dim
.Index2D
= index2D
;
1388 emit_decl_sampler_view(struct ureg_program
*ureg
,
1391 unsigned return_type_x
,
1392 unsigned return_type_y
,
1393 unsigned return_type_z
,
1394 unsigned return_type_w
)
1396 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 3);
1399 out
[0].decl
.Type
= TGSI_TOKEN_TYPE_DECLARATION
;
1400 out
[0].decl
.NrTokens
= 3;
1401 out
[0].decl
.File
= TGSI_FILE_SAMPLER_VIEW
;
1402 out
[0].decl
.UsageMask
= 0xf;
1405 out
[1].decl_range
.First
= index
;
1406 out
[1].decl_range
.Last
= index
;
1409 out
[2].decl_sampler_view
.Resource
= target
;
1410 out
[2].decl_sampler_view
.ReturnTypeX
= return_type_x
;
1411 out
[2].decl_sampler_view
.ReturnTypeY
= return_type_y
;
1412 out
[2].decl_sampler_view
.ReturnTypeZ
= return_type_z
;
1413 out
[2].decl_sampler_view
.ReturnTypeW
= return_type_w
;
1417 emit_immediate( struct ureg_program
*ureg
,
1421 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 5 );
1424 out
[0].imm
.Type
= TGSI_TOKEN_TYPE_IMMEDIATE
;
1425 out
[0].imm
.NrTokens
= 5;
1426 out
[0].imm
.DataType
= type
;
1427 out
[0].imm
.Padding
= 0;
1429 out
[1].imm_data
.Uint
= v
[0];
1430 out
[2].imm_data
.Uint
= v
[1];
1431 out
[3].imm_data
.Uint
= v
[2];
1432 out
[4].imm_data
.Uint
= v
[3];
1436 emit_property(struct ureg_program
*ureg
,
1440 union tgsi_any_token
*out
= get_tokens(ureg
, DOMAIN_DECL
, 2);
1443 out
[0].prop
.Type
= TGSI_TOKEN_TYPE_PROPERTY
;
1444 out
[0].prop
.NrTokens
= 2;
1445 out
[0].prop
.PropertyName
= name
;
1447 out
[1].prop_data
.Data
= data
;
1451 static void emit_decls( struct ureg_program
*ureg
)
1455 if (ureg
->property_gs_input_prim
!= ~0) {
1456 assert(ureg
->processor
== TGSI_PROCESSOR_GEOMETRY
);
1459 TGSI_PROPERTY_GS_INPUT_PRIM
,
1460 ureg
->property_gs_input_prim
);
1463 if (ureg
->property_gs_output_prim
!= ~0) {
1464 assert(ureg
->processor
== TGSI_PROCESSOR_GEOMETRY
);
1467 TGSI_PROPERTY_GS_OUTPUT_PRIM
,
1468 ureg
->property_gs_output_prim
);
1471 if (ureg
->property_gs_max_vertices
!= ~0) {
1472 assert(ureg
->processor
== TGSI_PROCESSOR_GEOMETRY
);
1475 TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES
,
1476 ureg
->property_gs_max_vertices
);
1479 if (ureg
->property_gs_invocations
!= ~0) {
1480 assert(ureg
->processor
== TGSI_PROCESSOR_GEOMETRY
);
1483 TGSI_PROPERTY_GS_INVOCATIONS
,
1484 ureg
->property_gs_invocations
);
1487 if (ureg
->property_fs_coord_origin
) {
1488 assert(ureg
->processor
== TGSI_PROCESSOR_FRAGMENT
);
1491 TGSI_PROPERTY_FS_COORD_ORIGIN
,
1492 ureg
->property_fs_coord_origin
);
1495 if (ureg
->property_fs_coord_pixel_center
) {
1496 assert(ureg
->processor
== TGSI_PROCESSOR_FRAGMENT
);
1499 TGSI_PROPERTY_FS_COORD_PIXEL_CENTER
,
1500 ureg
->property_fs_coord_pixel_center
);
1503 if (ureg
->property_fs_color0_writes_all_cbufs
) {
1504 assert(ureg
->processor
== TGSI_PROCESSOR_FRAGMENT
);
1507 TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS
,
1508 ureg
->property_fs_color0_writes_all_cbufs
);
1511 if (ureg
->property_fs_depth_layout
) {
1512 assert(ureg
->processor
== TGSI_PROCESSOR_FRAGMENT
);
1515 TGSI_PROPERTY_FS_DEPTH_LAYOUT
,
1516 ureg
->property_fs_depth_layout
);
1519 if (ureg
->property_vs_window_space_position
) {
1520 assert(ureg
->processor
== TGSI_PROCESSOR_VERTEX
);
1523 TGSI_PROPERTY_VS_WINDOW_SPACE_POSITION
,
1524 ureg
->property_vs_window_space_position
);
1527 if (ureg
->processor
== TGSI_PROCESSOR_VERTEX
) {
1528 for (i
= 0; i
< UREG_MAX_INPUT
; i
++) {
1529 if (ureg
->vs_inputs
[i
/32] & (1 << (i
%32))) {
1530 emit_decl_range( ureg
, TGSI_FILE_INPUT
, i
, 1 );
1533 } else if (ureg
->processor
== TGSI_PROCESSOR_FRAGMENT
) {
1534 for (i
= 0; i
< ureg
->nr_fs_inputs
; i
++) {
1538 ureg
->fs_input
[i
].semantic_name
,
1539 ureg
->fs_input
[i
].semantic_index
,
1540 ureg
->fs_input
[i
].interp
,
1541 ureg
->fs_input
[i
].cylindrical_wrap
,
1542 ureg
->fs_input
[i
].centroid
);
1545 for (i
= 0; i
< ureg
->nr_gs_inputs
; i
++) {
1546 emit_decl_semantic(ureg
,
1548 ureg
->gs_input
[i
].index
,
1549 ureg
->gs_input
[i
].semantic_name
,
1550 ureg
->gs_input
[i
].semantic_index
,
1551 TGSI_WRITEMASK_XYZW
);
1555 for (i
= 0; i
< ureg
->nr_system_values
; i
++) {
1556 emit_decl_semantic(ureg
,
1557 TGSI_FILE_SYSTEM_VALUE
,
1558 ureg
->system_value
[i
].index
,
1559 ureg
->system_value
[i
].semantic_name
,
1560 ureg
->system_value
[i
].semantic_index
,
1561 TGSI_WRITEMASK_XYZW
);
1564 for (i
= 0; i
< ureg
->nr_outputs
; i
++) {
1565 emit_decl_semantic(ureg
,
1568 ureg
->output
[i
].semantic_name
,
1569 ureg
->output
[i
].semantic_index
,
1570 ureg
->output
[i
].usage_mask
);
1573 for (i
= 0; i
< ureg
->nr_samplers
; i
++) {
1574 emit_decl_range( ureg
,
1576 ureg
->sampler
[i
].Index
, 1 );
1579 for (i
= 0; i
< ureg
->nr_sampler_views
; i
++) {
1580 emit_decl_sampler_view(ureg
,
1581 ureg
->sampler_view
[i
].index
,
1582 ureg
->sampler_view
[i
].target
,
1583 ureg
->sampler_view
[i
].return_type_x
,
1584 ureg
->sampler_view
[i
].return_type_y
,
1585 ureg
->sampler_view
[i
].return_type_z
,
1586 ureg
->sampler_view
[i
].return_type_w
);
1589 if (ureg
->const_decls
.nr_constant_ranges
) {
1590 for (i
= 0; i
< ureg
->const_decls
.nr_constant_ranges
; i
++) {
1591 emit_decl_range(ureg
,
1593 ureg
->const_decls
.constant_range
[i
].first
,
1594 ureg
->const_decls
.constant_range
[i
].last
- ureg
->const_decls
.constant_range
[i
].first
+ 1);
1598 for (i
= 0; i
< PIPE_MAX_CONSTANT_BUFFERS
; i
++) {
1599 struct const_decl
*decl
= &ureg
->const_decls2D
[i
];
1601 if (decl
->nr_constant_ranges
) {
1604 for (j
= 0; j
< decl
->nr_constant_ranges
; j
++) {
1605 emit_decl_range2D(ureg
,
1607 decl
->constant_range
[j
].first
,
1608 decl
->constant_range
[j
].last
,
1614 if (ureg
->nr_temps
) {
1616 for (i
= 0; i
< ureg
->nr_temps
;) {
1617 boolean local
= util_bitmask_get(ureg
->local_temps
, i
);
1619 i
= util_bitmask_get_next_index(ureg
->decl_temps
, i
+ 1);
1620 if (i
== UTIL_BITMASK_INVALID_INDEX
)
1623 if (array
< ureg
->nr_array_temps
&& ureg
->array_temps
[array
] == first
)
1624 emit_decl_temps( ureg
, first
, i
- 1, local
, ++array
);
1626 emit_decl_temps( ureg
, first
, i
- 1, local
, 0 );
1630 if (ureg
->nr_addrs
) {
1631 emit_decl_range( ureg
,
1633 0, ureg
->nr_addrs
);
1636 if (ureg
->nr_preds
) {
1637 emit_decl_range(ureg
,
1638 TGSI_FILE_PREDICATE
,
1643 for (i
= 0; i
< ureg
->nr_immediates
; i
++) {
1644 emit_immediate( ureg
,
1645 ureg
->immediate
[i
].value
.u
,
1646 ureg
->immediate
[i
].type
);
1650 /* Append the instruction tokens onto the declarations to build a
1651 * contiguous stream suitable to send to the driver.
1653 static void copy_instructions( struct ureg_program
*ureg
)
1655 unsigned nr_tokens
= ureg
->domain
[DOMAIN_INSN
].count
;
1656 union tgsi_any_token
*out
= get_tokens( ureg
,
1661 ureg
->domain
[DOMAIN_INSN
].tokens
,
1662 nr_tokens
* sizeof out
[0] );
1667 fixup_header_size(struct ureg_program
*ureg
)
1669 union tgsi_any_token
*out
= retrieve_token( ureg
, DOMAIN_DECL
, 0 );
1671 out
->header
.BodySize
= ureg
->domain
[DOMAIN_DECL
].count
- 2;
1676 emit_header( struct ureg_program
*ureg
)
1678 union tgsi_any_token
*out
= get_tokens( ureg
, DOMAIN_DECL
, 2 );
1680 out
[0].header
.HeaderSize
= 2;
1681 out
[0].header
.BodySize
= 0;
1683 out
[1].processor
.Processor
= ureg
->processor
;
1684 out
[1].processor
.Padding
= 0;
1688 const struct tgsi_token
*ureg_finalize( struct ureg_program
*ureg
)
1690 const struct tgsi_token
*tokens
;
1692 emit_header( ureg
);
1694 copy_instructions( ureg
);
1695 fixup_header_size( ureg
);
1697 if (ureg
->domain
[0].tokens
== error_tokens
||
1698 ureg
->domain
[1].tokens
== error_tokens
) {
1699 debug_printf("%s: error in generated shader\n", __FUNCTION__
);
1704 tokens
= &ureg
->domain
[DOMAIN_DECL
].tokens
[0].token
;
1707 debug_printf("%s: emitted shader %d tokens:\n", __FUNCTION__
,
1708 ureg
->domain
[DOMAIN_DECL
].count
);
1709 tgsi_dump( tokens
, 0 );
1713 if (tokens
&& !tgsi_sanity_check(tokens
)) {
1714 debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n");
1715 tgsi_dump(tokens
, 0);
1725 void *ureg_create_shader( struct ureg_program
*ureg
,
1726 struct pipe_context
*pipe
,
1727 const struct pipe_stream_output_info
*so
)
1729 struct pipe_shader_state state
;
1731 state
.tokens
= ureg_finalize(ureg
);
1736 state
.stream_output
= *so
;
1738 memset(&state
.stream_output
, 0, sizeof(state
.stream_output
));
1740 if (ureg
->processor
== TGSI_PROCESSOR_VERTEX
)
1741 return pipe
->create_vs_state( pipe
, &state
);
1743 return pipe
->create_fs_state( pipe
, &state
);
1747 const struct tgsi_token
*ureg_get_tokens( struct ureg_program
*ureg
,
1748 unsigned *nr_tokens
)
1750 const struct tgsi_token
*tokens
;
1752 ureg_finalize(ureg
);
1754 tokens
= &ureg
->domain
[DOMAIN_DECL
].tokens
[0].token
;
1757 *nr_tokens
= ureg
->domain
[DOMAIN_DECL
].size
;
1759 ureg
->domain
[DOMAIN_DECL
].tokens
= 0;
1760 ureg
->domain
[DOMAIN_DECL
].size
= 0;
1761 ureg
->domain
[DOMAIN_DECL
].order
= 0;
1762 ureg
->domain
[DOMAIN_DECL
].count
= 0;
1768 void ureg_free_tokens( const struct tgsi_token
*tokens
)
1770 FREE((struct tgsi_token
*)tokens
);
1774 struct ureg_program
*ureg_create( unsigned processor
)
1776 struct ureg_program
*ureg
= CALLOC_STRUCT( ureg_program
);
1780 ureg
->processor
= processor
;
1781 ureg
->property_gs_input_prim
= ~0;
1782 ureg
->property_gs_output_prim
= ~0;
1783 ureg
->property_gs_max_vertices
= ~0;
1784 ureg
->property_gs_invocations
= ~0;
1786 ureg
->free_temps
= util_bitmask_create();
1787 if (ureg
->free_temps
== NULL
)
1790 ureg
->local_temps
= util_bitmask_create();
1791 if (ureg
->local_temps
== NULL
)
1792 goto no_local_temps
;
1794 ureg
->decl_temps
= util_bitmask_create();
1795 if (ureg
->decl_temps
== NULL
)
1801 util_bitmask_destroy(ureg
->local_temps
);
1803 util_bitmask_destroy(ureg
->free_temps
);
1812 ureg_get_nr_outputs( const struct ureg_program
*ureg
)
1816 return ureg
->nr_outputs
;
1820 void ureg_destroy( struct ureg_program
*ureg
)
1824 for (i
= 0; i
< Elements(ureg
->domain
); i
++) {
1825 if (ureg
->domain
[i
].tokens
&&
1826 ureg
->domain
[i
].tokens
!= error_tokens
)
1827 FREE(ureg
->domain
[i
].tokens
);
1830 util_bitmask_destroy(ureg
->free_temps
);
1831 util_bitmask_destroy(ureg
->local_temps
);
1832 util_bitmask_destroy(ureg
->decl_temps
);