projects / mesa.git / blob
? search:


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