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