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