projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
tgsi/scan: handle indirect image indexing correctly
[mesa.git] / src / gallium / auxiliary / tgsi / tgsi_ureg.h
1 /**************************************************************************
2 *
3 * Copyright 2009 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 #ifndef TGSI_UREG_H
29 #define TGSI_UREG_H
30
31 #include "pipe/p_compiler.h"
32 #include "pipe/p_shader_tokens.h"
33 #include "util/u_debug.h"
34
35 #ifdef __cplusplus
36 extern "C" {
37 #endif
38
39 struct pipe_screen;
40 struct ureg_program;
41 struct pipe_stream_output_info;
42
43 /* Almost a tgsi_src_register, but we need to pull in the Absolute
44 * flag from the _ext token. Indirect flag always implies ADDR[0].
45 */
46 struct ureg_src
47 {
48 unsigned File : 4; /* TGSI_FILE_ */
49 unsigned SwizzleX : 2; /* TGSI_SWIZZLE_ */
50 unsigned SwizzleY : 2; /* TGSI_SWIZZLE_ */
51 unsigned SwizzleZ : 2; /* TGSI_SWIZZLE_ */
52 unsigned SwizzleW : 2; /* TGSI_SWIZZLE_ */
53 unsigned Indirect : 1; /* BOOL */
54 unsigned DimIndirect : 1; /* BOOL */
55 unsigned Dimension : 1; /* BOOL */
56 unsigned Absolute : 1; /* BOOL */
57 unsigned Negate : 1; /* BOOL */
58 unsigned IndirectFile : 4; /* TGSI_FILE_ */
59 unsigned IndirectSwizzle : 2; /* TGSI_SWIZZLE_ */
60 unsigned DimIndFile : 4; /* TGSI_FILE_ */
61 unsigned DimIndSwizzle : 2; /* TGSI_SWIZZLE_ */
62 int Index : 16; /* SINT */
63 int IndirectIndex : 16; /* SINT */
64 int DimensionIndex : 16; /* SINT */
65 int DimIndIndex : 16; /* SINT */
66 unsigned ArrayID : 10; /* UINT */
67 };
68
69 /* Very similar to a tgsi_dst_register, removing unsupported fields
70 * and adding a Saturate flag. It's easier to push saturate into the
71 * destination register than to try and create a _SAT variant of each
72 * instruction function.
73 */
74 struct ureg_dst
75 {
76 unsigned File : 4; /* TGSI_FILE_ */
77 unsigned WriteMask : 4; /* TGSI_WRITEMASK_ */
78 unsigned Indirect : 1; /* BOOL */
79 unsigned DimIndirect : 1; /* BOOL */
80 unsigned Dimension : 1; /* BOOL */
81 unsigned Saturate : 1; /* BOOL */
82 unsigned Predicate : 1;
83 unsigned PredNegate : 1; /* BOOL */
84 unsigned PredSwizzleX : 2; /* TGSI_SWIZZLE_ */
85 unsigned PredSwizzleY : 2; /* TGSI_SWIZZLE_ */
86 unsigned PredSwizzleZ : 2; /* TGSI_SWIZZLE_ */
87 unsigned PredSwizzleW : 2; /* TGSI_SWIZZLE_ */
88 int Index : 16; /* SINT */
89 int IndirectIndex : 16; /* SINT */
90 unsigned IndirectFile : 4; /* TGSI_FILE_ */
91 int IndirectSwizzle : 2; /* TGSI_SWIZZLE_ */
92 unsigned DimIndFile : 4; /* TGSI_FILE_ */
93 unsigned DimIndSwizzle : 2; /* TGSI_SWIZZLE_ */
94 int DimensionIndex : 16; /* SINT */
95 int DimIndIndex : 16; /* SINT */
96 unsigned ArrayID : 10; /* UINT */
97 };
98
99 struct pipe_context;
100
101 struct ureg_program *
102 ureg_create(unsigned processor);
103
104 struct ureg_program *
105 ureg_create_with_screen(unsigned processor, struct pipe_screen *screen);
106
107 const struct tgsi_token *
108 ureg_finalize( struct ureg_program * );
109
110 /* Create and return a shader:
111 */
112 void *
113 ureg_create_shader( struct ureg_program *,
114 struct pipe_context *pipe,
115 const struct pipe_stream_output_info *so );
116
117 void
118 ureg_set_next_shader_processor(struct ureg_program *ureg, unsigned processor);
119
120 /* Alternately, return the built token stream and hand ownership of
121 * that memory to the caller:
122 */
123 const struct tgsi_token *
124 ureg_get_tokens( struct ureg_program *ureg,
125 unsigned *nr_tokens );
126
127 /*
128 * Returns the number of currently declared outputs.
129 */
130 unsigned
131 ureg_get_nr_outputs( const struct ureg_program *ureg );
132
133
134 /* Free the tokens created by ureg_get_tokens() */
135 void ureg_free_tokens( const struct tgsi_token *tokens );
136
137
138 void
139 ureg_destroy( struct ureg_program * );
140
141
142 /***********************************************************************
143 * Convenience routine:
144 */
145 static inline void *
146 ureg_create_shader_with_so_and_destroy( struct ureg_program *p,
147 struct pipe_context *pipe,
148 const struct pipe_stream_output_info *so )
149 {
150 void *result = ureg_create_shader( p, pipe, so );
151 ureg_destroy( p );
152 return result;
153 }
154
155 static inline void *
156 ureg_create_shader_and_destroy( struct ureg_program *p,
157 struct pipe_context *pipe )
158 {
159 return ureg_create_shader_with_so_and_destroy(p, pipe, NULL);
160 }
161
162
163 /***********************************************************************
164 * Build shader properties:
165 */
166
167 void
168 ureg_property(struct ureg_program *ureg, unsigned name, unsigned value);
169
170
171 /***********************************************************************
172 * Build shader declarations:
173 */
174
175 struct ureg_src
176 ureg_DECL_fs_input_cyl_centroid_layout(struct ureg_program *,
177 unsigned semantic_name,
178 unsigned semantic_index,
179 unsigned interp_mode,
180 unsigned cylindrical_wrap,
181 unsigned interp_location,
182 unsigned index,
183 unsigned usage_mask,
184 unsigned array_id,
185 unsigned array_size);
186
187 struct ureg_src
188 ureg_DECL_fs_input_cyl_centroid(struct ureg_program *,
189 unsigned semantic_name,
190 unsigned semantic_index,
191 unsigned interp_mode,
192 unsigned cylindrical_wrap,
193 unsigned interp_location,
194 unsigned array_id,
195 unsigned array_size);
196
197 static inline struct ureg_src
198 ureg_DECL_fs_input_cyl(struct ureg_program *ureg,
199 unsigned semantic_name,
200 unsigned semantic_index,
201 unsigned interp_mode,
202 unsigned cylindrical_wrap)
203 {
204 return ureg_DECL_fs_input_cyl_centroid(ureg,
205 semantic_name,
206 semantic_index,
207 interp_mode,
208 cylindrical_wrap,
209 0, 0, 1);
210 }
211
212 static inline struct ureg_src
213 ureg_DECL_fs_input(struct ureg_program *ureg,
214 unsigned semantic_name,
215 unsigned semantic_index,
216 unsigned interp_mode)
217 {
218 return ureg_DECL_fs_input_cyl_centroid(ureg,
219 semantic_name,
220 semantic_index,
221 interp_mode,
222 0, 0, 0, 1);
223 }
224
225 struct ureg_src
226 ureg_DECL_vs_input( struct ureg_program *,
227 unsigned index );
228
229 struct ureg_src
230 ureg_DECL_input_layout(struct ureg_program *,
231 unsigned semantic_name,
232 unsigned semantic_index,
233 unsigned index,
234 unsigned usage_mask,
235 unsigned array_id,
236 unsigned array_size);
237
238 struct ureg_src
239 ureg_DECL_input(struct ureg_program *,
240 unsigned semantic_name,
241 unsigned semantic_index,
242 unsigned array_id,
243 unsigned array_size);
244
245 struct ureg_src
246 ureg_DECL_system_value(struct ureg_program *,
247 unsigned semantic_name,
248 unsigned semantic_index);
249
250 struct ureg_dst
251 ureg_DECL_output_layout(struct ureg_program *,
252 unsigned semantic_name,
253 unsigned semantic_index,
254 unsigned index,
255 unsigned usage_mask,
256 unsigned array_id,
257 unsigned array_size);
258
259 struct ureg_dst
260 ureg_DECL_output_masked(struct ureg_program *,
261 unsigned semantic_name,
262 unsigned semantic_index,
263 unsigned usage_mask,
264 unsigned array_id,
265 unsigned array_size);
266
267 struct ureg_dst
268 ureg_DECL_output(struct ureg_program *,
269 unsigned semantic_name,
270 unsigned semantic_index);
271
272 struct ureg_dst
273 ureg_DECL_output_array(struct ureg_program *ureg,
274 unsigned semantic_name,
275 unsigned semantic_index,
276 unsigned array_id,
277 unsigned array_size);
278
279 struct ureg_src
280 ureg_DECL_immediate( struct ureg_program *,
281 const float *v,
282 unsigned nr );
283
284 struct ureg_src
285 ureg_DECL_immediate_f64( struct ureg_program *,
286 const double *v,
287 unsigned nr );
288
289 struct ureg_src
290 ureg_DECL_immediate_uint( struct ureg_program *,
291 const unsigned *v,
292 unsigned nr );
293
294 struct ureg_src
295 ureg_DECL_immediate_block_uint( struct ureg_program *,
296 const unsigned *v,
297 unsigned nr );
298
299 struct ureg_src
300 ureg_DECL_immediate_int( struct ureg_program *,
301 const int *v,
302 unsigned nr );
303
304 struct ureg_src
305 ureg_DECL_immediate_uint64( struct ureg_program *,
306 const uint64_t *v,
307 unsigned nr );
308
309 struct ureg_src
310 ureg_DECL_immediate_int64( struct ureg_program *,
311 const int64_t *v,
312 unsigned nr );
313
314 void
315 ureg_DECL_constant2D(struct ureg_program *ureg,
316 unsigned first,
317 unsigned last,
318 unsigned index2D);
319
320 struct ureg_src
321 ureg_DECL_constant( struct ureg_program *,
322 unsigned index );
323
324 struct ureg_dst
325 ureg_DECL_temporary( struct ureg_program * );
326
327 /**
328 * Emit a temporary with the LOCAL declaration flag set. For use when
329 * the register value is not required to be preserved across
330 * subroutine boundaries.
331 */
332 struct ureg_dst
333 ureg_DECL_local_temporary( struct ureg_program * );
334
335 /**
336 * Declare "size" continuous temporary registers.
337 */
338 struct ureg_dst
339 ureg_DECL_array_temporary( struct ureg_program *,
340 unsigned size,
341 boolean local );
342
343 void
344 ureg_release_temporary( struct ureg_program *ureg,
345 struct ureg_dst tmp );
346
347 struct ureg_dst
348 ureg_DECL_address( struct ureg_program * );
349
350 struct ureg_dst
351 ureg_DECL_predicate(struct ureg_program *);
352
353 /* Supply an index to the sampler declaration as this is the hook to
354 * the external pipe_sampler state. Users of this function probably
355 * don't want just any sampler, but a specific one which they've set
356 * up state for in the context.
357 */
358 struct ureg_src
359 ureg_DECL_sampler( struct ureg_program *,
360 unsigned index );
361
362 struct ureg_src
363 ureg_DECL_sampler_view(struct ureg_program *,
364 unsigned index,
365 unsigned target,
366 unsigned return_type_x,
367 unsigned return_type_y,
368 unsigned return_type_z,
369 unsigned return_type_w );
370
371 struct ureg_src
372 ureg_DECL_image(struct ureg_program *ureg,
373 unsigned index,
374 unsigned target,
375 unsigned format,
376 boolean wr,
377 boolean raw);
378
379 struct ureg_src
380 ureg_DECL_buffer(struct ureg_program *ureg, unsigned nr, bool atomic);
381
382 struct ureg_src
383 ureg_DECL_memory(struct ureg_program *ureg, unsigned memory_type);
384
385 static inline struct ureg_src
386 ureg_imm4f( struct ureg_program *ureg,
387 float a, float b,
388 float c, float d)
389 {
390 float v[4];
391 v[0] = a;
392 v[1] = b;
393 v[2] = c;
394 v[3] = d;
395 return ureg_DECL_immediate( ureg, v, 4 );
396 }
397
398 static inline struct ureg_src
399 ureg_imm3f( struct ureg_program *ureg,
400 float a, float b,
401 float c)
402 {
403 float v[3];
404 v[0] = a;
405 v[1] = b;
406 v[2] = c;
407 return ureg_DECL_immediate( ureg, v, 3 );
408 }
409
410 static inline struct ureg_src
411 ureg_imm2f( struct ureg_program *ureg,
412 float a, float b)
413 {
414 float v[2];
415 v[0] = a;
416 v[1] = b;
417 return ureg_DECL_immediate( ureg, v, 2 );
418 }
419
420 static inline struct ureg_src
421 ureg_imm1f( struct ureg_program *ureg,
422 float a)
423 {
424 float v[1];
425 v[0] = a;
426 return ureg_DECL_immediate( ureg, v, 1 );
427 }
428
429 static inline struct ureg_src
430 ureg_imm4u( struct ureg_program *ureg,
431 unsigned a, unsigned b,
432 unsigned c, unsigned d)
433 {
434 unsigned v[4];
435 v[0] = a;
436 v[1] = b;
437 v[2] = c;
438 v[3] = d;
439 return ureg_DECL_immediate_uint( ureg, v, 4 );
440 }
441
442 static inline struct ureg_src
443 ureg_imm3u( struct ureg_program *ureg,
444 unsigned a, unsigned b,
445 unsigned c)
446 {
447 unsigned v[3];
448 v[0] = a;
449 v[1] = b;
450 v[2] = c;
451 return ureg_DECL_immediate_uint( ureg, v, 3 );
452 }
453
454 static inline struct ureg_src
455 ureg_imm2u( struct ureg_program *ureg,
456 unsigned a, unsigned b)
457 {
458 unsigned v[2];
459 v[0] = a;
460 v[1] = b;
461 return ureg_DECL_immediate_uint( ureg, v, 2 );
462 }
463
464 static inline struct ureg_src
465 ureg_imm1u( struct ureg_program *ureg,
466 unsigned a)
467 {
468 return ureg_DECL_immediate_uint( ureg, &a, 1 );
469 }
470
471 static inline struct ureg_src
472 ureg_imm4i( struct ureg_program *ureg,
473 int a, int b,
474 int c, int d)
475 {
476 int v[4];
477 v[0] = a;
478 v[1] = b;
479 v[2] = c;
480 v[3] = d;
481 return ureg_DECL_immediate_int( ureg, v, 4 );
482 }
483
484 static inline struct ureg_src
485 ureg_imm3i( struct ureg_program *ureg,
486 int a, int b,
487 int c)
488 {
489 int v[3];
490 v[0] = a;
491 v[1] = b;
492 v[2] = c;
493 return ureg_DECL_immediate_int( ureg, v, 3 );
494 }
495
496 static inline struct ureg_src
497 ureg_imm2i( struct ureg_program *ureg,
498 int a, int b)
499 {
500 int v[2];
501 v[0] = a;
502 v[1] = b;
503 return ureg_DECL_immediate_int( ureg, v, 2 );
504 }
505
506 static inline struct ureg_src
507 ureg_imm1i( struct ureg_program *ureg,
508 int a)
509 {
510 return ureg_DECL_immediate_int( ureg, &a, 1 );
511 }
512
513 /* Where the destination register has a valid file, but an empty
514 * writemask.
515 */
516 static inline boolean
517 ureg_dst_is_empty( struct ureg_dst dst )
518 {
519 return dst.File != TGSI_FILE_NULL &&
520 dst.WriteMask == 0;
521 }
522
523 /***********************************************************************
524 * Functions for patching up labels
525 */
526
527
528 /* Will return a number which can be used in a label to point to the
529 * next instruction to be emitted.
530 */
531 unsigned
532 ureg_get_instruction_number( struct ureg_program *ureg );
533
534
535 /* Patch a given label (expressed as a token number) to point to a
536 * given instruction (expressed as an instruction number).
537 *
538 * Labels are obtained from instruction emitters, eg ureg_CAL().
539 * Instruction numbers are obtained from ureg_get_instruction_number(),
540 * above.
541 */
542 void
543 ureg_fixup_label(struct ureg_program *ureg,
544 unsigned label_token,
545 unsigned instruction_number );
546
547
548 /* Generic instruction emitter. Use if you need to pass the opcode as
549 * a parameter, rather than using the emit_OP() variants below.
550 */
551 void
552 ureg_insn(struct ureg_program *ureg,
553 unsigned opcode,
554 const struct ureg_dst *dst,
555 unsigned nr_dst,
556 const struct ureg_src *src,
557 unsigned nr_src );
558
559
560 void
561 ureg_tex_insn(struct ureg_program *ureg,
562 unsigned opcode,
563 const struct ureg_dst *dst,
564 unsigned nr_dst,
565 unsigned target,
566 const struct tgsi_texture_offset *texoffsets,
567 unsigned nr_offset,
568 const struct ureg_src *src,
569 unsigned nr_src );
570
571
572 void
573 ureg_label_insn(struct ureg_program *ureg,
574 unsigned opcode,
575 const struct ureg_src *src,
576 unsigned nr_src,
577 unsigned *label);
578
579 void
580 ureg_memory_insn(struct ureg_program *ureg,
581 unsigned opcode,
582 const struct ureg_dst *dst,
583 unsigned nr_dst,
584 const struct ureg_src *src,
585 unsigned nr_src,
586 unsigned qualifier,
587 unsigned texture,
588 unsigned format);
589
590 /***********************************************************************
591 * Internal instruction helpers, don't call these directly:
592 */
593
594 struct ureg_emit_insn_result {
595 unsigned insn_token; /*< Used to fixup insn size. */
596 unsigned extended_token; /*< Used to set the Extended bit, usually the same as insn_token. */
597 };
598
599 struct ureg_emit_insn_result
600 ureg_emit_insn(struct ureg_program *ureg,
601 unsigned opcode,
602 boolean saturate,
603 boolean predicate,
604 boolean pred_negate,
605 unsigned pred_swizzle_x,
606 unsigned pred_swizzle_y,
607 unsigned pred_swizzle_z,
608 unsigned pred_swizzle_w,
609 unsigned num_dst,
610 unsigned num_src );
611
612 void
613 ureg_emit_label(struct ureg_program *ureg,
614 unsigned insn_token,
615 unsigned *label_token );
616
617 void
618 ureg_emit_texture(struct ureg_program *ureg,
619 unsigned insn_token,
620 unsigned target, unsigned num_offsets);
621
622 void
623 ureg_emit_texture_offset(struct ureg_program *ureg,
624 const struct tgsi_texture_offset *offset);
625
626 void
627 ureg_emit_memory(struct ureg_program *ureg,
628 unsigned insn_token,
629 unsigned qualifier,
630 unsigned texture,
631 unsigned format);
632
633 void
634 ureg_emit_dst( struct ureg_program *ureg,
635 struct ureg_dst dst );
636
637 void
638 ureg_emit_src( struct ureg_program *ureg,
639 struct ureg_src src );
640
641 void
642 ureg_fixup_insn_size(struct ureg_program *ureg,
643 unsigned insn );
644
645
646 #define OP00( op ) \
647 static inline void ureg_##op( struct ureg_program *ureg ) \
648 { \
649 unsigned opcode = TGSI_OPCODE_##op; \
650 struct ureg_emit_insn_result insn; \
651 insn = ureg_emit_insn(ureg, \
652 opcode, \
653 FALSE, \
654 FALSE, \
655 FALSE, \
656 TGSI_SWIZZLE_X, \
657 TGSI_SWIZZLE_Y, \
658 TGSI_SWIZZLE_Z, \
659 TGSI_SWIZZLE_W, \
660 0, \
661 0); \
662 ureg_fixup_insn_size( ureg, insn.insn_token ); \
663 }
664
665 #define OP01( op ) \
666 static inline void ureg_##op( struct ureg_program *ureg, \
667 struct ureg_src src ) \
668 { \
669 unsigned opcode = TGSI_OPCODE_##op; \
670 struct ureg_emit_insn_result insn; \
671 insn = ureg_emit_insn(ureg, \
672 opcode, \
673 FALSE, \
674 FALSE, \
675 FALSE, \
676 TGSI_SWIZZLE_X, \
677 TGSI_SWIZZLE_Y, \
678 TGSI_SWIZZLE_Z, \
679 TGSI_SWIZZLE_W, \
680 0, \
681 1); \
682 ureg_emit_src( ureg, src ); \
683 ureg_fixup_insn_size( ureg, insn.insn_token ); \
684 }
685
686 #define OP00_LBL( op ) \
687 static inline void ureg_##op( struct ureg_program *ureg, \
688 unsigned *label_token ) \
689 { \
690 unsigned opcode = TGSI_OPCODE_##op; \
691 struct ureg_emit_insn_result insn; \
692 insn = ureg_emit_insn(ureg, \
693 opcode, \
694 FALSE, \
695 FALSE, \
696 FALSE, \
697 TGSI_SWIZZLE_X, \
698 TGSI_SWIZZLE_Y, \
699 TGSI_SWIZZLE_Z, \
700 TGSI_SWIZZLE_W, \
701 0, \
702 0); \
703 ureg_emit_label( ureg, insn.extended_token, label_token ); \
704 ureg_fixup_insn_size( ureg, insn.insn_token ); \
705 }
706
707 #define OP01_LBL( op ) \
708 static inline void ureg_##op( struct ureg_program *ureg, \
709 struct ureg_src src, \
710 unsigned *label_token ) \
711 { \
712 unsigned opcode = TGSI_OPCODE_##op; \
713 struct ureg_emit_insn_result insn; \
714 insn = ureg_emit_insn(ureg, \
715 opcode, \
716 FALSE, \
717 FALSE, \
718 FALSE, \
719 TGSI_SWIZZLE_X, \
720 TGSI_SWIZZLE_Y, \
721 TGSI_SWIZZLE_Z, \
722 TGSI_SWIZZLE_W, \
723 0, \
724 1); \
725 ureg_emit_label( ureg, insn.extended_token, label_token ); \
726 ureg_emit_src( ureg, src ); \
727 ureg_fixup_insn_size( ureg, insn.insn_token ); \
728 }
729
730 #define OP10( op ) \
731 static inline void ureg_##op( struct ureg_program *ureg, \
732 struct ureg_dst dst ) \
733 { \
734 unsigned opcode = TGSI_OPCODE_##op; \
735 struct ureg_emit_insn_result insn; \
736 if (ureg_dst_is_empty(dst)) \
737 return; \
738 insn = ureg_emit_insn(ureg, \
739 opcode, \
740 dst.Saturate, \
741 dst.Predicate, \
742 dst.PredNegate, \
743 dst.PredSwizzleX, \
744 dst.PredSwizzleY, \
745 dst.PredSwizzleZ, \
746 dst.PredSwizzleW, \
747 1, \
748 0); \
749 ureg_emit_dst( ureg, dst ); \
750 ureg_fixup_insn_size( ureg, insn.insn_token ); \
751 }
752
753
754 #define OP11( op ) \
755 static inline void ureg_##op( struct ureg_program *ureg, \
756 struct ureg_dst dst, \
757 struct ureg_src src ) \
758 { \
759 unsigned opcode = TGSI_OPCODE_##op; \
760 struct ureg_emit_insn_result insn; \
761 if (ureg_dst_is_empty(dst)) \
762 return; \
763 insn = ureg_emit_insn(ureg, \
764 opcode, \
765 dst.Saturate, \
766 dst.Predicate, \
767 dst.PredNegate, \
768 dst.PredSwizzleX, \
769 dst.PredSwizzleY, \
770 dst.PredSwizzleZ, \
771 dst.PredSwizzleW, \
772 1, \
773 1); \
774 ureg_emit_dst( ureg, dst ); \
775 ureg_emit_src( ureg, src ); \
776 ureg_fixup_insn_size( ureg, insn.insn_token ); \
777 }
778
779 #define OP12( op ) \
780 static inline void ureg_##op( struct ureg_program *ureg, \
781 struct ureg_dst dst, \
782 struct ureg_src src0, \
783 struct ureg_src src1 ) \
784 { \
785 unsigned opcode = TGSI_OPCODE_##op; \
786 struct ureg_emit_insn_result insn; \
787 if (ureg_dst_is_empty(dst)) \
788 return; \
789 insn = ureg_emit_insn(ureg, \
790 opcode, \
791 dst.Saturate, \
792 dst.Predicate, \
793 dst.PredNegate, \
794 dst.PredSwizzleX, \
795 dst.PredSwizzleY, \
796 dst.PredSwizzleZ, \
797 dst.PredSwizzleW, \
798 1, \
799 2); \
800 ureg_emit_dst( ureg, dst ); \
801 ureg_emit_src( ureg, src0 ); \
802 ureg_emit_src( ureg, src1 ); \
803 ureg_fixup_insn_size( ureg, insn.insn_token ); \
804 }
805
806 #define OP12_TEX( op ) \
807 static inline void ureg_##op( struct ureg_program *ureg, \
808 struct ureg_dst dst, \
809 unsigned target, \
810 struct ureg_src src0, \
811 struct ureg_src src1 ) \
812 { \
813 unsigned opcode = TGSI_OPCODE_##op; \
814 struct ureg_emit_insn_result insn; \
815 if (ureg_dst_is_empty(dst)) \
816 return; \
817 insn = ureg_emit_insn(ureg, \
818 opcode, \
819 dst.Saturate, \
820 dst.Predicate, \
821 dst.PredNegate, \
822 dst.PredSwizzleX, \
823 dst.PredSwizzleY, \
824 dst.PredSwizzleZ, \
825 dst.PredSwizzleW, \
826 1, \
827 2); \
828 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
829 ureg_emit_dst( ureg, dst ); \
830 ureg_emit_src( ureg, src0 ); \
831 ureg_emit_src( ureg, src1 ); \
832 ureg_fixup_insn_size( ureg, insn.insn_token ); \
833 }
834
835 #define OP12_SAMPLE( op ) \
836 static inline void ureg_##op( struct ureg_program *ureg, \
837 struct ureg_dst dst, \
838 struct ureg_src src0, \
839 struct ureg_src src1 ) \
840 { \
841 unsigned opcode = TGSI_OPCODE_##op; \
842 unsigned target = TGSI_TEXTURE_UNKNOWN; \
843 struct ureg_emit_insn_result insn; \
844 if (ureg_dst_is_empty(dst)) \
845 return; \
846 insn = ureg_emit_insn(ureg, \
847 opcode, \
848 dst.Saturate, \
849 dst.Predicate, \
850 dst.PredNegate, \
851 dst.PredSwizzleX, \
852 dst.PredSwizzleY, \
853 dst.PredSwizzleZ, \
854 dst.PredSwizzleW, \
855 1, \
856 2); \
857 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
858 ureg_emit_dst( ureg, dst ); \
859 ureg_emit_src( ureg, src0 ); \
860 ureg_emit_src( ureg, src1 ); \
861 ureg_fixup_insn_size( ureg, insn.insn_token ); \
862 }
863
864 #define OP13( op ) \
865 static inline void ureg_##op( struct ureg_program *ureg, \
866 struct ureg_dst dst, \
867 struct ureg_src src0, \
868 struct ureg_src src1, \
869 struct ureg_src src2 ) \
870 { \
871 unsigned opcode = TGSI_OPCODE_##op; \
872 struct ureg_emit_insn_result insn; \
873 if (ureg_dst_is_empty(dst)) \
874 return; \
875 insn = ureg_emit_insn(ureg, \
876 opcode, \
877 dst.Saturate, \
878 dst.Predicate, \
879 dst.PredNegate, \
880 dst.PredSwizzleX, \
881 dst.PredSwizzleY, \
882 dst.PredSwizzleZ, \
883 dst.PredSwizzleW, \
884 1, \
885 3); \
886 ureg_emit_dst( ureg, dst ); \
887 ureg_emit_src( ureg, src0 ); \
888 ureg_emit_src( ureg, src1 ); \
889 ureg_emit_src( ureg, src2 ); \
890 ureg_fixup_insn_size( ureg, insn.insn_token ); \
891 }
892
893 #define OP13_SAMPLE( op ) \
894 static inline void ureg_##op( struct ureg_program *ureg, \
895 struct ureg_dst dst, \
896 struct ureg_src src0, \
897 struct ureg_src src1, \
898 struct ureg_src src2 ) \
899 { \
900 unsigned opcode = TGSI_OPCODE_##op; \
901 unsigned target = TGSI_TEXTURE_UNKNOWN; \
902 struct ureg_emit_insn_result insn; \
903 if (ureg_dst_is_empty(dst)) \
904 return; \
905 insn = ureg_emit_insn(ureg, \
906 opcode, \
907 dst.Saturate, \
908 dst.Predicate, \
909 dst.PredNegate, \
910 dst.PredSwizzleX, \
911 dst.PredSwizzleY, \
912 dst.PredSwizzleZ, \
913 dst.PredSwizzleW, \
914 1, \
915 3); \
916 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
917 ureg_emit_dst( ureg, dst ); \
918 ureg_emit_src( ureg, src0 ); \
919 ureg_emit_src( ureg, src1 ); \
920 ureg_emit_src( ureg, src2 ); \
921 ureg_fixup_insn_size( ureg, insn.insn_token ); \
922 }
923
924 #define OP14_TEX( op ) \
925 static inline void ureg_##op( struct ureg_program *ureg, \
926 struct ureg_dst dst, \
927 unsigned target, \
928 struct ureg_src src0, \
929 struct ureg_src src1, \
930 struct ureg_src src2, \
931 struct ureg_src src3 ) \
932 { \
933 unsigned opcode = TGSI_OPCODE_##op; \
934 struct ureg_emit_insn_result insn; \
935 if (ureg_dst_is_empty(dst)) \
936 return; \
937 insn = ureg_emit_insn(ureg, \
938 opcode, \
939 dst.Saturate, \
940 dst.Predicate, \
941 dst.PredNegate, \
942 dst.PredSwizzleX, \
943 dst.PredSwizzleY, \
944 dst.PredSwizzleZ, \
945 dst.PredSwizzleW, \
946 1, \
947 4); \
948 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
949 ureg_emit_dst( ureg, dst ); \
950 ureg_emit_src( ureg, src0 ); \
951 ureg_emit_src( ureg, src1 ); \
952 ureg_emit_src( ureg, src2 ); \
953 ureg_emit_src( ureg, src3 ); \
954 ureg_fixup_insn_size( ureg, insn.insn_token ); \
955 }
956
957 #define OP14_SAMPLE( op ) \
958 static inline void ureg_##op( struct ureg_program *ureg, \
959 struct ureg_dst dst, \
960 struct ureg_src src0, \
961 struct ureg_src src1, \
962 struct ureg_src src2, \
963 struct ureg_src src3 ) \
964 { \
965 unsigned opcode = TGSI_OPCODE_##op; \
966 unsigned target = TGSI_TEXTURE_UNKNOWN; \
967 struct ureg_emit_insn_result insn; \
968 if (ureg_dst_is_empty(dst)) \
969 return; \
970 insn = ureg_emit_insn(ureg, \
971 opcode, \
972 dst.Saturate, \
973 dst.Predicate, \
974 dst.PredNegate, \
975 dst.PredSwizzleX, \
976 dst.PredSwizzleY, \
977 dst.PredSwizzleZ, \
978 dst.PredSwizzleW, \
979 1, \
980 4); \
981 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
982 ureg_emit_dst( ureg, dst ); \
983 ureg_emit_src( ureg, src0 ); \
984 ureg_emit_src( ureg, src1 ); \
985 ureg_emit_src( ureg, src2 ); \
986 ureg_emit_src( ureg, src3 ); \
987 ureg_fixup_insn_size( ureg, insn.insn_token ); \
988 }
989
990
991 #define OP14( op ) \
992 static inline void ureg_##op( struct ureg_program *ureg, \
993 struct ureg_dst dst, \
994 struct ureg_src src0, \
995 struct ureg_src src1, \
996 struct ureg_src src2, \
997 struct ureg_src src3 ) \
998 { \
999 unsigned opcode = TGSI_OPCODE_##op; \
1000 struct ureg_emit_insn_result insn; \
1001 if (ureg_dst_is_empty(dst)) \
1002 return; \
1003 insn = ureg_emit_insn(ureg, \
1004 opcode, \
1005 dst.Saturate, \
1006 dst.Predicate, \
1007 dst.PredNegate, \
1008 dst.PredSwizzleX, \
1009 dst.PredSwizzleY, \
1010 dst.PredSwizzleZ, \
1011 dst.PredSwizzleW, \
1012 1, \
1013 4); \
1014 ureg_emit_dst( ureg, dst ); \
1015 ureg_emit_src( ureg, src0 ); \
1016 ureg_emit_src( ureg, src1 ); \
1017 ureg_emit_src( ureg, src2 ); \
1018 ureg_emit_src( ureg, src3 ); \
1019 ureg_fixup_insn_size( ureg, insn.insn_token ); \
1020 }
1021
1022
1023 #define OP15( op ) \
1024 static inline void ureg_##op( struct ureg_program *ureg, \
1025 struct ureg_dst dst, \
1026 struct ureg_src src0, \
1027 struct ureg_src src1, \
1028 struct ureg_src src2, \
1029 struct ureg_src src3, \
1030 struct ureg_src src4 ) \
1031 { \
1032 unsigned opcode = TGSI_OPCODE_##op; \
1033 struct ureg_emit_insn_result insn; \
1034 if (ureg_dst_is_empty(dst)) \
1035 return; \
1036 insn = ureg_emit_insn(ureg, \
1037 opcode, \
1038 dst.Saturate, \
1039 dst.Predicate, \
1040 dst.PredNegate, \
1041 dst.PredSwizzleX, \
1042 dst.PredSwizzleY, \
1043 dst.PredSwizzleZ, \
1044 dst.PredSwizzleW, \
1045 1, \
1046 5); \
1047 ureg_emit_dst( ureg, dst ); \
1048 ureg_emit_src( ureg, src0 ); \
1049 ureg_emit_src( ureg, src1 ); \
1050 ureg_emit_src( ureg, src2 ); \
1051 ureg_emit_src( ureg, src3 ); \
1052 ureg_emit_src( ureg, src4 ); \
1053 ureg_fixup_insn_size( ureg, insn.insn_token ); \
1054 }
1055
1056 #define OP15_SAMPLE( op ) \
1057 static inline void ureg_##op( struct ureg_program *ureg, \
1058 struct ureg_dst dst, \
1059 struct ureg_src src0, \
1060 struct ureg_src src1, \
1061 struct ureg_src src2, \
1062 struct ureg_src src3, \
1063 struct ureg_src src4 ) \
1064 { \
1065 unsigned opcode = TGSI_OPCODE_##op; \
1066 unsigned target = TGSI_TEXTURE_UNKNOWN; \
1067 struct ureg_emit_insn_result insn; \
1068 if (ureg_dst_is_empty(dst)) \
1069 return; \
1070 insn = ureg_emit_insn(ureg, \
1071 opcode, \
1072 dst.Saturate, \
1073 dst.Predicate, \
1074 dst.PredNegate, \
1075 dst.PredSwizzleX, \
1076 dst.PredSwizzleY, \
1077 dst.PredSwizzleZ, \
1078 dst.PredSwizzleW, \
1079 1, \
1080 5); \
1081 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
1082 ureg_emit_dst( ureg, dst ); \
1083 ureg_emit_src( ureg, src0 ); \
1084 ureg_emit_src( ureg, src1 ); \
1085 ureg_emit_src( ureg, src2 ); \
1086 ureg_emit_src( ureg, src3 ); \
1087 ureg_emit_src( ureg, src4 ); \
1088 ureg_fixup_insn_size( ureg, insn.insn_token ); \
1089 }
1090
1091 /* Use a template include to generate a correctly-typed ureg_OP()
1092 * function for each TGSI opcode:
1093 */
1094 #include "tgsi_opcode_tmp.h"
1095
1096
1097 /***********************************************************************
1098 * Inline helpers for manipulating register structs:
1099 */
1100 static inline struct ureg_src
1101 ureg_negate( struct ureg_src reg )
1102 {
1103 assert(reg.File != TGSI_FILE_NULL);
1104 reg.Negate ^= 1;
1105 return reg;
1106 }
1107
1108 static inline struct ureg_src
1109 ureg_abs( struct ureg_src reg )
1110 {
1111 assert(reg.File != TGSI_FILE_NULL);
1112 reg.Absolute = 1;
1113 reg.Negate = 0;
1114 return reg;
1115 }
1116
1117 static inline struct ureg_src
1118 ureg_swizzle( struct ureg_src reg,
1119 int x, int y, int z, int w )
1120 {
1121 unsigned swz = ( (reg.SwizzleX << 0) |
1122 (reg.SwizzleY << 2) |
1123 (reg.SwizzleZ << 4) |
1124 (reg.SwizzleW << 6));
1125
1126 assert(reg.File != TGSI_FILE_NULL);
1127 assert(x < 4);
1128 assert(y < 4);
1129 assert(z < 4);
1130 assert(w < 4);
1131
1132 reg.SwizzleX = (swz >> (x*2)) & 0x3;
1133 reg.SwizzleY = (swz >> (y*2)) & 0x3;
1134 reg.SwizzleZ = (swz >> (z*2)) & 0x3;
1135 reg.SwizzleW = (swz >> (w*2)) & 0x3;
1136 return reg;
1137 }
1138
1139 static inline struct ureg_src
1140 ureg_scalar( struct ureg_src reg, int x )
1141 {
1142 return ureg_swizzle(reg, x, x, x, x);
1143 }
1144
1145 static inline struct ureg_dst
1146 ureg_writemask( struct ureg_dst reg,
1147 unsigned writemask )
1148 {
1149 assert(reg.File != TGSI_FILE_NULL);
1150 reg.WriteMask &= writemask;
1151 return reg;
1152 }
1153
1154 static inline struct ureg_dst
1155 ureg_saturate( struct ureg_dst reg )
1156 {
1157 assert(reg.File != TGSI_FILE_NULL);
1158 reg.Saturate = 1;
1159 return reg;
1160 }
1161
1162 static inline struct ureg_dst
1163 ureg_predicate(struct ureg_dst reg,
1164 boolean negate,
1165 unsigned swizzle_x,
1166 unsigned swizzle_y,
1167 unsigned swizzle_z,
1168 unsigned swizzle_w)
1169 {
1170 assert(reg.File != TGSI_FILE_NULL);
1171 reg.Predicate = 1;
1172 reg.PredNegate = negate;
1173 reg.PredSwizzleX = swizzle_x;
1174 reg.PredSwizzleY = swizzle_y;
1175 reg.PredSwizzleZ = swizzle_z;
1176 reg.PredSwizzleW = swizzle_w;
1177 return reg;
1178 }
1179
1180 static inline struct ureg_dst
1181 ureg_dst_indirect( struct ureg_dst reg, struct ureg_src addr )
1182 {
1183 assert(reg.File != TGSI_FILE_NULL);
1184 assert(addr.File == TGSI_FILE_ADDRESS || addr.File == TGSI_FILE_TEMPORARY);
1185 reg.Indirect = 1;
1186 reg.IndirectFile = addr.File;
1187 reg.IndirectIndex = addr.Index;
1188 reg.IndirectSwizzle = addr.SwizzleX;
1189 return reg;
1190 }
1191
1192 static inline struct ureg_src
1193 ureg_src_indirect( struct ureg_src reg, struct ureg_src addr )
1194 {
1195 assert(reg.File != TGSI_FILE_NULL);
1196 assert(addr.File == TGSI_FILE_ADDRESS || addr.File == TGSI_FILE_TEMPORARY);
1197 reg.Indirect = 1;
1198 reg.IndirectFile = addr.File;
1199 reg.IndirectIndex = addr.Index;
1200 reg.IndirectSwizzle = addr.SwizzleX;
1201 return reg;
1202 }
1203
1204 static inline struct ureg_dst
1205 ureg_dst_dimension( struct ureg_dst reg, int index )
1206 {
1207 assert(reg.File != TGSI_FILE_NULL);
1208 reg.Dimension = 1;
1209 reg.DimIndirect = 0;
1210 reg.DimensionIndex = index;
1211 return reg;
1212 }
1213
1214 static inline struct ureg_src
1215 ureg_src_dimension( struct ureg_src reg, int index )
1216 {
1217 assert(reg.File != TGSI_FILE_NULL);
1218 reg.Dimension = 1;
1219 reg.DimIndirect = 0;
1220 reg.DimensionIndex = index;
1221 return reg;
1222 }
1223
1224 static inline struct ureg_dst
1225 ureg_dst_dimension_indirect( struct ureg_dst reg, struct ureg_src addr,
1226 int index )
1227 {
1228 assert(reg.File != TGSI_FILE_NULL);
1229 reg.Dimension = 1;
1230 reg.DimIndirect = 1;
1231 reg.DimensionIndex = index;
1232 reg.DimIndFile = addr.File;
1233 reg.DimIndIndex = addr.Index;
1234 reg.DimIndSwizzle = addr.SwizzleX;
1235 return reg;
1236 }
1237
1238 static inline struct ureg_src
1239 ureg_src_dimension_indirect( struct ureg_src reg, struct ureg_src addr,
1240 int index )
1241 {
1242 assert(reg.File != TGSI_FILE_NULL);
1243 reg.Dimension = 1;
1244 reg.DimIndirect = 1;
1245 reg.DimensionIndex = index;
1246 reg.DimIndFile = addr.File;
1247 reg.DimIndIndex = addr.Index;
1248 reg.DimIndSwizzle = addr.SwizzleX;
1249 return reg;
1250 }
1251
1252 static inline struct ureg_src
1253 ureg_src_array_offset(struct ureg_src reg, int offset)
1254 {
1255 reg.Index += offset;
1256 return reg;
1257 }
1258
1259 static inline struct ureg_dst
1260 ureg_dst_array_offset( struct ureg_dst reg, int offset )
1261 {
1262 reg.Index += offset;
1263 return reg;
1264 }
1265
1266 static inline struct ureg_dst
1267 ureg_dst_array_register(unsigned file,
1268 unsigned index,
1269 unsigned array_id)
1270 {
1271 struct ureg_dst dst;
1272
1273 dst.File = file;
1274 dst.WriteMask = TGSI_WRITEMASK_XYZW;
1275 dst.Indirect = 0;
1276 dst.IndirectFile = TGSI_FILE_NULL;
1277 dst.IndirectIndex = 0;
1278 dst.IndirectSwizzle = 0;
1279 dst.Saturate = 0;
1280 dst.Predicate = 0;
1281 dst.PredNegate = 0;
1282 dst.PredSwizzleX = TGSI_SWIZZLE_X;
1283 dst.PredSwizzleY = TGSI_SWIZZLE_Y;
1284 dst.PredSwizzleZ = TGSI_SWIZZLE_Z;
1285 dst.PredSwizzleW = TGSI_SWIZZLE_W;
1286 dst.Index = index;
1287 dst.Dimension = 0;
1288 dst.DimensionIndex = 0;
1289 dst.DimIndirect = 0;
1290 dst.DimIndFile = TGSI_FILE_NULL;
1291 dst.DimIndIndex = 0;
1292 dst.DimIndSwizzle = 0;
1293 dst.ArrayID = array_id;
1294
1295 return dst;
1296 }
1297
1298 static inline struct ureg_dst
1299 ureg_dst_register(unsigned file,
1300 unsigned index)
1301 {
1302 return ureg_dst_array_register(file, index, 0);
1303 }
1304
1305 static inline struct ureg_dst
1306 ureg_dst( struct ureg_src src )
1307 {
1308 struct ureg_dst dst;
1309
1310 assert(!src.Indirect ||
1311 (src.IndirectFile == TGSI_FILE_ADDRESS ||
1312 src.IndirectFile == TGSI_FILE_TEMPORARY));
1313
1314 dst.File = src.File;
1315 dst.WriteMask = TGSI_WRITEMASK_XYZW;
1316 dst.IndirectFile = src.IndirectFile;
1317 dst.Indirect = src.Indirect;
1318 dst.IndirectIndex = src.IndirectIndex;
1319 dst.IndirectSwizzle = src.IndirectSwizzle;
1320 dst.Saturate = 0;
1321 dst.Predicate = 0;
1322 dst.PredNegate = 0;
1323 dst.PredSwizzleX = TGSI_SWIZZLE_X;
1324 dst.PredSwizzleY = TGSI_SWIZZLE_Y;
1325 dst.PredSwizzleZ = TGSI_SWIZZLE_Z;
1326 dst.PredSwizzleW = TGSI_SWIZZLE_W;
1327 dst.Index = src.Index;
1328 dst.Dimension = src.Dimension;
1329 dst.DimensionIndex = src.DimensionIndex;
1330 dst.DimIndirect = src.DimIndirect;
1331 dst.DimIndFile = src.DimIndFile;
1332 dst.DimIndIndex = src.DimIndIndex;
1333 dst.DimIndSwizzle = src.DimIndSwizzle;
1334 dst.ArrayID = src.ArrayID;
1335
1336 return dst;
1337 }
1338
1339 static inline struct ureg_src
1340 ureg_src_array_register(unsigned file,
1341 unsigned index,
1342 unsigned array_id)
1343 {
1344 struct ureg_src src;
1345
1346 src.File = file;
1347 src.SwizzleX = TGSI_SWIZZLE_X;
1348 src.SwizzleY = TGSI_SWIZZLE_Y;
1349 src.SwizzleZ = TGSI_SWIZZLE_Z;
1350 src.SwizzleW = TGSI_SWIZZLE_W;
1351 src.Indirect = 0;
1352 src.IndirectFile = TGSI_FILE_NULL;
1353 src.IndirectIndex = 0;
1354 src.IndirectSwizzle = 0;
1355 src.Absolute = 0;
1356 src.Index = index;
1357 src.Negate = 0;
1358 src.Dimension = 0;
1359 src.DimensionIndex = 0;
1360 src.DimIndirect = 0;
1361 src.DimIndFile = TGSI_FILE_NULL;
1362 src.DimIndIndex = 0;
1363 src.DimIndSwizzle = 0;
1364 src.ArrayID = array_id;
1365
1366 return src;
1367 }
1368
1369 static inline struct ureg_src
1370 ureg_src_register(unsigned file,
1371 unsigned index)
1372 {
1373 return ureg_src_array_register(file, index, 0);
1374 }
1375
1376 static inline struct ureg_src
1377 ureg_src( struct ureg_dst dst )
1378 {
1379 struct ureg_src src;
1380
1381 src.File = dst.File;
1382 src.SwizzleX = TGSI_SWIZZLE_X;
1383 src.SwizzleY = TGSI_SWIZZLE_Y;
1384 src.SwizzleZ = TGSI_SWIZZLE_Z;
1385 src.SwizzleW = TGSI_SWIZZLE_W;
1386 src.Indirect = dst.Indirect;
1387 src.IndirectFile = dst.IndirectFile;
1388 src.IndirectIndex = dst.IndirectIndex;
1389 src.IndirectSwizzle = dst.IndirectSwizzle;
1390 src.Absolute = 0;
1391 src.Index = dst.Index;
1392 src.Negate = 0;
1393 src.Dimension = dst.Dimension;
1394 src.DimensionIndex = dst.DimensionIndex;
1395 src.DimIndirect = dst.DimIndirect;
1396 src.DimIndFile = dst.DimIndFile;
1397 src.DimIndIndex = dst.DimIndIndex;
1398 src.DimIndSwizzle = dst.DimIndSwizzle;
1399 src.ArrayID = dst.ArrayID;
1400
1401 return src;
1402 }
1403
1404
1405
1406 static inline struct ureg_dst
1407 ureg_dst_undef( void )
1408 {
1409 struct ureg_dst dst;
1410
1411 dst.File = TGSI_FILE_NULL;
1412 dst.WriteMask = 0;
1413 dst.Indirect = 0;
1414 dst.IndirectFile = TGSI_FILE_NULL;
1415 dst.IndirectIndex = 0;
1416 dst.IndirectSwizzle = 0;
1417 dst.Saturate = 0;
1418 dst.Predicate = 0;
1419 dst.PredNegate = 0;
1420 dst.PredSwizzleX = TGSI_SWIZZLE_X;
1421 dst.PredSwizzleY = TGSI_SWIZZLE_Y;
1422 dst.PredSwizzleZ = TGSI_SWIZZLE_Z;
1423 dst.PredSwizzleW = TGSI_SWIZZLE_W;
1424 dst.Index = 0;
1425 dst.Dimension = 0;
1426 dst.DimensionIndex = 0;
1427 dst.DimIndirect = 0;
1428 dst.DimIndFile = TGSI_FILE_NULL;
1429 dst.DimIndIndex = 0;
1430 dst.DimIndSwizzle = 0;
1431 dst.ArrayID = 0;
1432
1433 return dst;
1434 }
1435
1436 static inline struct ureg_src
1437 ureg_src_undef( void )
1438 {
1439 struct ureg_src src;
1440
1441 src.File = TGSI_FILE_NULL;
1442 src.SwizzleX = 0;
1443 src.SwizzleY = 0;
1444 src.SwizzleZ = 0;
1445 src.SwizzleW = 0;
1446 src.Indirect = 0;
1447 src.IndirectFile = TGSI_FILE_NULL;
1448 src.IndirectIndex = 0;
1449 src.IndirectSwizzle = 0;
1450 src.Absolute = 0;
1451 src.Index = 0;
1452 src.Negate = 0;
1453 src.Dimension = 0;
1454 src.DimensionIndex = 0;
1455 src.DimIndirect = 0;
1456 src.DimIndFile = TGSI_FILE_NULL;
1457 src.DimIndIndex = 0;
1458 src.DimIndSwizzle = 0;
1459 src.ArrayID = 0;
1460
1461 return src;
1462 }
1463
1464 static inline boolean
1465 ureg_src_is_undef( struct ureg_src src )
1466 {
1467 return src.File == TGSI_FILE_NULL;
1468 }
1469
1470 static inline boolean
1471 ureg_dst_is_undef( struct ureg_dst dst )
1472 {
1473 return dst.File == TGSI_FILE_NULL;
1474 }
1475
1476
1477 #ifdef __cplusplus
1478 }
1479 #endif
1480
1481 #endif