projects / mesa.git / blob
? search:


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