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