projects / mesa.git / blob
? search:


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