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