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