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