projects / mesa.git / blob
? search:


6a3b5ddf0178ce2adc353f4c74b20367f9262724
[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
546 /***********************************************************************
547 * Internal instruction helpers, don't call these directly:
548 */
549
550 struct ureg_emit_insn_result {
551 unsigned insn_token; /*< Used to fixup insn size. */
552 unsigned extended_token; /*< Used to set the Extended bit, usually the same as insn_token. */
553 };
554
555 struct ureg_emit_insn_result
556 ureg_emit_insn(struct ureg_program *ureg,
557 unsigned opcode,
558 boolean saturate,
559 boolean predicate,
560 boolean pred_negate,
561 unsigned pred_swizzle_x,
562 unsigned pred_swizzle_y,
563 unsigned pred_swizzle_z,
564 unsigned pred_swizzle_w,
565 unsigned num_dst,
566 unsigned num_src );
567
568 void
569 ureg_emit_label(struct ureg_program *ureg,
570 unsigned insn_token,
571 unsigned *label_token );
572
573 void
574 ureg_emit_texture(struct ureg_program *ureg,
575 unsigned insn_token,
576 unsigned target, unsigned num_offsets);
577
578 void
579 ureg_emit_texture_offset(struct ureg_program *ureg,
580 const struct tgsi_texture_offset *offset);
581
582 void
583 ureg_emit_memory(struct ureg_program *ureg,
584 unsigned insn_token,
585 unsigned qualifier);
586
587 void
588 ureg_emit_dst( struct ureg_program *ureg,
589 struct ureg_dst dst );
590
591 void
592 ureg_emit_src( struct ureg_program *ureg,
593 struct ureg_src src );
594
595 void
596 ureg_fixup_insn_size(struct ureg_program *ureg,
597 unsigned insn );
598
599
600 #define OP00( op ) \
601 static inline void ureg_##op( struct ureg_program *ureg ) \
602 { \
603 unsigned opcode = TGSI_OPCODE_##op; \
604 struct ureg_emit_insn_result insn; \
605 insn = ureg_emit_insn(ureg, \
606 opcode, \
607 FALSE, \
608 FALSE, \
609 FALSE, \
610 TGSI_SWIZZLE_X, \
611 TGSI_SWIZZLE_Y, \
612 TGSI_SWIZZLE_Z, \
613 TGSI_SWIZZLE_W, \
614 0, \
615 0); \
616 ureg_fixup_insn_size( ureg, insn.insn_token ); \
617 }
618
619 #define OP01( op ) \
620 static inline void ureg_##op( struct ureg_program *ureg, \
621 struct ureg_src src ) \
622 { \
623 unsigned opcode = TGSI_OPCODE_##op; \
624 struct ureg_emit_insn_result insn; \
625 insn = ureg_emit_insn(ureg, \
626 opcode, \
627 FALSE, \
628 FALSE, \
629 FALSE, \
630 TGSI_SWIZZLE_X, \
631 TGSI_SWIZZLE_Y, \
632 TGSI_SWIZZLE_Z, \
633 TGSI_SWIZZLE_W, \
634 0, \
635 1); \
636 ureg_emit_src( ureg, src ); \
637 ureg_fixup_insn_size( ureg, insn.insn_token ); \
638 }
639
640 #define OP00_LBL( op ) \
641 static inline void ureg_##op( struct ureg_program *ureg, \
642 unsigned *label_token ) \
643 { \
644 unsigned opcode = TGSI_OPCODE_##op; \
645 struct ureg_emit_insn_result insn; \
646 insn = ureg_emit_insn(ureg, \
647 opcode, \
648 FALSE, \
649 FALSE, \
650 FALSE, \
651 TGSI_SWIZZLE_X, \
652 TGSI_SWIZZLE_Y, \
653 TGSI_SWIZZLE_Z, \
654 TGSI_SWIZZLE_W, \
655 0, \
656 0); \
657 ureg_emit_label( ureg, insn.extended_token, label_token ); \
658 ureg_fixup_insn_size( ureg, insn.insn_token ); \
659 }
660
661 #define OP01_LBL( op ) \
662 static inline void ureg_##op( struct ureg_program *ureg, \
663 struct ureg_src src, \
664 unsigned *label_token ) \
665 { \
666 unsigned opcode = TGSI_OPCODE_##op; \
667 struct ureg_emit_insn_result insn; \
668 insn = ureg_emit_insn(ureg, \
669 opcode, \
670 FALSE, \
671 FALSE, \
672 FALSE, \
673 TGSI_SWIZZLE_X, \
674 TGSI_SWIZZLE_Y, \
675 TGSI_SWIZZLE_Z, \
676 TGSI_SWIZZLE_W, \
677 0, \
678 1); \
679 ureg_emit_label( ureg, insn.extended_token, label_token ); \
680 ureg_emit_src( ureg, src ); \
681 ureg_fixup_insn_size( ureg, insn.insn_token ); \
682 }
683
684 #define OP10( op ) \
685 static inline void ureg_##op( struct ureg_program *ureg, \
686 struct ureg_dst dst ) \
687 { \
688 unsigned opcode = TGSI_OPCODE_##op; \
689 struct ureg_emit_insn_result insn; \
690 if (ureg_dst_is_empty(dst)) \
691 return; \
692 insn = ureg_emit_insn(ureg, \
693 opcode, \
694 dst.Saturate, \
695 dst.Predicate, \
696 dst.PredNegate, \
697 dst.PredSwizzleX, \
698 dst.PredSwizzleY, \
699 dst.PredSwizzleZ, \
700 dst.PredSwizzleW, \
701 1, \
702 0); \
703 ureg_emit_dst( ureg, dst ); \
704 ureg_fixup_insn_size( ureg, insn.insn_token ); \
705 }
706
707
708 #define OP11( op ) \
709 static inline void ureg_##op( struct ureg_program *ureg, \
710 struct ureg_dst dst, \
711 struct ureg_src src ) \
712 { \
713 unsigned opcode = TGSI_OPCODE_##op; \
714 struct ureg_emit_insn_result insn; \
715 if (ureg_dst_is_empty(dst)) \
716 return; \
717 insn = ureg_emit_insn(ureg, \
718 opcode, \
719 dst.Saturate, \
720 dst.Predicate, \
721 dst.PredNegate, \
722 dst.PredSwizzleX, \
723 dst.PredSwizzleY, \
724 dst.PredSwizzleZ, \
725 dst.PredSwizzleW, \
726 1, \
727 1); \
728 ureg_emit_dst( ureg, dst ); \
729 ureg_emit_src( ureg, src ); \
730 ureg_fixup_insn_size( ureg, insn.insn_token ); \
731 }
732
733 #define OP12( op ) \
734 static inline void ureg_##op( struct ureg_program *ureg, \
735 struct ureg_dst dst, \
736 struct ureg_src src0, \
737 struct ureg_src src1 ) \
738 { \
739 unsigned opcode = TGSI_OPCODE_##op; \
740 struct ureg_emit_insn_result insn; \
741 if (ureg_dst_is_empty(dst)) \
742 return; \
743 insn = ureg_emit_insn(ureg, \
744 opcode, \
745 dst.Saturate, \
746 dst.Predicate, \
747 dst.PredNegate, \
748 dst.PredSwizzleX, \
749 dst.PredSwizzleY, \
750 dst.PredSwizzleZ, \
751 dst.PredSwizzleW, \
752 1, \
753 2); \
754 ureg_emit_dst( ureg, dst ); \
755 ureg_emit_src( ureg, src0 ); \
756 ureg_emit_src( ureg, src1 ); \
757 ureg_fixup_insn_size( ureg, insn.insn_token ); \
758 }
759
760 #define OP12_TEX( op ) \
761 static inline void ureg_##op( struct ureg_program *ureg, \
762 struct ureg_dst dst, \
763 unsigned target, \
764 struct ureg_src src0, \
765 struct ureg_src src1 ) \
766 { \
767 unsigned opcode = TGSI_OPCODE_##op; \
768 struct ureg_emit_insn_result insn; \
769 if (ureg_dst_is_empty(dst)) \
770 return; \
771 insn = ureg_emit_insn(ureg, \
772 opcode, \
773 dst.Saturate, \
774 dst.Predicate, \
775 dst.PredNegate, \
776 dst.PredSwizzleX, \
777 dst.PredSwizzleY, \
778 dst.PredSwizzleZ, \
779 dst.PredSwizzleW, \
780 1, \
781 2); \
782 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
783 ureg_emit_dst( ureg, dst ); \
784 ureg_emit_src( ureg, src0 ); \
785 ureg_emit_src( ureg, src1 ); \
786 ureg_fixup_insn_size( ureg, insn.insn_token ); \
787 }
788
789 #define OP12_SAMPLE( op ) \
790 static inline void ureg_##op( struct ureg_program *ureg, \
791 struct ureg_dst dst, \
792 struct ureg_src src0, \
793 struct ureg_src src1 ) \
794 { \
795 unsigned opcode = TGSI_OPCODE_##op; \
796 unsigned target = TGSI_TEXTURE_UNKNOWN; \
797 struct ureg_emit_insn_result insn; \
798 if (ureg_dst_is_empty(dst)) \
799 return; \
800 insn = ureg_emit_insn(ureg, \
801 opcode, \
802 dst.Saturate, \
803 dst.Predicate, \
804 dst.PredNegate, \
805 dst.PredSwizzleX, \
806 dst.PredSwizzleY, \
807 dst.PredSwizzleZ, \
808 dst.PredSwizzleW, \
809 1, \
810 2); \
811 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
812 ureg_emit_dst( ureg, dst ); \
813 ureg_emit_src( ureg, src0 ); \
814 ureg_emit_src( ureg, src1 ); \
815 ureg_fixup_insn_size( ureg, insn.insn_token ); \
816 }
817
818 #define OP13( op ) \
819 static inline void ureg_##op( struct ureg_program *ureg, \
820 struct ureg_dst dst, \
821 struct ureg_src src0, \
822 struct ureg_src src1, \
823 struct ureg_src src2 ) \
824 { \
825 unsigned opcode = TGSI_OPCODE_##op; \
826 struct ureg_emit_insn_result insn; \
827 if (ureg_dst_is_empty(dst)) \
828 return; \
829 insn = ureg_emit_insn(ureg, \
830 opcode, \
831 dst.Saturate, \
832 dst.Predicate, \
833 dst.PredNegate, \
834 dst.PredSwizzleX, \
835 dst.PredSwizzleY, \
836 dst.PredSwizzleZ, \
837 dst.PredSwizzleW, \
838 1, \
839 3); \
840 ureg_emit_dst( ureg, dst ); \
841 ureg_emit_src( ureg, src0 ); \
842 ureg_emit_src( ureg, src1 ); \
843 ureg_emit_src( ureg, src2 ); \
844 ureg_fixup_insn_size( ureg, insn.insn_token ); \
845 }
846
847 #define OP13_SAMPLE( op ) \
848 static inline void ureg_##op( struct ureg_program *ureg, \
849 struct ureg_dst dst, \
850 struct ureg_src src0, \
851 struct ureg_src src1, \
852 struct ureg_src src2 ) \
853 { \
854 unsigned opcode = TGSI_OPCODE_##op; \
855 unsigned target = TGSI_TEXTURE_UNKNOWN; \
856 struct ureg_emit_insn_result insn; \
857 if (ureg_dst_is_empty(dst)) \
858 return; \
859 insn = ureg_emit_insn(ureg, \
860 opcode, \
861 dst.Saturate, \
862 dst.Predicate, \
863 dst.PredNegate, \
864 dst.PredSwizzleX, \
865 dst.PredSwizzleY, \
866 dst.PredSwizzleZ, \
867 dst.PredSwizzleW, \
868 1, \
869 3); \
870 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
871 ureg_emit_dst( ureg, dst ); \
872 ureg_emit_src( ureg, src0 ); \
873 ureg_emit_src( ureg, src1 ); \
874 ureg_emit_src( ureg, src2 ); \
875 ureg_fixup_insn_size( ureg, insn.insn_token ); \
876 }
877
878 #define OP14_TEX( op ) \
879 static inline void ureg_##op( struct ureg_program *ureg, \
880 struct ureg_dst dst, \
881 unsigned target, \
882 struct ureg_src src0, \
883 struct ureg_src src1, \
884 struct ureg_src src2, \
885 struct ureg_src src3 ) \
886 { \
887 unsigned opcode = TGSI_OPCODE_##op; \
888 struct ureg_emit_insn_result insn; \
889 if (ureg_dst_is_empty(dst)) \
890 return; \
891 insn = ureg_emit_insn(ureg, \
892 opcode, \
893 dst.Saturate, \
894 dst.Predicate, \
895 dst.PredNegate, \
896 dst.PredSwizzleX, \
897 dst.PredSwizzleY, \
898 dst.PredSwizzleZ, \
899 dst.PredSwizzleW, \
900 1, \
901 4); \
902 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
903 ureg_emit_dst( ureg, dst ); \
904 ureg_emit_src( ureg, src0 ); \
905 ureg_emit_src( ureg, src1 ); \
906 ureg_emit_src( ureg, src2 ); \
907 ureg_emit_src( ureg, src3 ); \
908 ureg_fixup_insn_size( ureg, insn.insn_token ); \
909 }
910
911 #define OP14_SAMPLE( op ) \
912 static inline void ureg_##op( struct ureg_program *ureg, \
913 struct ureg_dst dst, \
914 struct ureg_src src0, \
915 struct ureg_src src1, \
916 struct ureg_src src2, \
917 struct ureg_src src3 ) \
918 { \
919 unsigned opcode = TGSI_OPCODE_##op; \
920 unsigned target = TGSI_TEXTURE_UNKNOWN; \
921 struct ureg_emit_insn_result insn; \
922 if (ureg_dst_is_empty(dst)) \
923 return; \
924 insn = ureg_emit_insn(ureg, \
925 opcode, \
926 dst.Saturate, \
927 dst.Predicate, \
928 dst.PredNegate, \
929 dst.PredSwizzleX, \
930 dst.PredSwizzleY, \
931 dst.PredSwizzleZ, \
932 dst.PredSwizzleW, \
933 1, \
934 4); \
935 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
936 ureg_emit_dst( ureg, dst ); \
937 ureg_emit_src( ureg, src0 ); \
938 ureg_emit_src( ureg, src1 ); \
939 ureg_emit_src( ureg, src2 ); \
940 ureg_emit_src( ureg, src3 ); \
941 ureg_fixup_insn_size( ureg, insn.insn_token ); \
942 }
943
944
945 #define OP14( op ) \
946 static inline void ureg_##op( struct ureg_program *ureg, \
947 struct ureg_dst dst, \
948 struct ureg_src src0, \
949 struct ureg_src src1, \
950 struct ureg_src src2, \
951 struct ureg_src src3 ) \
952 { \
953 unsigned opcode = TGSI_OPCODE_##op; \
954 struct ureg_emit_insn_result insn; \
955 if (ureg_dst_is_empty(dst)) \
956 return; \
957 insn = ureg_emit_insn(ureg, \
958 opcode, \
959 dst.Saturate, \
960 dst.Predicate, \
961 dst.PredNegate, \
962 dst.PredSwizzleX, \
963 dst.PredSwizzleY, \
964 dst.PredSwizzleZ, \
965 dst.PredSwizzleW, \
966 1, \
967 4); \
968 ureg_emit_dst( ureg, dst ); \
969 ureg_emit_src( ureg, src0 ); \
970 ureg_emit_src( ureg, src1 ); \
971 ureg_emit_src( ureg, src2 ); \
972 ureg_emit_src( ureg, src3 ); \
973 ureg_fixup_insn_size( ureg, insn.insn_token ); \
974 }
975
976
977 #define OP15( op ) \
978 static inline void ureg_##op( struct ureg_program *ureg, \
979 struct ureg_dst dst, \
980 struct ureg_src src0, \
981 struct ureg_src src1, \
982 struct ureg_src src2, \
983 struct ureg_src src3, \
984 struct ureg_src src4 ) \
985 { \
986 unsigned opcode = TGSI_OPCODE_##op; \
987 struct ureg_emit_insn_result insn; \
988 if (ureg_dst_is_empty(dst)) \
989 return; \
990 insn = ureg_emit_insn(ureg, \
991 opcode, \
992 dst.Saturate, \
993 dst.Predicate, \
994 dst.PredNegate, \
995 dst.PredSwizzleX, \
996 dst.PredSwizzleY, \
997 dst.PredSwizzleZ, \
998 dst.PredSwizzleW, \
999 1, \
1000 5); \
1001 ureg_emit_dst( ureg, dst ); \
1002 ureg_emit_src( ureg, src0 ); \
1003 ureg_emit_src( ureg, src1 ); \
1004 ureg_emit_src( ureg, src2 ); \
1005 ureg_emit_src( ureg, src3 ); \
1006 ureg_emit_src( ureg, src4 ); \
1007 ureg_fixup_insn_size( ureg, insn.insn_token ); \
1008 }
1009
1010 #define OP15_SAMPLE( op ) \
1011 static inline void ureg_##op( struct ureg_program *ureg, \
1012 struct ureg_dst dst, \
1013 struct ureg_src src0, \
1014 struct ureg_src src1, \
1015 struct ureg_src src2, \
1016 struct ureg_src src3, \
1017 struct ureg_src src4 ) \
1018 { \
1019 unsigned opcode = TGSI_OPCODE_##op; \
1020 unsigned target = TGSI_TEXTURE_UNKNOWN; \
1021 struct ureg_emit_insn_result insn; \
1022 if (ureg_dst_is_empty(dst)) \
1023 return; \
1024 insn = ureg_emit_insn(ureg, \
1025 opcode, \
1026 dst.Saturate, \
1027 dst.Predicate, \
1028 dst.PredNegate, \
1029 dst.PredSwizzleX, \
1030 dst.PredSwizzleY, \
1031 dst.PredSwizzleZ, \
1032 dst.PredSwizzleW, \
1033 1, \
1034 5); \
1035 ureg_emit_texture( ureg, insn.extended_token, target, 0 ); \
1036 ureg_emit_dst( ureg, dst ); \
1037 ureg_emit_src( ureg, src0 ); \
1038 ureg_emit_src( ureg, src1 ); \
1039 ureg_emit_src( ureg, src2 ); \
1040 ureg_emit_src( ureg, src3 ); \
1041 ureg_emit_src( ureg, src4 ); \
1042 ureg_fixup_insn_size( ureg, insn.insn_token ); \
1043 }
1044
1045 /* Use a template include to generate a correctly-typed ureg_OP()
1046 * function for each TGSI opcode:
1047 */
1048 #include "tgsi_opcode_tmp.h"
1049
1050
1051 /***********************************************************************
1052 * Inline helpers for manipulating register structs:
1053 */
1054 static inline struct ureg_src
1055 ureg_negate( struct ureg_src reg )
1056 {
1057 assert(reg.File != TGSI_FILE_NULL);
1058 reg.Negate ^= 1;
1059 return reg;
1060 }
1061
1062 static inline struct ureg_src
1063 ureg_abs( struct ureg_src reg )
1064 {
1065 assert(reg.File != TGSI_FILE_NULL);
1066 reg.Absolute = 1;
1067 reg.Negate = 0;
1068 return reg;
1069 }
1070
1071 static inline struct ureg_src
1072 ureg_swizzle( struct ureg_src reg,
1073 int x, int y, int z, int w )
1074 {
1075 unsigned swz = ( (reg.SwizzleX << 0) |
1076 (reg.SwizzleY << 2) |
1077 (reg.SwizzleZ << 4) |
1078 (reg.SwizzleW << 6));
1079
1080 assert(reg.File != TGSI_FILE_NULL);
1081 assert(x < 4);
1082 assert(y < 4);
1083 assert(z < 4);
1084 assert(w < 4);
1085
1086 reg.SwizzleX = (swz >> (x*2)) & 0x3;
1087 reg.SwizzleY = (swz >> (y*2)) & 0x3;
1088 reg.SwizzleZ = (swz >> (z*2)) & 0x3;
1089 reg.SwizzleW = (swz >> (w*2)) & 0x3;
1090 return reg;
1091 }
1092
1093 static inline struct ureg_src
1094 ureg_scalar( struct ureg_src reg, int x )
1095 {
1096 return ureg_swizzle(reg, x, x, x, x);
1097 }
1098
1099 static inline struct ureg_dst
1100 ureg_writemask( struct ureg_dst reg,
1101 unsigned writemask )
1102 {
1103 assert(reg.File != TGSI_FILE_NULL);
1104 reg.WriteMask &= writemask;
1105 return reg;
1106 }
1107
1108 static inline struct ureg_dst
1109 ureg_saturate( struct ureg_dst reg )
1110 {
1111 assert(reg.File != TGSI_FILE_NULL);
1112 reg.Saturate = 1;
1113 return reg;
1114 }
1115
1116 static inline struct ureg_dst
1117 ureg_predicate(struct ureg_dst reg,
1118 boolean negate,
1119 unsigned swizzle_x,
1120 unsigned swizzle_y,
1121 unsigned swizzle_z,
1122 unsigned swizzle_w)
1123 {
1124 assert(reg.File != TGSI_FILE_NULL);
1125 reg.Predicate = 1;
1126 reg.PredNegate = negate;
1127 reg.PredSwizzleX = swizzle_x;
1128 reg.PredSwizzleY = swizzle_y;
1129 reg.PredSwizzleZ = swizzle_z;
1130 reg.PredSwizzleW = swizzle_w;
1131 return reg;
1132 }
1133
1134 static inline struct ureg_dst
1135 ureg_dst_indirect( struct ureg_dst reg, struct ureg_src addr )
1136 {
1137 assert(reg.File != TGSI_FILE_NULL);
1138 assert(addr.File == TGSI_FILE_ADDRESS || addr.File == TGSI_FILE_TEMPORARY);
1139 reg.Indirect = 1;
1140 reg.IndirectFile = addr.File;
1141 reg.IndirectIndex = addr.Index;
1142 reg.IndirectSwizzle = addr.SwizzleX;
1143 return reg;
1144 }
1145
1146 static inline struct ureg_src
1147 ureg_src_indirect( struct ureg_src reg, struct ureg_src addr )
1148 {
1149 assert(reg.File != TGSI_FILE_NULL);
1150 assert(addr.File == TGSI_FILE_ADDRESS || addr.File == TGSI_FILE_TEMPORARY);
1151 reg.Indirect = 1;
1152 reg.IndirectFile = addr.File;
1153 reg.IndirectIndex = addr.Index;
1154 reg.IndirectSwizzle = addr.SwizzleX;
1155 return reg;
1156 }
1157
1158 static inline struct ureg_dst
1159 ureg_dst_dimension( struct ureg_dst reg, int index )
1160 {
1161 assert(reg.File != TGSI_FILE_NULL);
1162 reg.Dimension = 1;
1163 reg.DimIndirect = 0;
1164 reg.DimensionIndex = index;
1165 return reg;
1166 }
1167
1168 static inline struct ureg_src
1169 ureg_src_dimension( struct ureg_src reg, int index )
1170 {
1171 assert(reg.File != TGSI_FILE_NULL);
1172 reg.Dimension = 1;
1173 reg.DimIndirect = 0;
1174 reg.DimensionIndex = index;
1175 return reg;
1176 }
1177
1178 static inline struct ureg_dst
1179 ureg_dst_dimension_indirect( struct ureg_dst reg, struct ureg_src addr,
1180 int index )
1181 {
1182 assert(reg.File != TGSI_FILE_NULL);
1183 reg.Dimension = 1;
1184 reg.DimIndirect = 1;
1185 reg.DimensionIndex = index;
1186 reg.DimIndFile = addr.File;
1187 reg.DimIndIndex = addr.Index;
1188 reg.DimIndSwizzle = addr.SwizzleX;
1189 return reg;
1190 }
1191
1192 static inline struct ureg_src
1193 ureg_src_dimension_indirect( struct ureg_src reg, struct ureg_src addr,
1194 int index )
1195 {
1196 assert(reg.File != TGSI_FILE_NULL);
1197 reg.Dimension = 1;
1198 reg.DimIndirect = 1;
1199 reg.DimensionIndex = index;
1200 reg.DimIndFile = addr.File;
1201 reg.DimIndIndex = addr.Index;
1202 reg.DimIndSwizzle = addr.SwizzleX;
1203 return reg;
1204 }
1205
1206 static inline struct ureg_src
1207 ureg_src_array_offset(struct ureg_src reg, int offset)
1208 {
1209 reg.Index += offset;
1210 return reg;
1211 }
1212
1213 static inline struct ureg_dst
1214 ureg_dst_array_offset( struct ureg_dst reg, int offset )
1215 {
1216 reg.Index += offset;
1217 return reg;
1218 }
1219
1220 static inline struct ureg_dst
1221 ureg_dst_array_register(unsigned file,
1222 unsigned index,
1223 unsigned array_id)
1224 {
1225 struct ureg_dst dst;
1226
1227 dst.File = file;
1228 dst.WriteMask = TGSI_WRITEMASK_XYZW;
1229 dst.Indirect = 0;
1230 dst.IndirectFile = TGSI_FILE_NULL;
1231 dst.IndirectIndex = 0;
1232 dst.IndirectSwizzle = 0;
1233 dst.Saturate = 0;
1234 dst.Predicate = 0;
1235 dst.PredNegate = 0;
1236 dst.PredSwizzleX = TGSI_SWIZZLE_X;
1237 dst.PredSwizzleY = TGSI_SWIZZLE_Y;
1238 dst.PredSwizzleZ = TGSI_SWIZZLE_Z;
1239 dst.PredSwizzleW = TGSI_SWIZZLE_W;
1240 dst.Index = index;
1241 dst.Dimension = 0;
1242 dst.DimensionIndex = 0;
1243 dst.DimIndirect = 0;
1244 dst.DimIndFile = TGSI_FILE_NULL;
1245 dst.DimIndIndex = 0;
1246 dst.DimIndSwizzle = 0;
1247 dst.ArrayID = array_id;
1248
1249 return dst;
1250 }
1251
1252 static inline struct ureg_dst
1253 ureg_dst_register(unsigned file,
1254 unsigned index)
1255 {
1256 return ureg_dst_array_register(file, index, 0);
1257 }
1258
1259 static inline struct ureg_dst
1260 ureg_dst( struct ureg_src src )
1261 {
1262 struct ureg_dst dst;
1263
1264 assert(!src.Indirect ||
1265 (src.IndirectFile == TGSI_FILE_ADDRESS ||
1266 src.IndirectFile == TGSI_FILE_TEMPORARY));
1267
1268 dst.File = src.File;
1269 dst.WriteMask = TGSI_WRITEMASK_XYZW;
1270 dst.IndirectFile = src.IndirectFile;
1271 dst.Indirect = src.Indirect;
1272 dst.IndirectIndex = src.IndirectIndex;
1273 dst.IndirectSwizzle = src.IndirectSwizzle;
1274 dst.Saturate = 0;
1275 dst.Predicate = 0;
1276 dst.PredNegate = 0;
1277 dst.PredSwizzleX = TGSI_SWIZZLE_X;
1278 dst.PredSwizzleY = TGSI_SWIZZLE_Y;
1279 dst.PredSwizzleZ = TGSI_SWIZZLE_Z;
1280 dst.PredSwizzleW = TGSI_SWIZZLE_W;
1281 dst.Index = src.Index;
1282 dst.Dimension = src.Dimension;
1283 dst.DimensionIndex = src.DimensionIndex;
1284 dst.DimIndirect = src.DimIndirect;
1285 dst.DimIndFile = src.DimIndFile;
1286 dst.DimIndIndex = src.DimIndIndex;
1287 dst.DimIndSwizzle = src.DimIndSwizzle;
1288 dst.ArrayID = src.ArrayID;
1289
1290 return dst;
1291 }
1292
1293 static inline struct ureg_src
1294 ureg_src_array_register(unsigned file,
1295 unsigned index,
1296 unsigned array_id)
1297 {
1298 struct ureg_src src;
1299
1300 src.File = file;
1301 src.SwizzleX = TGSI_SWIZZLE_X;
1302 src.SwizzleY = TGSI_SWIZZLE_Y;
1303 src.SwizzleZ = TGSI_SWIZZLE_Z;
1304 src.SwizzleW = TGSI_SWIZZLE_W;
1305 src.Indirect = 0;
1306 src.IndirectFile = TGSI_FILE_NULL;
1307 src.IndirectIndex = 0;
1308 src.IndirectSwizzle = 0;
1309 src.Absolute = 0;
1310 src.Index = index;
1311 src.Negate = 0;
1312 src.Dimension = 0;
1313 src.DimensionIndex = 0;
1314 src.DimIndirect = 0;
1315 src.DimIndFile = TGSI_FILE_NULL;
1316 src.DimIndIndex = 0;
1317 src.DimIndSwizzle = 0;
1318 src.ArrayID = array_id;
1319
1320 return src;
1321 }
1322
1323 static inline struct ureg_src
1324 ureg_src_register(unsigned file,
1325 unsigned index)
1326 {
1327 return ureg_src_array_register(file, index, 0);
1328 }
1329
1330 static inline struct ureg_src
1331 ureg_src( struct ureg_dst dst )
1332 {
1333 struct ureg_src src;
1334
1335 src.File = dst.File;
1336 src.SwizzleX = TGSI_SWIZZLE_X;
1337 src.SwizzleY = TGSI_SWIZZLE_Y;
1338 src.SwizzleZ = TGSI_SWIZZLE_Z;
1339 src.SwizzleW = TGSI_SWIZZLE_W;
1340 src.Indirect = dst.Indirect;
1341 src.IndirectFile = dst.IndirectFile;
1342 src.IndirectIndex = dst.IndirectIndex;
1343 src.IndirectSwizzle = dst.IndirectSwizzle;
1344 src.Absolute = 0;
1345 src.Index = dst.Index;
1346 src.Negate = 0;
1347 src.Dimension = dst.Dimension;
1348 src.DimensionIndex = dst.DimensionIndex;
1349 src.DimIndirect = dst.DimIndirect;
1350 src.DimIndFile = dst.DimIndFile;
1351 src.DimIndIndex = dst.DimIndIndex;
1352 src.DimIndSwizzle = dst.DimIndSwizzle;
1353 src.ArrayID = dst.ArrayID;
1354
1355 return src;
1356 }
1357
1358
1359
1360 static inline struct ureg_dst
1361 ureg_dst_undef( void )
1362 {
1363 struct ureg_dst dst;
1364
1365 dst.File = TGSI_FILE_NULL;
1366 dst.WriteMask = 0;
1367 dst.Indirect = 0;
1368 dst.IndirectFile = TGSI_FILE_NULL;
1369 dst.IndirectIndex = 0;
1370 dst.IndirectSwizzle = 0;
1371 dst.Saturate = 0;
1372 dst.Predicate = 0;
1373 dst.PredNegate = 0;
1374 dst.PredSwizzleX = TGSI_SWIZZLE_X;
1375 dst.PredSwizzleY = TGSI_SWIZZLE_Y;
1376 dst.PredSwizzleZ = TGSI_SWIZZLE_Z;
1377 dst.PredSwizzleW = TGSI_SWIZZLE_W;
1378 dst.Index = 0;
1379 dst.Dimension = 0;
1380 dst.DimensionIndex = 0;
1381 dst.DimIndirect = 0;
1382 dst.DimIndFile = TGSI_FILE_NULL;
1383 dst.DimIndIndex = 0;
1384 dst.DimIndSwizzle = 0;
1385 dst.ArrayID = 0;
1386
1387 return dst;
1388 }
1389
1390 static inline struct ureg_src
1391 ureg_src_undef( void )
1392 {
1393 struct ureg_src src;
1394
1395 src.File = TGSI_FILE_NULL;
1396 src.SwizzleX = 0;
1397 src.SwizzleY = 0;
1398 src.SwizzleZ = 0;
1399 src.SwizzleW = 0;
1400 src.Indirect = 0;
1401 src.IndirectFile = TGSI_FILE_NULL;
1402 src.IndirectIndex = 0;
1403 src.IndirectSwizzle = 0;
1404 src.Absolute = 0;
1405 src.Index = 0;
1406 src.Negate = 0;
1407 src.Dimension = 0;
1408 src.DimensionIndex = 0;
1409 src.DimIndirect = 0;
1410 src.DimIndFile = TGSI_FILE_NULL;
1411 src.DimIndIndex = 0;
1412 src.DimIndSwizzle = 0;
1413 src.ArrayID = 0;
1414
1415 return src;
1416 }
1417
1418 static inline boolean
1419 ureg_src_is_undef( struct ureg_src src )
1420 {
1421 return src.File == TGSI_FILE_NULL;
1422 }
1423
1424 static inline boolean
1425 ureg_dst_is_undef( struct ureg_dst dst )
1426 {
1427 return dst.File == TGSI_FILE_NULL;
1428 }
1429
1430
1431 #ifdef __cplusplus
1432 }
1433 #endif
1434
1435 #endif