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