projects / mesa.git / blob
? search:


9eb00d09194f602747400bcfd504000c0b9c77a2
[mesa.git] / src / gallium / auxiliary / tgsi / tgsi_ureg.c
1 /**************************************************************************
2 *
3 * Copyright 2009-2010 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL 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.
25 *
26 **************************************************************************/
27
28
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"
42
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_label insn_label;
61 struct tgsi_instruction_texture insn_texture;
62 struct tgsi_instruction_memory insn_memory;
63 struct tgsi_texture_offset insn_texture_offset;
64 struct tgsi_src_register src;
65 struct tgsi_ind_register ind;
66 struct tgsi_dimension dim;
67 struct tgsi_dst_register dst;
68 unsigned value;
69 };
70
71
72 struct ureg_tokens {
73 union tgsi_any_token *tokens;
74 unsigned size;
75 unsigned order;
76 unsigned count;
77 };
78
79 #define UREG_MAX_INPUT (4 * PIPE_MAX_SHADER_INPUTS)
80 #define UREG_MAX_SYSTEM_VALUE PIPE_MAX_ATTRIBS
81 #define UREG_MAX_OUTPUT (4 * PIPE_MAX_SHADER_OUTPUTS)
82 #define UREG_MAX_CONSTANT_RANGE 32
83 #define UREG_MAX_IMMEDIATE 4096
84 #define UREG_MAX_ADDR 3
85 #define UREG_MAX_ARRAY_TEMPS 256
86
87 struct const_decl {
88 struct {
89 unsigned first;
90 unsigned last;
91 } constant_range[UREG_MAX_CONSTANT_RANGE];
92 unsigned nr_constant_ranges;
93 };
94
95 #define DOMAIN_DECL 0
96 #define DOMAIN_INSN 1
97
98 struct ureg_program
99 {
100 unsigned processor;
101 bool supports_any_inout_decl_range;
102 int next_shader_processor;
103
104 struct {
105 unsigned semantic_name;
106 unsigned semantic_index;
107 unsigned interp;
108 unsigned char cylindrical_wrap;
109 unsigned char usage_mask;
110 unsigned interp_location;
111 unsigned first;
112 unsigned last;
113 unsigned array_id;
114 } input[UREG_MAX_INPUT];
115 unsigned nr_inputs, nr_input_regs;
116
117 unsigned vs_inputs[PIPE_MAX_ATTRIBS/32];
118
119 struct {
120 unsigned semantic_name;
121 unsigned semantic_index;
122 } system_value[UREG_MAX_SYSTEM_VALUE];
123 unsigned nr_system_values;
124
125 struct {
126 unsigned semantic_name;
127 unsigned semantic_index;
128 unsigned streams;
129 unsigned usage_mask; /* = TGSI_WRITEMASK_* */
130 unsigned first;
131 unsigned last;
132 unsigned array_id;
133 } output[UREG_MAX_OUTPUT];
134 unsigned nr_outputs, nr_output_regs;
135
136 struct {
137 union {
138 float f[4];
139 unsigned u[4];
140 int i[4];
141 } value;
142 unsigned nr;
143 unsigned type;
144 } immediate[UREG_MAX_IMMEDIATE];
145 unsigned nr_immediates;
146
147 struct ureg_src sampler[PIPE_MAX_SAMPLERS];
148 unsigned nr_samplers;
149
150 struct {
151 unsigned index;
152 unsigned target;
153 unsigned return_type_x;
154 unsigned return_type_y;
155 unsigned return_type_z;
156 unsigned return_type_w;
157 } sampler_view[PIPE_MAX_SHADER_SAMPLER_VIEWS];
158 unsigned nr_sampler_views;
159
160 struct {
161 unsigned index;
162 unsigned target;
163 unsigned format;
164 boolean wr;
165 boolean raw;
166 } image[PIPE_MAX_SHADER_IMAGES];
167 unsigned nr_images;
168
169 struct {
170 unsigned index;
171 bool atomic;
172 } buffer[PIPE_MAX_SHADER_BUFFERS];
173 unsigned nr_buffers;
174
175 struct util_bitmask *free_temps;
176 struct util_bitmask *local_temps;
177 struct util_bitmask *decl_temps;
178 unsigned nr_temps;
179
180 unsigned array_temps[UREG_MAX_ARRAY_TEMPS];
181 unsigned nr_array_temps;
182
183 struct const_decl const_decls;
184 struct const_decl const_decls2D[PIPE_MAX_CONSTANT_BUFFERS];
185
186 unsigned properties[TGSI_PROPERTY_COUNT];
187
188 unsigned nr_addrs;
189 unsigned nr_instructions;
190
191 struct ureg_tokens domain[2];
192
193 bool use_memory[TGSI_MEMORY_TYPE_COUNT];
194 };
195
196 static union tgsi_any_token error_tokens[32];
197
198 static void tokens_error( struct ureg_tokens *tokens )
199 {
200 if (tokens->tokens && tokens->tokens != error_tokens)
201 FREE(tokens->tokens);
202
203 tokens->tokens = error_tokens;
204 tokens->size = ARRAY_SIZE(error_tokens);
205 tokens->count = 0;
206 }
207
208
209 static void tokens_expand( struct ureg_tokens *tokens,
210 unsigned count )
211 {
212 unsigned old_size = tokens->size * sizeof(unsigned);
213
214 if (tokens->tokens == error_tokens) {
215 return;
216 }
217
218 while (tokens->count + count > tokens->size) {
219 tokens->size = (1 << ++tokens->order);
220 }
221
222 tokens->tokens = REALLOC(tokens->tokens,
223 old_size,
224 tokens->size * sizeof(unsigned));
225 if (tokens->tokens == NULL) {
226 tokens_error(tokens);
227 }
228 }
229
230 static void set_bad( struct ureg_program *ureg )
231 {
232 tokens_error(&ureg->domain[0]);
233 }
234
235
236
237 static union tgsi_any_token *get_tokens( struct ureg_program *ureg,
238 unsigned domain,
239 unsigned count )
240 {
241 struct ureg_tokens *tokens = &ureg->domain[domain];
242 union tgsi_any_token *result;
243
244 if (tokens->count + count > tokens->size)
245 tokens_expand(tokens, count);
246
247 result = &tokens->tokens[tokens->count];
248 tokens->count += count;
249 return result;
250 }
251
252
253 static union tgsi_any_token *retrieve_token( struct ureg_program *ureg,
254 unsigned domain,
255 unsigned nr )
256 {
257 if (ureg->domain[domain].tokens == error_tokens)
258 return &error_tokens[0];
259
260 return &ureg->domain[domain].tokens[nr];
261 }
262
263
264 void
265 ureg_property(struct ureg_program *ureg, unsigned name, unsigned value)
266 {
267 assert(name < ARRAY_SIZE(ureg->properties));
268 ureg->properties[name] = value;
269 }
270
271 struct ureg_src
272 ureg_DECL_fs_input_cyl_centroid_layout(struct ureg_program *ureg,
273 unsigned semantic_name,
274 unsigned semantic_index,
275 unsigned interp_mode,
276 unsigned cylindrical_wrap,
277 unsigned interp_location,
278 unsigned index,
279 unsigned usage_mask,
280 unsigned array_id,
281 unsigned array_size)
282 {
283 unsigned i;
284
285 assert(usage_mask != 0);
286 assert(usage_mask <= TGSI_WRITEMASK_XYZW);
287
288 for (i = 0; i < ureg->nr_inputs; i++) {
289 if (ureg->input[i].semantic_name == semantic_name &&
290 ureg->input[i].semantic_index == semantic_index) {
291 assert(ureg->input[i].interp == interp_mode);
292 assert(ureg->input[i].cylindrical_wrap == cylindrical_wrap);
293 assert(ureg->input[i].interp_location == interp_location);
294 if (ureg->input[i].array_id == array_id) {
295 ureg->input[i].usage_mask |= usage_mask;
296 goto out;
297 }
298 assert((ureg->input[i].usage_mask & usage_mask) == 0);
299 }
300 }
301
302 if (ureg->nr_inputs < UREG_MAX_INPUT) {
303 assert(array_size >= 1);
304 ureg->input[i].semantic_name = semantic_name;
305 ureg->input[i].semantic_index = semantic_index;
306 ureg->input[i].interp = interp_mode;
307 ureg->input[i].cylindrical_wrap = cylindrical_wrap;
308 ureg->input[i].interp_location = interp_location;
309 ureg->input[i].first = index;
310 ureg->input[i].last = index + array_size - 1;
311 ureg->input[i].array_id = array_id;
312 ureg->input[i].usage_mask = usage_mask;
313 ureg->nr_input_regs = MAX2(ureg->nr_input_regs, index + array_size);
314 ureg->nr_inputs++;
315 } else {
316 set_bad(ureg);
317 }
318
319 out:
320 return ureg_src_array_register(TGSI_FILE_INPUT, ureg->input[i].first,
321 array_id);
322 }
323
324 struct ureg_src
325 ureg_DECL_fs_input_cyl_centroid(struct ureg_program *ureg,
326 unsigned semantic_name,
327 unsigned semantic_index,
328 unsigned interp_mode,
329 unsigned cylindrical_wrap,
330 unsigned interp_location,
331 unsigned array_id,
332 unsigned array_size)
333 {
334 return ureg_DECL_fs_input_cyl_centroid_layout(ureg,
335 semantic_name, semantic_index, interp_mode, cylindrical_wrap, interp_location,
336 ureg->nr_input_regs, TGSI_WRITEMASK_XYZW, array_id, array_size);
337 }
338
339
340 struct ureg_src
341 ureg_DECL_vs_input( struct ureg_program *ureg,
342 unsigned index )
343 {
344 assert(ureg->processor == PIPE_SHADER_VERTEX);
345 assert(index / 32 < ARRAY_SIZE(ureg->vs_inputs));
346
347 ureg->vs_inputs[index/32] |= 1 << (index % 32);
348 return ureg_src_register( TGSI_FILE_INPUT, index );
349 }
350
351
352 struct ureg_src
353 ureg_DECL_input_layout(struct ureg_program *ureg,
354 unsigned semantic_name,
355 unsigned semantic_index,
356 unsigned index,
357 unsigned usage_mask,
358 unsigned array_id,
359 unsigned array_size)
360 {
361 return ureg_DECL_fs_input_cyl_centroid_layout(ureg,
362 semantic_name, semantic_index, 0, 0, 0,
363 index, usage_mask, array_id, array_size);
364 }
365
366
367 struct ureg_src
368 ureg_DECL_input(struct ureg_program *ureg,
369 unsigned semantic_name,
370 unsigned semantic_index,
371 unsigned array_id,
372 unsigned array_size)
373 {
374 return ureg_DECL_fs_input_cyl_centroid(ureg, semantic_name, semantic_index,
375 0, 0, 0, array_id, array_size);
376 }
377
378
379 struct ureg_src
380 ureg_DECL_system_value(struct ureg_program *ureg,
381 unsigned semantic_name,
382 unsigned semantic_index)
383 {
384 unsigned i;
385
386 for (i = 0; i < ureg->nr_system_values; i++) {
387 if (ureg->system_value[i].semantic_name == semantic_name &&
388 ureg->system_value[i].semantic_index == semantic_index) {
389 goto out;
390 }
391 }
392
393 if (ureg->nr_system_values < UREG_MAX_SYSTEM_VALUE) {
394 ureg->system_value[ureg->nr_system_values].semantic_name = semantic_name;
395 ureg->system_value[ureg->nr_system_values].semantic_index = semantic_index;
396 i = ureg->nr_system_values;
397 ureg->nr_system_values++;
398 } else {
399 set_bad(ureg);
400 }
401
402 out:
403 return ureg_src_register(TGSI_FILE_SYSTEM_VALUE, i);
404 }
405
406
407 struct ureg_dst
408 ureg_DECL_output_layout(struct ureg_program *ureg,
409 unsigned semantic_name,
410 unsigned semantic_index,
411 unsigned streams,
412 unsigned index,
413 unsigned usage_mask,
414 unsigned array_id,
415 unsigned array_size)
416 {
417 unsigned i;
418
419 assert(usage_mask != 0);
420 assert(!(streams & 0x03) || (usage_mask & 1));
421 assert(!(streams & 0x0c) || (usage_mask & 2));
422 assert(!(streams & 0x30) || (usage_mask & 4));
423 assert(!(streams & 0xc0) || (usage_mask & 8));
424
425 for (i = 0; i < ureg->nr_outputs; i++) {
426 if (ureg->output[i].semantic_name == semantic_name &&
427 ureg->output[i].semantic_index == semantic_index) {
428 if (ureg->output[i].array_id == array_id) {
429 ureg->output[i].usage_mask |= usage_mask;
430 goto out;
431 }
432 assert((ureg->output[i].usage_mask & usage_mask) == 0);
433 }
434 }
435
436 if (ureg->nr_outputs < UREG_MAX_OUTPUT) {
437 ureg->output[i].semantic_name = semantic_name;
438 ureg->output[i].semantic_index = semantic_index;
439 ureg->output[i].usage_mask = usage_mask;
440 ureg->output[i].first = index;
441 ureg->output[i].last = index + array_size - 1;
442 ureg->output[i].array_id = array_id;
443 ureg->nr_output_regs = MAX2(ureg->nr_output_regs, index + array_size);
444 ureg->nr_outputs++;
445 }
446 else {
447 set_bad( ureg );
448 i = 0;
449 }
450
451 out:
452 ureg->output[i].streams |= streams;
453
454 return ureg_dst_array_register(TGSI_FILE_OUTPUT, ureg->output[i].first,
455 array_id);
456 }
457
458
459 struct ureg_dst
460 ureg_DECL_output_masked(struct ureg_program *ureg,
461 unsigned name,
462 unsigned index,
463 unsigned usage_mask,
464 unsigned array_id,
465 unsigned array_size)
466 {
467 return ureg_DECL_output_layout(ureg, name, index, 0,
468 ureg->nr_output_regs, usage_mask, array_id, array_size);
469 }
470
471
472 struct ureg_dst
473 ureg_DECL_output(struct ureg_program *ureg,
474 unsigned name,
475 unsigned index)
476 {
477 return ureg_DECL_output_masked(ureg, name, index, TGSI_WRITEMASK_XYZW,
478 0, 1);
479 }
480
481 struct ureg_dst
482 ureg_DECL_output_array(struct ureg_program *ureg,
483 unsigned semantic_name,
484 unsigned semantic_index,
485 unsigned array_id,
486 unsigned array_size)
487 {
488 return ureg_DECL_output_masked(ureg, semantic_name, semantic_index,
489 TGSI_WRITEMASK_XYZW,
490 array_id, array_size);
491 }
492
493
494 /* Returns a new constant register. Keep track of which have been
495 * referred to so that we can emit decls later.
496 *
497 * Constant operands declared with this function must be addressed
498 * with a two-dimensional index.
499 *
500 * There is nothing in this code to bind this constant to any tracked
501 * value or manage any constant_buffer contents -- that's the
502 * resposibility of the calling code.
503 */
504 void
505 ureg_DECL_constant2D(struct ureg_program *ureg,
506 unsigned first,
507 unsigned last,
508 unsigned index2D)
509 {
510 struct const_decl *decl = &ureg->const_decls2D[index2D];
511
512 assert(index2D < PIPE_MAX_CONSTANT_BUFFERS);
513
514 if (decl->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) {
515 uint i = decl->nr_constant_ranges++;
516
517 decl->constant_range[i].first = first;
518 decl->constant_range[i].last = last;
519 }
520 }
521
522
523 /* A one-dimensional, deprecated version of ureg_DECL_constant2D().
524 *
525 * Constant operands declared with this function must be addressed
526 * with a one-dimensional index.
527 */
528 struct ureg_src
529 ureg_DECL_constant(struct ureg_program *ureg,
530 unsigned index)
531 {
532 struct const_decl *decl = &ureg->const_decls;
533 unsigned minconst = index, maxconst = index;
534 unsigned i;
535
536 /* Inside existing range?
537 */
538 for (i = 0; i < decl->nr_constant_ranges; i++) {
539 if (decl->constant_range[i].first <= index &&
540 decl->constant_range[i].last >= index) {
541 goto out;
542 }
543 }
544
545 /* Extend existing range?
546 */
547 for (i = 0; i < decl->nr_constant_ranges; i++) {
548 if (decl->constant_range[i].last == index - 1) {
549 decl->constant_range[i].last = index;
550 goto out;
551 }
552
553 if (decl->constant_range[i].first == index + 1) {
554 decl->constant_range[i].first = index;
555 goto out;
556 }
557
558 minconst = MIN2(minconst, decl->constant_range[i].first);
559 maxconst = MAX2(maxconst, decl->constant_range[i].last);
560 }
561
562 /* Create new range?
563 */
564 if (decl->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) {
565 i = decl->nr_constant_ranges++;
566 decl->constant_range[i].first = index;
567 decl->constant_range[i].last = index;
568 goto out;
569 }
570
571 /* Collapse all ranges down to one:
572 */
573 i = 0;
574 decl->constant_range[0].first = minconst;
575 decl->constant_range[0].last = maxconst;
576 decl->nr_constant_ranges = 1;
577
578 out:
579 assert(i < decl->nr_constant_ranges);
580 assert(decl->constant_range[i].first <= index);
581 assert(decl->constant_range[i].last >= index);
582 return ureg_src_register(TGSI_FILE_CONSTANT, index);
583 }
584
585 static struct ureg_dst alloc_temporary( struct ureg_program *ureg,
586 boolean local )
587 {
588 unsigned i;
589
590 /* Look for a released temporary.
591 */
592 for (i = util_bitmask_get_first_index(ureg->free_temps);
593 i != UTIL_BITMASK_INVALID_INDEX;
594 i = util_bitmask_get_next_index(ureg->free_temps, i + 1)) {
595 if (util_bitmask_get(ureg->local_temps, i) == local)
596 break;
597 }
598
599 /* Or allocate a new one.
600 */
601 if (i == UTIL_BITMASK_INVALID_INDEX) {
602 i = ureg->nr_temps++;
603
604 if (local)
605 util_bitmask_set(ureg->local_temps, i);
606
607 /* Start a new declaration when the local flag changes */
608 if (!i || util_bitmask_get(ureg->local_temps, i - 1) != local)
609 util_bitmask_set(ureg->decl_temps, i);
610 }
611
612 util_bitmask_clear(ureg->free_temps, i);
613
614 return ureg_dst_register( TGSI_FILE_TEMPORARY, i );
615 }
616
617 struct ureg_dst ureg_DECL_temporary( struct ureg_program *ureg )
618 {
619 return alloc_temporary(ureg, FALSE);
620 }
621
622 struct ureg_dst ureg_DECL_local_temporary( struct ureg_program *ureg )
623 {
624 return alloc_temporary(ureg, TRUE);
625 }
626
627 struct ureg_dst ureg_DECL_array_temporary( struct ureg_program *ureg,
628 unsigned size,
629 boolean local )
630 {
631 unsigned i = ureg->nr_temps;
632 struct ureg_dst dst = ureg_dst_register( TGSI_FILE_TEMPORARY, i );
633
634 if (local)
635 util_bitmask_set(ureg->local_temps, i);
636
637 /* Always start a new declaration at the start */
638 util_bitmask_set(ureg->decl_temps, i);
639
640 ureg->nr_temps += size;
641
642 /* and also at the end of the array */
643 util_bitmask_set(ureg->decl_temps, ureg->nr_temps);
644
645 if (ureg->nr_array_temps < UREG_MAX_ARRAY_TEMPS) {
646 ureg->array_temps[ureg->nr_array_temps++] = i;
647 dst.ArrayID = ureg->nr_array_temps;
648 }
649
650 return dst;
651 }
652
653 void ureg_release_temporary( struct ureg_program *ureg,
654 struct ureg_dst tmp )
655 {
656 if(tmp.File == TGSI_FILE_TEMPORARY)
657 util_bitmask_set(ureg->free_temps, tmp.Index);
658 }
659
660
661 /* Allocate a new address register.
662 */
663 struct ureg_dst ureg_DECL_address( struct ureg_program *ureg )
664 {
665 if (ureg->nr_addrs < UREG_MAX_ADDR)
666 return ureg_dst_register( TGSI_FILE_ADDRESS, ureg->nr_addrs++ );
667
668 assert( 0 );
669 return ureg_dst_register( TGSI_FILE_ADDRESS, 0 );
670 }
671
672 /* Allocate a new sampler.
673 */
674 struct ureg_src ureg_DECL_sampler( struct ureg_program *ureg,
675 unsigned nr )
676 {
677 unsigned i;
678
679 for (i = 0; i < ureg->nr_samplers; i++)
680 if (ureg->sampler[i].Index == nr)
681 return ureg->sampler[i];
682
683 if (i < PIPE_MAX_SAMPLERS) {
684 ureg->sampler[i] = ureg_src_register( TGSI_FILE_SAMPLER, nr );
685 ureg->nr_samplers++;
686 return ureg->sampler[i];
687 }
688
689 assert( 0 );
690 return ureg->sampler[0];
691 }
692
693 /*
694 * Allocate a new shader sampler view.
695 */
696 struct ureg_src
697 ureg_DECL_sampler_view(struct ureg_program *ureg,
698 unsigned index,
699 unsigned target,
700 unsigned return_type_x,
701 unsigned return_type_y,
702 unsigned return_type_z,
703 unsigned return_type_w)
704 {
705 struct ureg_src reg = ureg_src_register(TGSI_FILE_SAMPLER_VIEW, index);
706 uint i;
707
708 for (i = 0; i < ureg->nr_sampler_views; i++) {
709 if (ureg->sampler_view[i].index == index) {
710 return reg;
711 }
712 }
713
714 if (i < PIPE_MAX_SHADER_SAMPLER_VIEWS) {
715 ureg->sampler_view[i].index = index;
716 ureg->sampler_view[i].target = target;
717 ureg->sampler_view[i].return_type_x = return_type_x;
718 ureg->sampler_view[i].return_type_y = return_type_y;
719 ureg->sampler_view[i].return_type_z = return_type_z;
720 ureg->sampler_view[i].return_type_w = return_type_w;
721 ureg->nr_sampler_views++;
722 return reg;
723 }
724
725 assert(0);
726 return reg;
727 }
728
729 /* Allocate a new image.
730 */
731 struct ureg_src
732 ureg_DECL_image(struct ureg_program *ureg,
733 unsigned index,
734 unsigned target,
735 unsigned format,
736 boolean wr,
737 boolean raw)
738 {
739 struct ureg_src reg = ureg_src_register(TGSI_FILE_IMAGE, index);
740 unsigned i;
741
742 for (i = 0; i < ureg->nr_images; i++)
743 if (ureg->image[i].index == index)
744 return reg;
745
746 if (i < PIPE_MAX_SHADER_IMAGES) {
747 ureg->image[i].index = index;
748 ureg->image[i].target = target;
749 ureg->image[i].wr = wr;
750 ureg->image[i].raw = raw;
751 ureg->image[i].format = format;
752 ureg->nr_images++;
753 return reg;
754 }
755
756 assert(0);
757 return reg;
758 }
759
760 /* Allocate a new buffer.
761 */
762 struct ureg_src ureg_DECL_buffer(struct ureg_program *ureg, unsigned nr,
763 bool atomic)
764 {
765 struct ureg_src reg = ureg_src_register(TGSI_FILE_BUFFER, nr);
766 unsigned i;
767
768 for (i = 0; i < ureg->nr_buffers; i++)
769 if (ureg->buffer[i].index == nr)
770 return reg;
771
772 if (i < PIPE_MAX_SHADER_BUFFERS) {
773 ureg->buffer[i].index = nr;
774 ureg->buffer[i].atomic = atomic;
775 ureg->nr_buffers++;
776 return reg;
777 }
778
779 assert(0);
780 return reg;
781 }
782
783 /* Allocate a memory area.
784 */
785 struct ureg_src ureg_DECL_memory(struct ureg_program *ureg,
786 unsigned memory_type)
787 {
788 struct ureg_src reg = ureg_src_register(TGSI_FILE_MEMORY, memory_type);
789
790 ureg->use_memory[memory_type] = true;
791 return reg;
792 }
793
794 static int
795 match_or_expand_immediate64( const unsigned *v,
796 int type,
797 unsigned nr,
798 unsigned *v2,
799 unsigned *pnr2,
800 unsigned *swizzle )
801 {
802 unsigned nr2 = *pnr2;
803 unsigned i, j;
804 *swizzle = 0;
805
806 for (i = 0; i < nr; i += 2) {
807 boolean found = FALSE;
808
809 for (j = 0; j < nr2 && !found; j += 2) {
810 if (v[i] == v2[j] && v[i + 1] == v2[j + 1]) {
811 *swizzle |= (j << (i * 2)) | ((j + 1) << ((i + 1) * 2));
812 found = TRUE;
813 }
814 }
815 if (!found) {
816 if ((nr2) >= 4) {
817 return FALSE;
818 }
819
820 v2[nr2] = v[i];
821 v2[nr2 + 1] = v[i + 1];
822
823 *swizzle |= (nr2 << (i * 2)) | ((nr2 + 1) << ((i + 1) * 2));
824 nr2 += 2;
825 }
826 }
827
828 /* Actually expand immediate only when fully succeeded.
829 */
830 *pnr2 = nr2;
831 return TRUE;
832 }
833
834 static int
835 match_or_expand_immediate( const unsigned *v,
836 int type,
837 unsigned nr,
838 unsigned *v2,
839 unsigned *pnr2,
840 unsigned *swizzle )
841 {
842 unsigned nr2 = *pnr2;
843 unsigned i, j;
844
845 if (type == TGSI_IMM_FLOAT64 ||
846 type == TGSI_IMM_UINT64 ||
847 type == TGSI_IMM_INT64)
848 return match_or_expand_immediate64(v, type, nr, v2, pnr2, swizzle);
849
850 *swizzle = 0;
851
852 for (i = 0; i < nr; i++) {
853 boolean found = FALSE;
854
855 for (j = 0; j < nr2 && !found; j++) {
856 if (v[i] == v2[j]) {
857 *swizzle |= j << (i * 2);
858 found = TRUE;
859 }
860 }
861
862 if (!found) {
863 if (nr2 >= 4) {
864 return FALSE;
865 }
866
867 v2[nr2] = v[i];
868 *swizzle |= nr2 << (i * 2);
869 nr2++;
870 }
871 }
872
873 /* Actually expand immediate only when fully succeeded.
874 */
875 *pnr2 = nr2;
876 return TRUE;
877 }
878
879
880 static struct ureg_src
881 decl_immediate( struct ureg_program *ureg,
882 const unsigned *v,
883 unsigned nr,
884 unsigned type )
885 {
886 unsigned i, j;
887 unsigned swizzle = 0;
888
889 /* Could do a first pass where we examine all existing immediates
890 * without expanding.
891 */
892
893 for (i = 0; i < ureg->nr_immediates; i++) {
894 if (ureg->immediate[i].type != type) {
895 continue;
896 }
897 if (match_or_expand_immediate(v,
898 type,
899 nr,
900 ureg->immediate[i].value.u,
901 &ureg->immediate[i].nr,
902 &swizzle)) {
903 goto out;
904 }
905 }
906
907 if (ureg->nr_immediates < UREG_MAX_IMMEDIATE) {
908 i = ureg->nr_immediates++;
909 ureg->immediate[i].type = type;
910 if (match_or_expand_immediate(v,
911 type,
912 nr,
913 ureg->immediate[i].value.u,
914 &ureg->immediate[i].nr,
915 &swizzle)) {
916 goto out;
917 }
918 }
919
920 set_bad(ureg);
921
922 out:
923 /* Make sure that all referenced elements are from this immediate.
924 * Has the effect of making size-one immediates into scalars.
925 */
926 if (type == TGSI_IMM_FLOAT64 ||
927 type == TGSI_IMM_UINT64 ||
928 type == TGSI_IMM_INT64) {
929 for (j = nr; j < 4; j+=2) {
930 swizzle |= (swizzle & 0xf) << (j * 2);
931 }
932 } else {
933 for (j = nr; j < 4; j++) {
934 swizzle |= (swizzle & 0x3) << (j * 2);
935 }
936 }
937 return ureg_swizzle(ureg_src_register(TGSI_FILE_IMMEDIATE, i),
938 (swizzle >> 0) & 0x3,
939 (swizzle >> 2) & 0x3,
940 (swizzle >> 4) & 0x3,
941 (swizzle >> 6) & 0x3);
942 }
943
944
945 struct ureg_src
946 ureg_DECL_immediate( struct ureg_program *ureg,
947 const float *v,
948 unsigned nr )
949 {
950 union {
951 float f[4];
952 unsigned u[4];
953 } fu;
954 unsigned int i;
955
956 for (i = 0; i < nr; i++) {
957 fu.f[i] = v[i];
958 }
959
960 return decl_immediate(ureg, fu.u, nr, TGSI_IMM_FLOAT32);
961 }
962
963 struct ureg_src
964 ureg_DECL_immediate_f64( struct ureg_program *ureg,
965 const double *v,
966 unsigned nr )
967 {
968 union {
969 unsigned u[4];
970 double d[2];
971 } fu;
972 unsigned int i;
973
974 assert((nr / 2) < 3);
975 for (i = 0; i < nr / 2; i++) {
976 fu.d[i] = v[i];
977 }
978
979 return decl_immediate(ureg, fu.u, nr, TGSI_IMM_FLOAT64);
980 }
981
982 struct ureg_src
983 ureg_DECL_immediate_uint( struct ureg_program *ureg,
984 const unsigned *v,
985 unsigned nr )
986 {
987 return decl_immediate(ureg, v, nr, TGSI_IMM_UINT32);
988 }
989
990
991 struct ureg_src
992 ureg_DECL_immediate_block_uint( struct ureg_program *ureg,
993 const unsigned *v,
994 unsigned nr )
995 {
996 uint index;
997 uint i;
998
999 if (ureg->nr_immediates + (nr + 3) / 4 > UREG_MAX_IMMEDIATE) {
1000 set_bad(ureg);
1001 return ureg_src_register(TGSI_FILE_IMMEDIATE, 0);
1002 }
1003
1004 index = ureg->nr_immediates;
1005 ureg->nr_immediates += (nr + 3) / 4;
1006
1007 for (i = index; i < ureg->nr_immediates; i++) {
1008 ureg->immediate[i].type = TGSI_IMM_UINT32;
1009 ureg->immediate[i].nr = nr > 4 ? 4 : nr;
1010 memcpy(ureg->immediate[i].value.u,
1011 &v[(i - index) * 4],
1012 ureg->immediate[i].nr * sizeof(uint));
1013 nr -= 4;
1014 }
1015
1016 return ureg_src_register(TGSI_FILE_IMMEDIATE, index);
1017 }
1018
1019
1020 struct ureg_src
1021 ureg_DECL_immediate_int( struct ureg_program *ureg,
1022 const int *v,
1023 unsigned nr )
1024 {
1025 return decl_immediate(ureg, (const unsigned *)v, nr, TGSI_IMM_INT32);
1026 }
1027
1028 struct ureg_src
1029 ureg_DECL_immediate_uint64( struct ureg_program *ureg,
1030 const uint64_t *v,
1031 unsigned nr )
1032 {
1033 union {
1034 unsigned u[4];
1035 uint64_t u64[2];
1036 } fu;
1037 unsigned int i;
1038
1039 assert((nr / 2) < 3);
1040 for (i = 0; i < nr / 2; i++) {
1041 fu.u64[i] = v[i];
1042 }
1043
1044 return decl_immediate(ureg, fu.u, nr, TGSI_IMM_UINT64);
1045 }
1046
1047 struct ureg_src
1048 ureg_DECL_immediate_int64( struct ureg_program *ureg,
1049 const int64_t *v,
1050 unsigned nr )
1051 {
1052 union {
1053 unsigned u[4];
1054 int64_t i64[2];
1055 } fu;
1056 unsigned int i;
1057
1058 assert((nr / 2) < 3);
1059 for (i = 0; i < nr / 2; i++) {
1060 fu.i64[i] = v[i];
1061 }
1062
1063 return decl_immediate(ureg, fu.u, nr, TGSI_IMM_INT64);
1064 }
1065
1066 void
1067 ureg_emit_src( struct ureg_program *ureg,
1068 struct ureg_src src )
1069 {
1070 unsigned size = 1 + (src.Indirect ? 1 : 0) +
1071 (src.Dimension ? (src.DimIndirect ? 2 : 1) : 0);
1072
1073 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size );
1074 unsigned n = 0;
1075
1076 assert(src.File != TGSI_FILE_NULL);
1077 assert(src.File < TGSI_FILE_COUNT);
1078
1079 out[n].value = 0;
1080 out[n].src.File = src.File;
1081 out[n].src.SwizzleX = src.SwizzleX;
1082 out[n].src.SwizzleY = src.SwizzleY;
1083 out[n].src.SwizzleZ = src.SwizzleZ;
1084 out[n].src.SwizzleW = src.SwizzleW;
1085 out[n].src.Index = src.Index;
1086 out[n].src.Negate = src.Negate;
1087 out[0].src.Absolute = src.Absolute;
1088 n++;
1089
1090 if (src.Indirect) {
1091 out[0].src.Indirect = 1;
1092 out[n].value = 0;
1093 out[n].ind.File = src.IndirectFile;
1094 out[n].ind.Swizzle = src.IndirectSwizzle;
1095 out[n].ind.Index = src.IndirectIndex;
1096 if (!ureg->supports_any_inout_decl_range &&
1097 (src.File == TGSI_FILE_INPUT || src.File == TGSI_FILE_OUTPUT))
1098 out[n].ind.ArrayID = 0;
1099 else
1100 out[n].ind.ArrayID = src.ArrayID;
1101 n++;
1102 }
1103
1104 if (src.Dimension) {
1105 out[0].src.Dimension = 1;
1106 out[n].dim.Dimension = 0;
1107 out[n].dim.Padding = 0;
1108 if (src.DimIndirect) {
1109 out[n].dim.Indirect = 1;
1110 out[n].dim.Index = src.DimensionIndex;
1111 n++;
1112 out[n].value = 0;
1113 out[n].ind.File = src.DimIndFile;
1114 out[n].ind.Swizzle = src.DimIndSwizzle;
1115 out[n].ind.Index = src.DimIndIndex;
1116 if (!ureg->supports_any_inout_decl_range &&
1117 (src.File == TGSI_FILE_INPUT || src.File == TGSI_FILE_OUTPUT))
1118 out[n].ind.ArrayID = 0;
1119 else
1120 out[n].ind.ArrayID = src.ArrayID;
1121 } else {
1122 out[n].dim.Indirect = 0;
1123 out[n].dim.Index = src.DimensionIndex;
1124 }
1125 n++;
1126 }
1127
1128 assert(n == size);
1129 }
1130
1131
1132 void
1133 ureg_emit_dst( struct ureg_program *ureg,
1134 struct ureg_dst dst )
1135 {
1136 unsigned size = 1 + (dst.Indirect ? 1 : 0) +
1137 (dst.Dimension ? (dst.DimIndirect ? 2 : 1) : 0);
1138
1139 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_INSN, size );
1140 unsigned n = 0;
1141
1142 assert(dst.File != TGSI_FILE_NULL);
1143 assert(dst.File != TGSI_FILE_CONSTANT);
1144 assert(dst.File != TGSI_FILE_INPUT);
1145 assert(dst.File != TGSI_FILE_SAMPLER);
1146 assert(dst.File != TGSI_FILE_SAMPLER_VIEW);
1147 assert(dst.File != TGSI_FILE_IMMEDIATE);
1148 assert(dst.File < TGSI_FILE_COUNT);
1149
1150 out[n].value = 0;
1151 out[n].dst.File = dst.File;
1152 out[n].dst.WriteMask = dst.WriteMask;
1153 out[n].dst.Indirect = dst.Indirect;
1154 out[n].dst.Index = dst.Index;
1155 n++;
1156
1157 if (dst.Indirect) {
1158 out[n].value = 0;
1159 out[n].ind.File = dst.IndirectFile;
1160 out[n].ind.Swizzle = dst.IndirectSwizzle;
1161 out[n].ind.Index = dst.IndirectIndex;
1162 if (!ureg->supports_any_inout_decl_range &&
1163 (dst.File == TGSI_FILE_INPUT || dst.File == TGSI_FILE_OUTPUT))
1164 out[n].ind.ArrayID = 0;
1165 else
1166 out[n].ind.ArrayID = dst.ArrayID;
1167 n++;
1168 }
1169
1170 if (dst.Dimension) {
1171 out[0].dst.Dimension = 1;
1172 out[n].dim.Dimension = 0;
1173 out[n].dim.Padding = 0;
1174 if (dst.DimIndirect) {
1175 out[n].dim.Indirect = 1;
1176 out[n].dim.Index = dst.DimensionIndex;
1177 n++;
1178 out[n].value = 0;
1179 out[n].ind.File = dst.DimIndFile;
1180 out[n].ind.Swizzle = dst.DimIndSwizzle;
1181 out[n].ind.Index = dst.DimIndIndex;
1182 if (!ureg->supports_any_inout_decl_range &&
1183 (dst.File == TGSI_FILE_INPUT || dst.File == TGSI_FILE_OUTPUT))
1184 out[n].ind.ArrayID = 0;
1185 else
1186 out[n].ind.ArrayID = dst.ArrayID;
1187 } else {
1188 out[n].dim.Indirect = 0;
1189 out[n].dim.Index = dst.DimensionIndex;
1190 }
1191 n++;
1192 }
1193
1194 assert(n == size);
1195 }
1196
1197
1198 static void validate( unsigned opcode,
1199 unsigned nr_dst,
1200 unsigned nr_src )
1201 {
1202 #ifdef DEBUG
1203 const struct tgsi_opcode_info *info = tgsi_get_opcode_info( opcode );
1204 assert(info);
1205 if (info) {
1206 assert(nr_dst == info->num_dst);
1207 assert(nr_src == info->num_src);
1208 }
1209 #endif
1210 }
1211
1212 struct ureg_emit_insn_result
1213 ureg_emit_insn(struct ureg_program *ureg,
1214 unsigned opcode,
1215 boolean saturate,
1216 unsigned num_dst,
1217 unsigned num_src)
1218 {
1219 union tgsi_any_token *out;
1220 uint count = 1;
1221 struct ureg_emit_insn_result result;
1222
1223 validate( opcode, num_dst, num_src );
1224
1225 out = get_tokens( ureg, DOMAIN_INSN, count );
1226 out[0].insn = tgsi_default_instruction();
1227 out[0].insn.Opcode = opcode;
1228 out[0].insn.Saturate = saturate;
1229 out[0].insn.NumDstRegs = num_dst;
1230 out[0].insn.NumSrcRegs = num_src;
1231
1232 result.insn_token = ureg->domain[DOMAIN_INSN].count - count;
1233 result.extended_token = result.insn_token;
1234
1235 ureg->nr_instructions++;
1236
1237 return result;
1238 }
1239
1240
1241 /**
1242 * Emit a label token.
1243 * \param label_token returns a token number indicating where the label
1244 * needs to be patched later. Later, this value should be passed to the
1245 * ureg_fixup_label() function.
1246 */
1247 void
1248 ureg_emit_label(struct ureg_program *ureg,
1249 unsigned extended_token,
1250 unsigned *label_token )
1251 {
1252 union tgsi_any_token *out, *insn;
1253
1254 if (!label_token)
1255 return;
1256
1257 out = get_tokens( ureg, DOMAIN_INSN, 1 );
1258 out[0].value = 0;
1259
1260 insn = retrieve_token( ureg, DOMAIN_INSN, extended_token );
1261 insn->insn.Label = 1;
1262
1263 *label_token = ureg->domain[DOMAIN_INSN].count - 1;
1264 }
1265
1266 /* Will return a number which can be used in a label to point to the
1267 * next instruction to be emitted.
1268 */
1269 unsigned
1270 ureg_get_instruction_number( struct ureg_program *ureg )
1271 {
1272 return ureg->nr_instructions;
1273 }
1274
1275 /* Patch a given label (expressed as a token number) to point to a
1276 * given instruction (expressed as an instruction number).
1277 */
1278 void
1279 ureg_fixup_label(struct ureg_program *ureg,
1280 unsigned label_token,
1281 unsigned instruction_number )
1282 {
1283 union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, label_token );
1284
1285 out->insn_label.Label = instruction_number;
1286 }
1287
1288
1289 void
1290 ureg_emit_texture(struct ureg_program *ureg,
1291 unsigned extended_token,
1292 unsigned target, unsigned num_offsets)
1293 {
1294 union tgsi_any_token *out, *insn;
1295
1296 out = get_tokens( ureg, DOMAIN_INSN, 1 );
1297 insn = retrieve_token( ureg, DOMAIN_INSN, extended_token );
1298
1299 insn->insn.Texture = 1;
1300
1301 out[0].value = 0;
1302 out[0].insn_texture.Texture = target;
1303 out[0].insn_texture.NumOffsets = num_offsets;
1304 }
1305
1306 void
1307 ureg_emit_texture_offset(struct ureg_program *ureg,
1308 const struct tgsi_texture_offset *offset)
1309 {
1310 union tgsi_any_token *out;
1311
1312 out = get_tokens( ureg, DOMAIN_INSN, 1);
1313
1314 out[0].value = 0;
1315 out[0].insn_texture_offset = *offset;
1316
1317 }
1318
1319 void
1320 ureg_emit_memory(struct ureg_program *ureg,
1321 unsigned extended_token,
1322 unsigned qualifier,
1323 unsigned texture,
1324 unsigned format)
1325 {
1326 union tgsi_any_token *out, *insn;
1327
1328 out = get_tokens( ureg, DOMAIN_INSN, 1 );
1329 insn = retrieve_token( ureg, DOMAIN_INSN, extended_token );
1330
1331 insn->insn.Memory = 1;
1332
1333 out[0].value = 0;
1334 out[0].insn_memory.Qualifier = qualifier;
1335 out[0].insn_memory.Texture = texture;
1336 out[0].insn_memory.Format = format;
1337 }
1338
1339 void
1340 ureg_fixup_insn_size(struct ureg_program *ureg,
1341 unsigned insn )
1342 {
1343 union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_INSN, insn );
1344
1345 assert(out->insn.Type == TGSI_TOKEN_TYPE_INSTRUCTION);
1346 out->insn.NrTokens = ureg->domain[DOMAIN_INSN].count - insn - 1;
1347 }
1348
1349
1350 void
1351 ureg_insn(struct ureg_program *ureg,
1352 unsigned opcode,
1353 const struct ureg_dst *dst,
1354 unsigned nr_dst,
1355 const struct ureg_src *src,
1356 unsigned nr_src )
1357 {
1358 struct ureg_emit_insn_result insn;
1359 unsigned i;
1360 boolean saturate;
1361
1362 if (nr_dst && ureg_dst_is_empty(dst[0])) {
1363 return;
1364 }
1365
1366 saturate = nr_dst ? dst[0].Saturate : FALSE;
1367
1368 insn = ureg_emit_insn(ureg,
1369 opcode,
1370 saturate,
1371 nr_dst,
1372 nr_src);
1373
1374 for (i = 0; i < nr_dst; i++)
1375 ureg_emit_dst( ureg, dst[i] );
1376
1377 for (i = 0; i < nr_src; i++)
1378 ureg_emit_src( ureg, src[i] );
1379
1380 ureg_fixup_insn_size( ureg, insn.insn_token );
1381 }
1382
1383 void
1384 ureg_tex_insn(struct ureg_program *ureg,
1385 unsigned opcode,
1386 const struct ureg_dst *dst,
1387 unsigned nr_dst,
1388 unsigned target,
1389 const struct tgsi_texture_offset *texoffsets,
1390 unsigned nr_offset,
1391 const struct ureg_src *src,
1392 unsigned nr_src )
1393 {
1394 struct ureg_emit_insn_result insn;
1395 unsigned i;
1396 boolean saturate;
1397
1398 if (nr_dst && ureg_dst_is_empty(dst[0])) {
1399 return;
1400 }
1401
1402 saturate = nr_dst ? dst[0].Saturate : FALSE;
1403
1404 insn = ureg_emit_insn(ureg,
1405 opcode,
1406 saturate,
1407 nr_dst,
1408 nr_src);
1409
1410 ureg_emit_texture( ureg, insn.extended_token, target, nr_offset );
1411
1412 for (i = 0; i < nr_offset; i++)
1413 ureg_emit_texture_offset( ureg, &texoffsets[i]);
1414
1415 for (i = 0; i < nr_dst; i++)
1416 ureg_emit_dst( ureg, dst[i] );
1417
1418 for (i = 0; i < nr_src; i++)
1419 ureg_emit_src( ureg, src[i] );
1420
1421 ureg_fixup_insn_size( ureg, insn.insn_token );
1422 }
1423
1424
1425 void
1426 ureg_memory_insn(struct ureg_program *ureg,
1427 unsigned opcode,
1428 const struct ureg_dst *dst,
1429 unsigned nr_dst,
1430 const struct ureg_src *src,
1431 unsigned nr_src,
1432 unsigned qualifier,
1433 unsigned texture,
1434 unsigned format)
1435 {
1436 struct ureg_emit_insn_result insn;
1437 unsigned i;
1438
1439 insn = ureg_emit_insn(ureg,
1440 opcode,
1441 FALSE,
1442 nr_dst,
1443 nr_src);
1444
1445 ureg_emit_memory(ureg, insn.extended_token, qualifier, texture, format);
1446
1447 for (i = 0; i < nr_dst; i++)
1448 ureg_emit_dst(ureg, dst[i]);
1449
1450 for (i = 0; i < nr_src; i++)
1451 ureg_emit_src(ureg, src[i]);
1452
1453 ureg_fixup_insn_size(ureg, insn.insn_token);
1454 }
1455
1456
1457 static void
1458 emit_decl_semantic(struct ureg_program *ureg,
1459 unsigned file,
1460 unsigned first,
1461 unsigned last,
1462 unsigned semantic_name,
1463 unsigned semantic_index,
1464 unsigned streams,
1465 unsigned usage_mask,
1466 unsigned array_id)
1467 {
1468 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, array_id ? 4 : 3);
1469
1470 out[0].value = 0;
1471 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1472 out[0].decl.NrTokens = 3;
1473 out[0].decl.File = file;
1474 out[0].decl.UsageMask = usage_mask;
1475 out[0].decl.Semantic = 1;
1476 out[0].decl.Array = array_id != 0;
1477
1478 out[1].value = 0;
1479 out[1].decl_range.First = first;
1480 out[1].decl_range.Last = last;
1481
1482 out[2].value = 0;
1483 out[2].decl_semantic.Name = semantic_name;
1484 out[2].decl_semantic.Index = semantic_index;
1485 out[2].decl_semantic.StreamX = streams & 3;
1486 out[2].decl_semantic.StreamY = (streams >> 2) & 3;
1487 out[2].decl_semantic.StreamZ = (streams >> 4) & 3;
1488 out[2].decl_semantic.StreamW = (streams >> 6) & 3;
1489
1490 if (array_id) {
1491 out[3].value = 0;
1492 out[3].array.ArrayID = array_id;
1493 }
1494 }
1495
1496
1497 static void
1498 emit_decl_fs(struct ureg_program *ureg,
1499 unsigned file,
1500 unsigned first,
1501 unsigned last,
1502 unsigned semantic_name,
1503 unsigned semantic_index,
1504 unsigned interpolate,
1505 unsigned cylindrical_wrap,
1506 unsigned interpolate_location,
1507 unsigned array_id,
1508 unsigned usage_mask)
1509 {
1510 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL,
1511 array_id ? 5 : 4);
1512
1513 out[0].value = 0;
1514 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1515 out[0].decl.NrTokens = 4;
1516 out[0].decl.File = file;
1517 out[0].decl.UsageMask = usage_mask;
1518 out[0].decl.Interpolate = 1;
1519 out[0].decl.Semantic = 1;
1520 out[0].decl.Array = array_id != 0;
1521
1522 out[1].value = 0;
1523 out[1].decl_range.First = first;
1524 out[1].decl_range.Last = last;
1525
1526 out[2].value = 0;
1527 out[2].decl_interp.Interpolate = interpolate;
1528 out[2].decl_interp.CylindricalWrap = cylindrical_wrap;
1529 out[2].decl_interp.Location = interpolate_location;
1530
1531 out[3].value = 0;
1532 out[3].decl_semantic.Name = semantic_name;
1533 out[3].decl_semantic.Index = semantic_index;
1534
1535 if (array_id) {
1536 out[4].value = 0;
1537 out[4].array.ArrayID = array_id;
1538 }
1539 }
1540
1541 static void
1542 emit_decl_temps( struct ureg_program *ureg,
1543 unsigned first, unsigned last,
1544 boolean local,
1545 unsigned arrayid )
1546 {
1547 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL,
1548 arrayid ? 3 : 2 );
1549
1550 out[0].value = 0;
1551 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1552 out[0].decl.NrTokens = 2;
1553 out[0].decl.File = TGSI_FILE_TEMPORARY;
1554 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1555 out[0].decl.Local = local;
1556
1557 out[1].value = 0;
1558 out[1].decl_range.First = first;
1559 out[1].decl_range.Last = last;
1560
1561 if (arrayid) {
1562 out[0].decl.Array = 1;
1563 out[2].value = 0;
1564 out[2].array.ArrayID = arrayid;
1565 }
1566 }
1567
1568 static void emit_decl_range( struct ureg_program *ureg,
1569 unsigned file,
1570 unsigned first,
1571 unsigned count )
1572 {
1573 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 );
1574
1575 out[0].value = 0;
1576 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1577 out[0].decl.NrTokens = 2;
1578 out[0].decl.File = file;
1579 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1580 out[0].decl.Semantic = 0;
1581
1582 out[1].value = 0;
1583 out[1].decl_range.First = first;
1584 out[1].decl_range.Last = first + count - 1;
1585 }
1586
1587 static void
1588 emit_decl_range2D(struct ureg_program *ureg,
1589 unsigned file,
1590 unsigned first,
1591 unsigned last,
1592 unsigned index2D)
1593 {
1594 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 3);
1595
1596 out[0].value = 0;
1597 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1598 out[0].decl.NrTokens = 3;
1599 out[0].decl.File = file;
1600 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1601 out[0].decl.Dimension = 1;
1602
1603 out[1].value = 0;
1604 out[1].decl_range.First = first;
1605 out[1].decl_range.Last = last;
1606
1607 out[2].value = 0;
1608 out[2].decl_dim.Index2D = index2D;
1609 }
1610
1611 static void
1612 emit_decl_sampler_view(struct ureg_program *ureg,
1613 unsigned index,
1614 unsigned target,
1615 unsigned return_type_x,
1616 unsigned return_type_y,
1617 unsigned return_type_z,
1618 unsigned return_type_w )
1619 {
1620 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 3);
1621
1622 out[0].value = 0;
1623 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1624 out[0].decl.NrTokens = 3;
1625 out[0].decl.File = TGSI_FILE_SAMPLER_VIEW;
1626 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1627
1628 out[1].value = 0;
1629 out[1].decl_range.First = index;
1630 out[1].decl_range.Last = index;
1631
1632 out[2].value = 0;
1633 out[2].decl_sampler_view.Resource = target;
1634 out[2].decl_sampler_view.ReturnTypeX = return_type_x;
1635 out[2].decl_sampler_view.ReturnTypeY = return_type_y;
1636 out[2].decl_sampler_view.ReturnTypeZ = return_type_z;
1637 out[2].decl_sampler_view.ReturnTypeW = return_type_w;
1638 }
1639
1640 static void
1641 emit_decl_image(struct ureg_program *ureg,
1642 unsigned index,
1643 unsigned target,
1644 unsigned format,
1645 boolean wr,
1646 boolean raw)
1647 {
1648 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 3);
1649
1650 out[0].value = 0;
1651 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1652 out[0].decl.NrTokens = 3;
1653 out[0].decl.File = TGSI_FILE_IMAGE;
1654 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1655
1656 out[1].value = 0;
1657 out[1].decl_range.First = index;
1658 out[1].decl_range.Last = index;
1659
1660 out[2].value = 0;
1661 out[2].decl_image.Resource = target;
1662 out[2].decl_image.Writable = wr;
1663 out[2].decl_image.Raw = raw;
1664 out[2].decl_image.Format = format;
1665 }
1666
1667 static void
1668 emit_decl_buffer(struct ureg_program *ureg,
1669 unsigned index,
1670 bool atomic)
1671 {
1672 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 2);
1673
1674 out[0].value = 0;
1675 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1676 out[0].decl.NrTokens = 2;
1677 out[0].decl.File = TGSI_FILE_BUFFER;
1678 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1679 out[0].decl.Atomic = atomic;
1680
1681 out[1].value = 0;
1682 out[1].decl_range.First = index;
1683 out[1].decl_range.Last = index;
1684 }
1685
1686 static void
1687 emit_decl_memory(struct ureg_program *ureg, unsigned memory_type)
1688 {
1689 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 2);
1690
1691 out[0].value = 0;
1692 out[0].decl.Type = TGSI_TOKEN_TYPE_DECLARATION;
1693 out[0].decl.NrTokens = 2;
1694 out[0].decl.File = TGSI_FILE_MEMORY;
1695 out[0].decl.UsageMask = TGSI_WRITEMASK_XYZW;
1696 out[0].decl.MemType = memory_type;
1697
1698 out[1].value = 0;
1699 out[1].decl_range.First = memory_type;
1700 out[1].decl_range.Last = memory_type;
1701 }
1702
1703 static void
1704 emit_immediate( struct ureg_program *ureg,
1705 const unsigned *v,
1706 unsigned type )
1707 {
1708 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 5 );
1709
1710 out[0].value = 0;
1711 out[0].imm.Type = TGSI_TOKEN_TYPE_IMMEDIATE;
1712 out[0].imm.NrTokens = 5;
1713 out[0].imm.DataType = type;
1714 out[0].imm.Padding = 0;
1715
1716 out[1].imm_data.Uint = v[0];
1717 out[2].imm_data.Uint = v[1];
1718 out[3].imm_data.Uint = v[2];
1719 out[4].imm_data.Uint = v[3];
1720 }
1721
1722 static void
1723 emit_property(struct ureg_program *ureg,
1724 unsigned name,
1725 unsigned data)
1726 {
1727 union tgsi_any_token *out = get_tokens(ureg, DOMAIN_DECL, 2);
1728
1729 out[0].value = 0;
1730 out[0].prop.Type = TGSI_TOKEN_TYPE_PROPERTY;
1731 out[0].prop.NrTokens = 2;
1732 out[0].prop.PropertyName = name;
1733
1734 out[1].prop_data.Data = data;
1735 }
1736
1737
1738 static void emit_decls( struct ureg_program *ureg )
1739 {
1740 unsigned i,j;
1741
1742 for (i = 0; i < ARRAY_SIZE(ureg->properties); i++)
1743 if (ureg->properties[i] != ~0)
1744 emit_property(ureg, i, ureg->properties[i]);
1745
1746 if (ureg->processor == PIPE_SHADER_VERTEX) {
1747 for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
1748 if (ureg->vs_inputs[i/32] & (1u << (i%32))) {
1749 emit_decl_range( ureg, TGSI_FILE_INPUT, i, 1 );
1750 }
1751 }
1752 } else if (ureg->processor == PIPE_SHADER_FRAGMENT) {
1753 if (ureg->supports_any_inout_decl_range) {
1754 for (i = 0; i < ureg->nr_inputs; i++) {
1755 emit_decl_fs(ureg,
1756 TGSI_FILE_INPUT,
1757 ureg->input[i].first,
1758 ureg->input[i].last,
1759 ureg->input[i].semantic_name,
1760 ureg->input[i].semantic_index,
1761 ureg->input[i].interp,
1762 ureg->input[i].cylindrical_wrap,
1763 ureg->input[i].interp_location,
1764 ureg->input[i].array_id,
1765 ureg->input[i].usage_mask);
1766 }
1767 }
1768 else {
1769 for (i = 0; i < ureg->nr_inputs; i++) {
1770 for (j = ureg->input[i].first; j <= ureg->input[i].last; j++) {
1771 emit_decl_fs(ureg,
1772 TGSI_FILE_INPUT,
1773 j, j,
1774 ureg->input[i].semantic_name,
1775 ureg->input[i].semantic_index +
1776 (j - ureg->input[i].first),
1777 ureg->input[i].interp,
1778 ureg->input[i].cylindrical_wrap,
1779 ureg->input[i].interp_location, 0,
1780 ureg->input[i].usage_mask);
1781 }
1782 }
1783 }
1784 } else {
1785 if (ureg->supports_any_inout_decl_range) {
1786 for (i = 0; i < ureg->nr_inputs; i++) {
1787 emit_decl_semantic(ureg,
1788 TGSI_FILE_INPUT,
1789 ureg->input[i].first,
1790 ureg->input[i].last,
1791 ureg->input[i].semantic_name,
1792 ureg->input[i].semantic_index,
1793 0,
1794 TGSI_WRITEMASK_XYZW,
1795 ureg->input[i].array_id);
1796 }
1797 }
1798 else {
1799 for (i = 0; i < ureg->nr_inputs; i++) {
1800 for (j = ureg->input[i].first; j <= ureg->input[i].last; j++) {
1801 emit_decl_semantic(ureg,
1802 TGSI_FILE_INPUT,
1803 j, j,
1804 ureg->input[i].semantic_name,
1805 ureg->input[i].semantic_index +
1806 (j - ureg->input[i].first),
1807 0,
1808 TGSI_WRITEMASK_XYZW, 0);
1809 }
1810 }
1811 }
1812 }
1813
1814 for (i = 0; i < ureg->nr_system_values; i++) {
1815 emit_decl_semantic(ureg,
1816 TGSI_FILE_SYSTEM_VALUE,
1817 i,
1818 i,
1819 ureg->system_value[i].semantic_name,
1820 ureg->system_value[i].semantic_index,
1821 0,
1822 TGSI_WRITEMASK_XYZW, 0);
1823 }
1824
1825 if (ureg->supports_any_inout_decl_range) {
1826 for (i = 0; i < ureg->nr_outputs; i++) {
1827 emit_decl_semantic(ureg,
1828 TGSI_FILE_OUTPUT,
1829 ureg->output[i].first,
1830 ureg->output[i].last,
1831 ureg->output[i].semantic_name,
1832 ureg->output[i].semantic_index,
1833 ureg->output[i].streams,
1834 ureg->output[i].usage_mask,
1835 ureg->output[i].array_id);
1836 }
1837 }
1838 else {
1839 for (i = 0; i < ureg->nr_outputs; i++) {
1840 for (j = ureg->output[i].first; j <= ureg->output[i].last; j++) {
1841 emit_decl_semantic(ureg,
1842 TGSI_FILE_OUTPUT,
1843 j, j,
1844 ureg->output[i].semantic_name,
1845 ureg->output[i].semantic_index +
1846 (j - ureg->output[i].first),
1847 ureg->output[i].streams,
1848 ureg->output[i].usage_mask, 0);
1849 }
1850 }
1851 }
1852
1853 for (i = 0; i < ureg->nr_samplers; i++) {
1854 emit_decl_range( ureg,
1855 TGSI_FILE_SAMPLER,
1856 ureg->sampler[i].Index, 1 );
1857 }
1858
1859 for (i = 0; i < ureg->nr_sampler_views; i++) {
1860 emit_decl_sampler_view(ureg,
1861 ureg->sampler_view[i].index,
1862 ureg->sampler_view[i].target,
1863 ureg->sampler_view[i].return_type_x,
1864 ureg->sampler_view[i].return_type_y,
1865 ureg->sampler_view[i].return_type_z,
1866 ureg->sampler_view[i].return_type_w);
1867 }
1868
1869 for (i = 0; i < ureg->nr_images; i++) {
1870 emit_decl_image(ureg,
1871 ureg->image[i].index,
1872 ureg->image[i].target,
1873 ureg->image[i].format,
1874 ureg->image[i].wr,
1875 ureg->image[i].raw);
1876 }
1877
1878 for (i = 0; i < ureg->nr_buffers; i++) {
1879 emit_decl_buffer(ureg, ureg->buffer[i].index, ureg->buffer[i].atomic);
1880 }
1881
1882 for (i = 0; i < TGSI_MEMORY_TYPE_COUNT; i++) {
1883 if (ureg->use_memory[i])
1884 emit_decl_memory(ureg, i);
1885 }
1886
1887 if (ureg->const_decls.nr_constant_ranges) {
1888 for (i = 0; i < ureg->const_decls.nr_constant_ranges; i++) {
1889 emit_decl_range(ureg,
1890 TGSI_FILE_CONSTANT,
1891 ureg->const_decls.constant_range[i].first,
1892 ureg->const_decls.constant_range[i].last - ureg->const_decls.constant_range[i].first + 1);
1893 }
1894 }
1895
1896 for (i = 0; i < PIPE_MAX_CONSTANT_BUFFERS; i++) {
1897 struct const_decl *decl = &ureg->const_decls2D[i];
1898
1899 if (decl->nr_constant_ranges) {
1900 uint j;
1901
1902 for (j = 0; j < decl->nr_constant_ranges; j++) {
1903 emit_decl_range2D(ureg,
1904 TGSI_FILE_CONSTANT,
1905 decl->constant_range[j].first,
1906 decl->constant_range[j].last,
1907 i);
1908 }
1909 }
1910 }
1911
1912 if (ureg->nr_temps) {
1913 unsigned array = 0;
1914 for (i = 0; i < ureg->nr_temps;) {
1915 boolean local = util_bitmask_get(ureg->local_temps, i);
1916 unsigned first = i;
1917 i = util_bitmask_get_next_index(ureg->decl_temps, i + 1);
1918 if (i == UTIL_BITMASK_INVALID_INDEX)
1919 i = ureg->nr_temps;
1920
1921 if (array < ureg->nr_array_temps && ureg->array_temps[array] == first)
1922 emit_decl_temps( ureg, first, i - 1, local, ++array );
1923 else
1924 emit_decl_temps( ureg, first, i - 1, local, 0 );
1925 }
1926 }
1927
1928 if (ureg->nr_addrs) {
1929 emit_decl_range( ureg,
1930 TGSI_FILE_ADDRESS,
1931 0, ureg->nr_addrs );
1932 }
1933
1934 for (i = 0; i < ureg->nr_immediates; i++) {
1935 emit_immediate( ureg,
1936 ureg->immediate[i].value.u,
1937 ureg->immediate[i].type );
1938 }
1939 }
1940
1941 /* Append the instruction tokens onto the declarations to build a
1942 * contiguous stream suitable to send to the driver.
1943 */
1944 static void copy_instructions( struct ureg_program *ureg )
1945 {
1946 unsigned nr_tokens = ureg->domain[DOMAIN_INSN].count;
1947 union tgsi_any_token *out = get_tokens( ureg,
1948 DOMAIN_DECL,
1949 nr_tokens );
1950
1951 memcpy(out,
1952 ureg->domain[DOMAIN_INSN].tokens,
1953 nr_tokens * sizeof out[0] );
1954 }
1955
1956
1957 static void
1958 fixup_header_size(struct ureg_program *ureg)
1959 {
1960 union tgsi_any_token *out = retrieve_token( ureg, DOMAIN_DECL, 0 );
1961
1962 out->header.BodySize = ureg->domain[DOMAIN_DECL].count - 2;
1963 }
1964
1965
1966 static void
1967 emit_header( struct ureg_program *ureg )
1968 {
1969 union tgsi_any_token *out = get_tokens( ureg, DOMAIN_DECL, 2 );
1970
1971 out[0].header.HeaderSize = 2;
1972 out[0].header.BodySize = 0;
1973
1974 out[1].processor.Processor = ureg->processor;
1975 out[1].processor.Padding = 0;
1976 }
1977
1978
1979 const struct tgsi_token *ureg_finalize( struct ureg_program *ureg )
1980 {
1981 const struct tgsi_token *tokens;
1982
1983 switch (ureg->processor) {
1984 case PIPE_SHADER_VERTEX:
1985 case PIPE_SHADER_TESS_EVAL:
1986 ureg_property(ureg, TGSI_PROPERTY_NEXT_SHADER,
1987 ureg->next_shader_processor == -1 ?
1988 PIPE_SHADER_FRAGMENT :
1989 ureg->next_shader_processor);
1990 break;
1991 }
1992
1993 emit_header( ureg );
1994 emit_decls( ureg );
1995 copy_instructions( ureg );
1996 fixup_header_size( ureg );
1997
1998 if (ureg->domain[0].tokens == error_tokens ||
1999 ureg->domain[1].tokens == error_tokens) {
2000 debug_printf("%s: error in generated shader\n", __FUNCTION__);
2001 assert(0);
2002 return NULL;
2003 }
2004
2005 tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token;
2006
2007 if (0) {
2008 debug_printf("%s: emitted shader %d tokens:\n", __FUNCTION__,
2009 ureg->domain[DOMAIN_DECL].count);
2010 tgsi_dump( tokens, 0 );
2011 }
2012
2013 #if DEBUG
2014 if (tokens && !tgsi_sanity_check(tokens)) {
2015 debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n");
2016 tgsi_dump(tokens, 0);
2017 assert(0);
2018 }
2019 #endif
2020
2021
2022 return tokens;
2023 }
2024
2025
2026 void *ureg_create_shader( struct ureg_program *ureg,
2027 struct pipe_context *pipe,
2028 const struct pipe_stream_output_info *so )
2029 {
2030 struct pipe_shader_state state;
2031
2032 pipe_shader_state_from_tgsi(&state, ureg_finalize(ureg));
2033 if(!state.tokens)
2034 return NULL;
2035
2036 if (so)
2037 state.stream_output = *so;
2038
2039 switch (ureg->processor) {
2040 case PIPE_SHADER_VERTEX:
2041 return pipe->create_vs_state(pipe, &state);
2042 case PIPE_SHADER_TESS_CTRL:
2043 return pipe->create_tcs_state(pipe, &state);
2044 case PIPE_SHADER_TESS_EVAL:
2045 return pipe->create_tes_state(pipe, &state);
2046 case PIPE_SHADER_GEOMETRY:
2047 return pipe->create_gs_state(pipe, &state);
2048 case PIPE_SHADER_FRAGMENT:
2049 return pipe->create_fs_state(pipe, &state);
2050 default:
2051 return NULL;
2052 }
2053 }
2054
2055
2056 const struct tgsi_token *ureg_get_tokens( struct ureg_program *ureg,
2057 unsigned *nr_tokens )
2058 {
2059 const struct tgsi_token *tokens;
2060
2061 ureg_finalize(ureg);
2062
2063 tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token;
2064
2065 if (nr_tokens)
2066 *nr_tokens = ureg->domain[DOMAIN_DECL].count;
2067
2068 ureg->domain[DOMAIN_DECL].tokens = 0;
2069 ureg->domain[DOMAIN_DECL].size = 0;
2070 ureg->domain[DOMAIN_DECL].order = 0;
2071 ureg->domain[DOMAIN_DECL].count = 0;
2072
2073 return tokens;
2074 }
2075
2076
2077 void ureg_free_tokens( const struct tgsi_token *tokens )
2078 {
2079 FREE((struct tgsi_token *)tokens);
2080 }
2081
2082
2083 struct ureg_program *
2084 ureg_create(unsigned processor)
2085 {
2086 return ureg_create_with_screen(processor, NULL);
2087 }
2088
2089
2090 struct ureg_program *
2091 ureg_create_with_screen(unsigned processor, struct pipe_screen *screen)
2092 {
2093 int i;
2094 struct ureg_program *ureg = CALLOC_STRUCT( ureg_program );
2095 if (!ureg)
2096 goto no_ureg;
2097
2098 ureg->processor = processor;
2099 ureg->supports_any_inout_decl_range =
2100 screen &&
2101 screen->get_shader_param(screen, processor,
2102 PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE) != 0;
2103 ureg->next_shader_processor = -1;
2104
2105 for (i = 0; i < ARRAY_SIZE(ureg->properties); i++)
2106 ureg->properties[i] = ~0;
2107
2108 ureg->free_temps = util_bitmask_create();
2109 if (ureg->free_temps == NULL)
2110 goto no_free_temps;
2111
2112 ureg->local_temps = util_bitmask_create();
2113 if (ureg->local_temps == NULL)
2114 goto no_local_temps;
2115
2116 ureg->decl_temps = util_bitmask_create();
2117 if (ureg->decl_temps == NULL)
2118 goto no_decl_temps;
2119
2120 return ureg;
2121
2122 no_decl_temps:
2123 util_bitmask_destroy(ureg->local_temps);
2124 no_local_temps:
2125 util_bitmask_destroy(ureg->free_temps);
2126 no_free_temps:
2127 FREE(ureg);
2128 no_ureg:
2129 return NULL;
2130 }
2131
2132
2133 void
2134 ureg_set_next_shader_processor(struct ureg_program *ureg, unsigned processor)
2135 {
2136 ureg->next_shader_processor = processor;
2137 }
2138
2139
2140 unsigned
2141 ureg_get_nr_outputs( const struct ureg_program *ureg )
2142 {
2143 if (!ureg)
2144 return 0;
2145 return ureg->nr_outputs;
2146 }
2147
2148
2149 void ureg_destroy( struct ureg_program *ureg )
2150 {
2151 unsigned i;
2152
2153 for (i = 0; i < ARRAY_SIZE(ureg->domain); i++) {
2154 if (ureg->domain[i].tokens &&
2155 ureg->domain[i].tokens != error_tokens)
2156 FREE(ureg->domain[i].tokens);
2157 }
2158
2159 util_bitmask_destroy(ureg->free_temps);
2160 util_bitmask_destroy(ureg->local_temps);
2161 util_bitmask_destroy(ureg->decl_temps);
2162
2163 FREE(ureg);
2164 }