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