projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
glsl: use the BA1 macro for textureCubeArrayShadow()
[mesa.git] / src / compiler / glsl / builtin_functions.cpp
1 /*
2 * Copyright © 2013 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 /**
25 * \file builtin_functions.cpp
26 *
27 * Support for GLSL built-in functions.
28 *
29 * This file is split into several main components:
30 *
31 * 1. Availability predicates
32 *
33 * A series of small functions that check whether the current shader
34 * supports the version/extensions required to expose a built-in.
35 *
36 * 2. Core builtin_builder class functionality
37 *
38 * 3. Lists of built-in functions
39 *
40 * The builtin_builder::create_builtins() function contains lists of all
41 * built-in function signatures, where they're available, what types they
42 * take, and so on.
43 *
44 * 4. Implementations of built-in function signatures
45 *
46 * A series of functions which create ir_function_signatures and emit IR
47 * via ir_builder to implement them.
48 *
49 * 5. External API
50 *
51 * A few functions the rest of the compiler can use to interact with the
52 * built-in function module. For example, searching for a built-in by
53 * name and parameters.
54 */
55
56
57 /**
58 * Unfortunately, some versions of MinGW produce bad code if this file
59 * is compiled with -O2 or -O3. The resulting driver will crash in random
60 * places if the app uses GLSL.
61 * The work-around is to disable optimizations for just this file. Luckily,
62 * this code is basically just executed once.
63 *
64 * MinGW 4.6.3 (in Ubuntu 13.10) does not have this bug.
65 * MinGW 5.3.1 (in Ubuntu 16.04) definitely has this bug.
66 * MinGW 6.2.0 (in Ubuntu 16.10) definitely has this bug.
67 * MinGW x.y.z - don't know. Assume versions after 4.6.x are buggy
68 */
69
70 #if defined(__MINGW32__) && ((__GNUC__ * 100) + __GNUC_MINOR >= 407)
71 #warning "disabling optimizations for this file to work around compiler bug"
72 #pragma GCC optimize("O1")
73 #endif
74
75
76 #include <stdarg.h>
77 #include <stdio.h>
78 #include "main/core.h" /* for struct gl_shader */
79 #include "main/shaderobj.h"
80 #include "ir_builder.h"
81 #include "glsl_parser_extras.h"
82 #include "program/prog_instruction.h"
83 #include <math.h>
84 #include "builtin_functions.h"
85 #include "util/hash_table.h"
86
87 #define M_PIf ((float) M_PI)
88 #define M_PI_2f ((float) M_PI_2)
89 #define M_PI_4f ((float) M_PI_4)
90
91 using namespace ir_builder;
92
93 /**
94 * Availability predicates:
95 * @{
96 */
97 static bool
98 always_available(const _mesa_glsl_parse_state *)
99 {
100 return true;
101 }
102
103 static bool
104 compatibility_vs_only(const _mesa_glsl_parse_state *state)
105 {
106 return state->stage == MESA_SHADER_VERTEX &&
107 state->language_version <= 130 &&
108 !state->es_shader;
109 }
110
111 static bool
112 fs_only(const _mesa_glsl_parse_state *state)
113 {
114 return state->stage == MESA_SHADER_FRAGMENT;
115 }
116
117 static bool
118 gs_only(const _mesa_glsl_parse_state *state)
119 {
120 return state->stage == MESA_SHADER_GEOMETRY;
121 }
122
123 static bool
124 v110(const _mesa_glsl_parse_state *state)
125 {
126 return !state->es_shader;
127 }
128
129 static bool
130 v110_fs_only(const _mesa_glsl_parse_state *state)
131 {
132 return !state->es_shader && state->stage == MESA_SHADER_FRAGMENT;
133 }
134
135 static bool
136 v120(const _mesa_glsl_parse_state *state)
137 {
138 return state->is_version(120, 300);
139 }
140
141 static bool
142 v130(const _mesa_glsl_parse_state *state)
143 {
144 return state->is_version(130, 300);
145 }
146
147 static bool
148 v130_desktop(const _mesa_glsl_parse_state *state)
149 {
150 return state->is_version(130, 0);
151 }
152
153 static bool
154 v130_fs_only(const _mesa_glsl_parse_state *state)
155 {
156 return state->is_version(130, 300) &&
157 state->stage == MESA_SHADER_FRAGMENT;
158 }
159
160 static bool
161 v140_or_es3(const _mesa_glsl_parse_state *state)
162 {
163 return state->is_version(140, 300);
164 }
165
166 static bool
167 v400_fs_only(const _mesa_glsl_parse_state *state)
168 {
169 return state->is_version(400, 0) &&
170 state->stage == MESA_SHADER_FRAGMENT;
171 }
172
173 static bool
174 texture_rectangle(const _mesa_glsl_parse_state *state)
175 {
176 return state->ARB_texture_rectangle_enable;
177 }
178
179 static bool
180 texture_external(const _mesa_glsl_parse_state *state)
181 {
182 return state->OES_EGL_image_external_enable;
183 }
184
185 /** True if texturing functions with explicit LOD are allowed. */
186 static bool
187 lod_exists_in_stage(const _mesa_glsl_parse_state *state)
188 {
189 /* Texturing functions with "Lod" in their name exist:
190 * - In the vertex shader stage (for all languages)
191 * - In any stage for GLSL 1.30+ or GLSL ES 3.00
192 * - In any stage for desktop GLSL with ARB_shader_texture_lod enabled.
193 *
194 * Since ARB_shader_texture_lod can only be enabled on desktop GLSL, we
195 * don't need to explicitly check state->es_shader.
196 */
197 return state->stage == MESA_SHADER_VERTEX ||
198 state->is_version(130, 300) ||
199 state->ARB_shader_texture_lod_enable;
200 }
201
202 static bool
203 v110_lod(const _mesa_glsl_parse_state *state)
204 {
205 return !state->es_shader && lod_exists_in_stage(state);
206 }
207
208 static bool
209 texture_buffer(const _mesa_glsl_parse_state *state)
210 {
211 return state->is_version(140, 320) ||
212 state->EXT_texture_buffer_enable ||
213 state->OES_texture_buffer_enable;
214 }
215
216 static bool
217 shader_texture_lod(const _mesa_glsl_parse_state *state)
218 {
219 return state->ARB_shader_texture_lod_enable;
220 }
221
222 static bool
223 shader_texture_lod_and_rect(const _mesa_glsl_parse_state *state)
224 {
225 return state->ARB_shader_texture_lod_enable &&
226 state->ARB_texture_rectangle_enable;
227 }
228
229 static bool
230 shader_bit_encoding(const _mesa_glsl_parse_state *state)
231 {
232 return state->is_version(330, 300) ||
233 state->ARB_shader_bit_encoding_enable ||
234 state->ARB_gpu_shader5_enable;
235 }
236
237 static bool
238 shader_integer_mix(const _mesa_glsl_parse_state *state)
239 {
240 return state->is_version(450, 310) ||
241 state->ARB_ES3_1_compatibility_enable ||
242 (v130(state) && state->EXT_shader_integer_mix_enable);
243 }
244
245 static bool
246 shader_packing_or_es3(const _mesa_glsl_parse_state *state)
247 {
248 return state->ARB_shading_language_packing_enable ||
249 state->is_version(420, 300);
250 }
251
252 static bool
253 shader_packing_or_es3_or_gpu_shader5(const _mesa_glsl_parse_state *state)
254 {
255 return state->ARB_shading_language_packing_enable ||
256 state->ARB_gpu_shader5_enable ||
257 state->is_version(400, 300);
258 }
259
260 static bool
261 gpu_shader5(const _mesa_glsl_parse_state *state)
262 {
263 return state->is_version(400, 0) || state->ARB_gpu_shader5_enable;
264 }
265
266 static bool
267 gpu_shader5_es(const _mesa_glsl_parse_state *state)
268 {
269 return state->is_version(400, 320) ||
270 state->ARB_gpu_shader5_enable ||
271 state->EXT_gpu_shader5_enable ||
272 state->OES_gpu_shader5_enable;
273 }
274
275 static bool
276 gpu_shader5_or_OES_texture_cube_map_array(const _mesa_glsl_parse_state *state)
277 {
278 return state->is_version(400, 320) ||
279 state->ARB_gpu_shader5_enable ||
280 state->EXT_texture_cube_map_array_enable ||
281 state->OES_texture_cube_map_array_enable;
282 }
283
284 static bool
285 es31_not_gs5(const _mesa_glsl_parse_state *state)
286 {
287 return state->is_version(0, 310) && !gpu_shader5_es(state);
288 }
289
290 static bool
291 gpu_shader5_or_es31(const _mesa_glsl_parse_state *state)
292 {
293 return state->is_version(400, 310) || state->ARB_gpu_shader5_enable;
294 }
295
296 static bool
297 shader_packing_or_es31_or_gpu_shader5(const _mesa_glsl_parse_state *state)
298 {
299 return state->ARB_shading_language_packing_enable ||
300 state->ARB_gpu_shader5_enable ||
301 state->is_version(400, 310);
302 }
303
304 static bool
305 gpu_shader5_or_es31_or_integer_functions(const _mesa_glsl_parse_state *state)
306 {
307 return gpu_shader5_or_es31(state) ||
308 state->MESA_shader_integer_functions_enable;
309 }
310
311 static bool
312 fs_interpolate_at(const _mesa_glsl_parse_state *state)
313 {
314 return state->stage == MESA_SHADER_FRAGMENT &&
315 (state->is_version(400, 320) ||
316 state->ARB_gpu_shader5_enable ||
317 state->OES_shader_multisample_interpolation_enable);
318 }
319
320
321 static bool
322 texture_array_lod(const _mesa_glsl_parse_state *state)
323 {
324 return lod_exists_in_stage(state) &&
325 state->EXT_texture_array_enable;
326 }
327
328 static bool
329 fs_texture_array(const _mesa_glsl_parse_state *state)
330 {
331 return state->stage == MESA_SHADER_FRAGMENT &&
332 state->EXT_texture_array_enable;
333 }
334
335 static bool
336 texture_array(const _mesa_glsl_parse_state *state)
337 {
338 return state->EXT_texture_array_enable;
339 }
340
341 static bool
342 texture_multisample(const _mesa_glsl_parse_state *state)
343 {
344 return state->is_version(150, 310) ||
345 state->ARB_texture_multisample_enable;
346 }
347
348 static bool
349 texture_multisample_array(const _mesa_glsl_parse_state *state)
350 {
351 return state->is_version(150, 320) ||
352 state->ARB_texture_multisample_enable ||
353 state->OES_texture_storage_multisample_2d_array_enable;
354 }
355
356 static bool
357 texture_samples_identical(const _mesa_glsl_parse_state *state)
358 {
359 return texture_multisample(state) &&
360 state->EXT_shader_samples_identical_enable;
361 }
362
363 static bool
364 texture_samples_identical_array(const _mesa_glsl_parse_state *state)
365 {
366 return texture_multisample_array(state) &&
367 state->EXT_shader_samples_identical_enable;
368 }
369
370 static bool
371 fs_texture_cube_map_array(const _mesa_glsl_parse_state *state)
372 {
373 return state->stage == MESA_SHADER_FRAGMENT &&
374 state->has_texture_cube_map_array();
375 }
376
377 static bool
378 texture_cube_map_array(const _mesa_glsl_parse_state *state)
379 {
380 return state->has_texture_cube_map_array();
381 }
382
383 static bool
384 texture_query_levels(const _mesa_glsl_parse_state *state)
385 {
386 return state->is_version(430, 0) ||
387 state->ARB_texture_query_levels_enable;
388 }
389
390 static bool
391 texture_query_lod(const _mesa_glsl_parse_state *state)
392 {
393 return state->stage == MESA_SHADER_FRAGMENT &&
394 state->ARB_texture_query_lod_enable;
395 }
396
397 static bool
398 texture_gather_cube_map_array(const _mesa_glsl_parse_state *state)
399 {
400 return state->is_version(400, 320) ||
401 state->ARB_texture_gather_enable ||
402 state->ARB_gpu_shader5_enable ||
403 state->EXT_texture_cube_map_array_enable ||
404 state->OES_texture_cube_map_array_enable;
405 }
406
407 static bool
408 texture_gather_or_es31(const _mesa_glsl_parse_state *state)
409 {
410 return state->is_version(400, 310) ||
411 state->ARB_texture_gather_enable ||
412 state->ARB_gpu_shader5_enable;
413 }
414
415 /* Only ARB_texture_gather but not GLSL 4.0 or ARB_gpu_shader5.
416 * used for relaxation of const offset requirements.
417 */
418 static bool
419 texture_gather_only_or_es31(const _mesa_glsl_parse_state *state)
420 {
421 return !state->is_version(400, 320) &&
422 !state->ARB_gpu_shader5_enable &&
423 !state->EXT_gpu_shader5_enable &&
424 !state->OES_gpu_shader5_enable &&
425 (state->ARB_texture_gather_enable ||
426 state->is_version(0, 310));
427 }
428
429 /* Desktop GL or OES_standard_derivatives + fragment shader only */
430 static bool
431 fs_oes_derivatives(const _mesa_glsl_parse_state *state)
432 {
433 return state->stage == MESA_SHADER_FRAGMENT &&
434 (state->is_version(110, 300) ||
435 state->OES_standard_derivatives_enable);
436 }
437
438 static bool
439 fs_derivative_control(const _mesa_glsl_parse_state *state)
440 {
441 return state->stage == MESA_SHADER_FRAGMENT &&
442 (state->is_version(450, 0) ||
443 state->ARB_derivative_control_enable);
444 }
445
446 static bool
447 tex1d_lod(const _mesa_glsl_parse_state *state)
448 {
449 return !state->es_shader && lod_exists_in_stage(state);
450 }
451
452 /** True if sampler3D exists */
453 static bool
454 tex3d(const _mesa_glsl_parse_state *state)
455 {
456 /* sampler3D exists in all desktop GLSL versions, GLSL ES 1.00 with the
457 * OES_texture_3D extension, and in GLSL ES 3.00.
458 */
459 return !state->es_shader ||
460 state->OES_texture_3D_enable ||
461 state->language_version >= 300;
462 }
463
464 static bool
465 fs_tex3d(const _mesa_glsl_parse_state *state)
466 {
467 return state->stage == MESA_SHADER_FRAGMENT &&
468 (!state->es_shader || state->OES_texture_3D_enable);
469 }
470
471 static bool
472 tex3d_lod(const _mesa_glsl_parse_state *state)
473 {
474 return tex3d(state) && lod_exists_in_stage(state);
475 }
476
477 static bool
478 shader_atomic_counters(const _mesa_glsl_parse_state *state)
479 {
480 return state->has_atomic_counters();
481 }
482
483 static bool
484 shader_atomic_counter_ops(const _mesa_glsl_parse_state *state)
485 {
486 return state->ARB_shader_atomic_counter_ops_enable;
487 }
488
489 static bool
490 shader_ballot(const _mesa_glsl_parse_state *state)
491 {
492 return state->ARB_shader_ballot_enable;
493 }
494
495 static bool
496 shader_clock(const _mesa_glsl_parse_state *state)
497 {
498 return state->ARB_shader_clock_enable;
499 }
500
501 static bool
502 shader_clock_int64(const _mesa_glsl_parse_state *state)
503 {
504 return state->ARB_shader_clock_enable &&
505 state->ARB_gpu_shader_int64_enable;
506 }
507
508 static bool
509 shader_storage_buffer_object(const _mesa_glsl_parse_state *state)
510 {
511 return state->has_shader_storage_buffer_objects();
512 }
513
514 static bool
515 shader_trinary_minmax(const _mesa_glsl_parse_state *state)
516 {
517 return state->AMD_shader_trinary_minmax_enable;
518 }
519
520 static bool
521 shader_image_load_store(const _mesa_glsl_parse_state *state)
522 {
523 return (state->is_version(420, 310) ||
524 state->ARB_shader_image_load_store_enable);
525 }
526
527 static bool
528 shader_image_atomic(const _mesa_glsl_parse_state *state)
529 {
530 return (state->is_version(420, 320) ||
531 state->ARB_shader_image_load_store_enable ||
532 state->OES_shader_image_atomic_enable);
533 }
534
535 static bool
536 shader_image_atomic_exchange_float(const _mesa_glsl_parse_state *state)
537 {
538 return (state->is_version(450, 320) ||
539 state->ARB_ES3_1_compatibility_enable ||
540 state->OES_shader_image_atomic_enable);
541 }
542
543 static bool
544 shader_image_size(const _mesa_glsl_parse_state *state)
545 {
546 return state->is_version(430, 310) ||
547 state->ARB_shader_image_size_enable;
548 }
549
550 static bool
551 shader_samples(const _mesa_glsl_parse_state *state)
552 {
553 return state->is_version(450, 0) ||
554 state->ARB_shader_texture_image_samples_enable;
555 }
556
557 static bool
558 gs_streams(const _mesa_glsl_parse_state *state)
559 {
560 return gpu_shader5(state) && gs_only(state);
561 }
562
563 static bool
564 fp64(const _mesa_glsl_parse_state *state)
565 {
566 return state->has_double();
567 }
568
569 static bool
570 int64(const _mesa_glsl_parse_state *state)
571 {
572 return state->has_int64();
573 }
574
575 static bool
576 int64_fp64(const _mesa_glsl_parse_state *state)
577 {
578 return state->has_int64() && state->has_double();
579 }
580
581 static bool
582 compute_shader(const _mesa_glsl_parse_state *state)
583 {
584 return state->stage == MESA_SHADER_COMPUTE;
585 }
586
587 static bool
588 compute_shader_supported(const _mesa_glsl_parse_state *state)
589 {
590 return state->has_compute_shader();
591 }
592
593 static bool
594 buffer_atomics_supported(const _mesa_glsl_parse_state *state)
595 {
596 return compute_shader(state) || shader_storage_buffer_object(state);
597 }
598
599 static bool
600 barrier_supported(const _mesa_glsl_parse_state *state)
601 {
602 return compute_shader(state) ||
603 state->stage == MESA_SHADER_TESS_CTRL;
604 }
605
606 static bool
607 vote(const _mesa_glsl_parse_state *state)
608 {
609 return state->ARB_shader_group_vote_enable;
610 }
611
612 static bool
613 integer_functions_supported(const _mesa_glsl_parse_state *state)
614 {
615 return state->extensions->MESA_shader_integer_functions;
616 }
617 /** @} */
618
619 /******************************************************************************/
620
621 namespace {
622
623 /**
624 * builtin_builder: A singleton object representing the core of the built-in
625 * function module.
626 *
627 * It generates IR for every built-in function signature, and organizes them
628 * into functions.
629 */
630 class builtin_builder {
631 public:
632 builtin_builder();
633 ~builtin_builder();
634
635 void initialize();
636 void release();
637 ir_function_signature *find(_mesa_glsl_parse_state *state,
638 const char *name, exec_list *actual_parameters);
639
640 /**
641 * A shader to hold all the built-in signatures; created by this module.
642 *
643 * This includes signatures for every built-in, regardless of version or
644 * enabled extensions. The availability predicate associated with each
645 * signature allows matching_signature() to filter out the irrelevant ones.
646 */
647 gl_shader *shader;
648
649 private:
650 void *mem_ctx;
651
652 void create_shader();
653 void create_intrinsics();
654 void create_builtins();
655
656 /**
657 * IR builder helpers:
658 *
659 * These convenience functions assist in emitting IR, but don't necessarily
660 * fit in ir_builder itself. Many of them rely on having a mem_ctx class
661 * member available.
662 */
663 ir_variable *in_var(const glsl_type *type, const char *name);
664 ir_variable *out_var(const glsl_type *type, const char *name);
665 ir_constant *imm(float f, unsigned vector_elements=1);
666 ir_constant *imm(bool b, unsigned vector_elements=1);
667 ir_constant *imm(int i, unsigned vector_elements=1);
668 ir_constant *imm(unsigned u, unsigned vector_elements=1);
669 ir_constant *imm(double d, unsigned vector_elements=1);
670 ir_constant *imm(const glsl_type *type, const ir_constant_data &);
671 ir_dereference_variable *var_ref(ir_variable *var);
672 ir_dereference_array *array_ref(ir_variable *var, int i);
673 ir_swizzle *matrix_elt(ir_variable *var, int col, int row);
674
675 ir_expression *asin_expr(ir_variable *x, float p0, float p1);
676 void do_atan(ir_factory &body, const glsl_type *type, ir_variable *res, operand y_over_x);
677
678 /**
679 * Call function \param f with parameters specified as the linked
680 * list \param params of \c ir_variable objects. \param ret should
681 * point to the ir_variable that will hold the function return
682 * value, or be \c NULL if the function has void return type.
683 */
684 ir_call *call(ir_function *f, ir_variable *ret, exec_list params);
685
686 /** Create a new function and add the given signatures. */
687 void add_function(const char *name, ...);
688
689 typedef ir_function_signature *(builtin_builder::*image_prototype_ctr)(const glsl_type *image_type,
690 unsigned num_arguments,
691 unsigned flags);
692
693 /**
694 * Create a new image built-in function for all known image types.
695 * \p flags is a bitfield of \c image_function_flags flags.
696 */
697 void add_image_function(const char *name,
698 const char *intrinsic_name,
699 image_prototype_ctr prototype,
700 unsigned num_arguments,
701 unsigned flags,
702 enum ir_intrinsic_id id);
703
704 /**
705 * Create new functions for all known image built-ins and types.
706 * If \p glsl is \c true, use the GLSL built-in names and emit code
707 * to call into the actual compiler intrinsic. If \p glsl is
708 * false, emit a function prototype with no body for each image
709 * intrinsic name.
710 */
711 void add_image_functions(bool glsl);
712
713 ir_function_signature *new_sig(const glsl_type *return_type,
714 builtin_available_predicate avail,
715 int num_params, ...);
716
717 /**
718 * Function signature generators:
719 * @{
720 */
721 ir_function_signature *unop(builtin_available_predicate avail,
722 ir_expression_operation opcode,
723 const glsl_type *return_type,
724 const glsl_type *param_type);
725 ir_function_signature *binop(builtin_available_predicate avail,
726 ir_expression_operation opcode,
727 const glsl_type *return_type,
728 const glsl_type *param0_type,
729 const glsl_type *param1_type);
730
731 #define B0(X) ir_function_signature *_##X();
732 #define B1(X) ir_function_signature *_##X(const glsl_type *);
733 #define B2(X) ir_function_signature *_##X(const glsl_type *, const glsl_type *);
734 #define B3(X) ir_function_signature *_##X(const glsl_type *, const glsl_type *, const glsl_type *);
735 #define BA1(X) ir_function_signature *_##X(builtin_available_predicate, const glsl_type *);
736 #define BA2(X) ir_function_signature *_##X(builtin_available_predicate, const glsl_type *, const glsl_type *);
737 B1(radians)
738 B1(degrees)
739 B1(sin)
740 B1(cos)
741 B1(tan)
742 B1(asin)
743 B1(acos)
744 B1(atan2)
745 B1(atan)
746 B1(sinh)
747 B1(cosh)
748 B1(tanh)
749 B1(asinh)
750 B1(acosh)
751 B1(atanh)
752 B1(pow)
753 B1(exp)
754 B1(log)
755 B1(exp2)
756 B1(log2)
757 BA1(sqrt)
758 BA1(inversesqrt)
759 BA1(abs)
760 BA1(sign)
761 BA1(floor)
762 BA1(trunc)
763 BA1(round)
764 BA1(roundEven)
765 BA1(ceil)
766 BA1(fract)
767 BA2(mod)
768 BA1(modf)
769 BA2(min)
770 BA2(max)
771 BA2(clamp)
772 BA2(mix_lrp)
773 ir_function_signature *_mix_sel(builtin_available_predicate avail,
774 const glsl_type *val_type,
775 const glsl_type *blend_type);
776 BA2(step)
777 BA2(smoothstep)
778 BA1(isnan)
779 BA1(isinf)
780 B1(floatBitsToInt)
781 B1(floatBitsToUint)
782 B1(intBitsToFloat)
783 B1(uintBitsToFloat)
784
785 BA1(doubleBitsToInt64)
786 BA1(doubleBitsToUint64)
787 BA1(int64BitsToDouble)
788 BA1(uint64BitsToDouble)
789
790 ir_function_signature *_packUnorm2x16(builtin_available_predicate avail);
791 ir_function_signature *_packSnorm2x16(builtin_available_predicate avail);
792 ir_function_signature *_packUnorm4x8(builtin_available_predicate avail);
793 ir_function_signature *_packSnorm4x8(builtin_available_predicate avail);
794 ir_function_signature *_unpackUnorm2x16(builtin_available_predicate avail);
795 ir_function_signature *_unpackSnorm2x16(builtin_available_predicate avail);
796 ir_function_signature *_unpackUnorm4x8(builtin_available_predicate avail);
797 ir_function_signature *_unpackSnorm4x8(builtin_available_predicate avail);
798 ir_function_signature *_packHalf2x16(builtin_available_predicate avail);
799 ir_function_signature *_unpackHalf2x16(builtin_available_predicate avail);
800 ir_function_signature *_packDouble2x32(builtin_available_predicate avail);
801 ir_function_signature *_unpackDouble2x32(builtin_available_predicate avail);
802 ir_function_signature *_packInt2x32(builtin_available_predicate avail);
803 ir_function_signature *_unpackInt2x32(builtin_available_predicate avail);
804 ir_function_signature *_packUint2x32(builtin_available_predicate avail);
805 ir_function_signature *_unpackUint2x32(builtin_available_predicate avail);
806
807 BA1(length)
808 BA1(distance);
809 BA1(dot);
810 BA1(cross);
811 BA1(normalize);
812 B0(ftransform);
813 BA1(faceforward);
814 BA1(reflect);
815 BA1(refract);
816 BA1(matrixCompMult);
817 BA1(outerProduct);
818 BA1(determinant_mat2);
819 BA1(determinant_mat3);
820 BA1(determinant_mat4);
821 BA1(inverse_mat2);
822 BA1(inverse_mat3);
823 BA1(inverse_mat4);
824 BA1(transpose);
825 BA1(lessThan);
826 BA1(lessThanEqual);
827 BA1(greaterThan);
828 BA1(greaterThanEqual);
829 BA1(equal);
830 BA1(notEqual);
831 B1(any);
832 B1(all);
833 B1(not);
834 BA2(textureSize);
835 B1(textureSamples);
836
837 /** Flags to _texture() */
838 #define TEX_PROJECT 1
839 #define TEX_OFFSET 2
840 #define TEX_COMPONENT 4
841 #define TEX_OFFSET_NONCONST 8
842 #define TEX_OFFSET_ARRAY 16
843
844 ir_function_signature *_texture(ir_texture_opcode opcode,
845 builtin_available_predicate avail,
846 const glsl_type *return_type,
847 const glsl_type *sampler_type,
848 const glsl_type *coord_type,
849 int flags = 0);
850 BA1(textureCubeArrayShadow);
851 ir_function_signature *_texelFetch(builtin_available_predicate avail,
852 const glsl_type *return_type,
853 const glsl_type *sampler_type,
854 const glsl_type *coord_type,
855 const glsl_type *offset_type = NULL);
856
857 B0(EmitVertex)
858 B0(EndPrimitive)
859 ir_function_signature *_EmitStreamVertex(builtin_available_predicate avail,
860 const glsl_type *stream_type);
861 ir_function_signature *_EndStreamPrimitive(builtin_available_predicate avail,
862 const glsl_type *stream_type);
863 B0(barrier)
864
865 BA2(textureQueryLod);
866 B1(textureQueryLevels);
867 BA2(textureSamplesIdentical);
868 B1(dFdx);
869 B1(dFdy);
870 B1(fwidth);
871 B1(dFdxCoarse);
872 B1(dFdyCoarse);
873 B1(fwidthCoarse);
874 B1(dFdxFine);
875 B1(dFdyFine);
876 B1(fwidthFine);
877 B1(noise1);
878 B1(noise2);
879 B1(noise3);
880 B1(noise4);
881
882 B1(bitfieldExtract)
883 B1(bitfieldInsert)
884 B1(bitfieldReverse)
885 B1(bitCount)
886 B1(findLSB)
887 B1(findMSB)
888 BA1(fma)
889 B2(ldexp)
890 B2(frexp)
891 B2(dfrexp)
892 B1(uaddCarry)
893 B1(usubBorrow)
894 B1(mulExtended)
895 B1(interpolateAtCentroid)
896 B1(interpolateAtOffset)
897 B1(interpolateAtSample)
898
899 ir_function_signature *_atomic_counter_intrinsic(builtin_available_predicate avail,
900 enum ir_intrinsic_id id);
901 ir_function_signature *_atomic_counter_intrinsic1(builtin_available_predicate avail,
902 enum ir_intrinsic_id id);
903 ir_function_signature *_atomic_counter_intrinsic2(builtin_available_predicate avail,
904 enum ir_intrinsic_id id);
905 ir_function_signature *_atomic_counter_op(const char *intrinsic,
906 builtin_available_predicate avail);
907 ir_function_signature *_atomic_counter_op1(const char *intrinsic,
908 builtin_available_predicate avail);
909 ir_function_signature *_atomic_counter_op2(const char *intrinsic,
910 builtin_available_predicate avail);
911
912 ir_function_signature *_atomic_intrinsic2(builtin_available_predicate avail,
913 const glsl_type *type,
914 enum ir_intrinsic_id id);
915 ir_function_signature *_atomic_op2(const char *intrinsic,
916 builtin_available_predicate avail,
917 const glsl_type *type);
918 ir_function_signature *_atomic_intrinsic3(builtin_available_predicate avail,
919 const glsl_type *type,
920 enum ir_intrinsic_id id);
921 ir_function_signature *_atomic_op3(const char *intrinsic,
922 builtin_available_predicate avail,
923 const glsl_type *type);
924
925 B1(min3)
926 B1(max3)
927 B1(mid3)
928
929 ir_function_signature *_image_prototype(const glsl_type *image_type,
930 unsigned num_arguments,
931 unsigned flags);
932 ir_function_signature *_image_size_prototype(const glsl_type *image_type,
933 unsigned num_arguments,
934 unsigned flags);
935 ir_function_signature *_image_samples_prototype(const glsl_type *image_type,
936 unsigned num_arguments,
937 unsigned flags);
938 ir_function_signature *_image(image_prototype_ctr prototype,
939 const glsl_type *image_type,
940 const char *intrinsic_name,
941 unsigned num_arguments,
942 unsigned flags,
943 enum ir_intrinsic_id id);
944
945 ir_function_signature *_memory_barrier_intrinsic(
946 builtin_available_predicate avail,
947 enum ir_intrinsic_id id);
948 ir_function_signature *_memory_barrier(const char *intrinsic_name,
949 builtin_available_predicate avail);
950
951 ir_function_signature *_ballot();
952 ir_function_signature *_read_first_invocation(const glsl_type *type);
953 ir_function_signature *_read_invocation(const glsl_type *type);
954
955 ir_function_signature *_shader_clock_intrinsic(builtin_available_predicate avail,
956 const glsl_type *type);
957 ir_function_signature *_shader_clock(builtin_available_predicate avail,
958 const glsl_type *type);
959
960 ir_function_signature *_vote(enum ir_expression_operation opcode);
961
962 #undef B0
963 #undef B1
964 #undef B2
965 #undef B3
966 #undef BA1
967 #undef BA2
968 /** @} */
969 };
970
971 enum image_function_flags {
972 IMAGE_FUNCTION_EMIT_STUB = (1 << 0),
973 IMAGE_FUNCTION_RETURNS_VOID = (1 << 1),
974 IMAGE_FUNCTION_HAS_VECTOR_DATA_TYPE = (1 << 2),
975 IMAGE_FUNCTION_SUPPORTS_FLOAT_DATA_TYPE = (1 << 3),
976 IMAGE_FUNCTION_READ_ONLY = (1 << 4),
977 IMAGE_FUNCTION_WRITE_ONLY = (1 << 5),
978 IMAGE_FUNCTION_AVAIL_ATOMIC = (1 << 6),
979 IMAGE_FUNCTION_MS_ONLY = (1 << 7),
980 IMAGE_FUNCTION_AVAIL_ATOMIC_EXCHANGE = (1 << 8)
981 };
982
983 } /* anonymous namespace */
984
985 /**
986 * Core builtin_builder functionality:
987 * @{
988 */
989 builtin_builder::builtin_builder()
990 : shader(NULL)
991 {
992 mem_ctx = NULL;
993 }
994
995 builtin_builder::~builtin_builder()
996 {
997 ralloc_free(mem_ctx);
998 }
999
1000 ir_function_signature *
1001 builtin_builder::find(_mesa_glsl_parse_state *state,
1002 const char *name, exec_list *actual_parameters)
1003 {
1004 /* The shader currently being compiled requested a built-in function;
1005 * it needs to link against builtin_builder::shader in order to get them.
1006 *
1007 * Even if we don't find a matching signature, we still need to do this so
1008 * that the "no matching signature" error will list potential candidates
1009 * from the available built-ins.
1010 */
1011 state->uses_builtin_functions = true;
1012
1013 ir_function *f = shader->symbols->get_function(name);
1014 if (f == NULL)
1015 return NULL;
1016
1017 ir_function_signature *sig =
1018 f->matching_signature(state, actual_parameters, true);
1019 if (sig == NULL)
1020 return NULL;
1021
1022 return sig;
1023 }
1024
1025 void
1026 builtin_builder::initialize()
1027 {
1028 /* If already initialized, don't do it again. */
1029 if (mem_ctx != NULL)
1030 return;
1031
1032 mem_ctx = ralloc_context(NULL);
1033 create_shader();
1034 create_intrinsics();
1035 create_builtins();
1036 }
1037
1038 void
1039 builtin_builder::release()
1040 {
1041 ralloc_free(mem_ctx);
1042 mem_ctx = NULL;
1043
1044 ralloc_free(shader);
1045 shader = NULL;
1046 }
1047
1048 void
1049 builtin_builder::create_shader()
1050 {
1051 /* The target doesn't actually matter. There's no target for generic
1052 * GLSL utility code that could be linked against any stage, so just
1053 * arbitrarily pick GL_VERTEX_SHADER.
1054 */
1055 shader = _mesa_new_shader(0, MESA_SHADER_VERTEX);
1056 shader->symbols = new(mem_ctx) glsl_symbol_table;
1057 }
1058
1059 /** @} */
1060
1061 /**
1062 * Create ir_function and ir_function_signature objects for each
1063 * intrinsic.
1064 */
1065 void
1066 builtin_builder::create_intrinsics()
1067 {
1068 add_function("__intrinsic_atomic_read",
1069 _atomic_counter_intrinsic(shader_atomic_counters,
1070 ir_intrinsic_atomic_counter_read),
1071 NULL);
1072 add_function("__intrinsic_atomic_increment",
1073 _atomic_counter_intrinsic(shader_atomic_counters,
1074 ir_intrinsic_atomic_counter_increment),
1075 NULL);
1076 add_function("__intrinsic_atomic_predecrement",
1077 _atomic_counter_intrinsic(shader_atomic_counters,
1078 ir_intrinsic_atomic_counter_predecrement),
1079 NULL);
1080
1081 add_function("__intrinsic_atomic_add",
1082 _atomic_intrinsic2(buffer_atomics_supported,
1083 glsl_type::uint_type,
1084 ir_intrinsic_generic_atomic_add),
1085 _atomic_intrinsic2(buffer_atomics_supported,
1086 glsl_type::int_type,
1087 ir_intrinsic_generic_atomic_add),
1088 _atomic_counter_intrinsic1(shader_atomic_counter_ops,
1089 ir_intrinsic_atomic_counter_add),
1090 NULL);
1091 add_function("__intrinsic_atomic_min",
1092 _atomic_intrinsic2(buffer_atomics_supported,
1093 glsl_type::uint_type,
1094 ir_intrinsic_generic_atomic_min),
1095 _atomic_intrinsic2(buffer_atomics_supported,
1096 glsl_type::int_type,
1097 ir_intrinsic_generic_atomic_min),
1098 _atomic_counter_intrinsic1(shader_atomic_counter_ops,
1099 ir_intrinsic_atomic_counter_min),
1100 NULL);
1101 add_function("__intrinsic_atomic_max",
1102 _atomic_intrinsic2(buffer_atomics_supported,
1103 glsl_type::uint_type,
1104 ir_intrinsic_generic_atomic_max),
1105 _atomic_intrinsic2(buffer_atomics_supported,
1106 glsl_type::int_type,
1107 ir_intrinsic_generic_atomic_max),
1108 _atomic_counter_intrinsic1(shader_atomic_counter_ops,
1109 ir_intrinsic_atomic_counter_max),
1110 NULL);
1111 add_function("__intrinsic_atomic_and",
1112 _atomic_intrinsic2(buffer_atomics_supported,
1113 glsl_type::uint_type,
1114 ir_intrinsic_generic_atomic_and),
1115 _atomic_intrinsic2(buffer_atomics_supported,
1116 glsl_type::int_type,
1117 ir_intrinsic_generic_atomic_and),
1118 _atomic_counter_intrinsic1(shader_atomic_counter_ops,
1119 ir_intrinsic_atomic_counter_and),
1120 NULL);
1121 add_function("__intrinsic_atomic_or",
1122 _atomic_intrinsic2(buffer_atomics_supported,
1123 glsl_type::uint_type,
1124 ir_intrinsic_generic_atomic_or),
1125 _atomic_intrinsic2(buffer_atomics_supported,
1126 glsl_type::int_type,
1127 ir_intrinsic_generic_atomic_or),
1128 _atomic_counter_intrinsic1(shader_atomic_counter_ops,
1129 ir_intrinsic_atomic_counter_or),
1130 NULL);
1131 add_function("__intrinsic_atomic_xor",
1132 _atomic_intrinsic2(buffer_atomics_supported,
1133 glsl_type::uint_type,
1134 ir_intrinsic_generic_atomic_xor),
1135 _atomic_intrinsic2(buffer_atomics_supported,
1136 glsl_type::int_type,
1137 ir_intrinsic_generic_atomic_xor),
1138 _atomic_counter_intrinsic1(shader_atomic_counter_ops,
1139 ir_intrinsic_atomic_counter_xor),
1140 NULL);
1141 add_function("__intrinsic_atomic_exchange",
1142 _atomic_intrinsic2(buffer_atomics_supported,
1143 glsl_type::uint_type,
1144 ir_intrinsic_generic_atomic_exchange),
1145 _atomic_intrinsic2(buffer_atomics_supported,
1146 glsl_type::int_type,
1147 ir_intrinsic_generic_atomic_exchange),
1148 _atomic_counter_intrinsic1(shader_atomic_counter_ops,
1149 ir_intrinsic_atomic_counter_exchange),
1150 NULL);
1151 add_function("__intrinsic_atomic_comp_swap",
1152 _atomic_intrinsic3(buffer_atomics_supported,
1153 glsl_type::uint_type,
1154 ir_intrinsic_generic_atomic_comp_swap),
1155 _atomic_intrinsic3(buffer_atomics_supported,
1156 glsl_type::int_type,
1157 ir_intrinsic_generic_atomic_comp_swap),
1158 _atomic_counter_intrinsic2(shader_atomic_counter_ops,
1159 ir_intrinsic_atomic_counter_comp_swap),
1160 NULL);
1161
1162 add_image_functions(false);
1163
1164 add_function("__intrinsic_memory_barrier",
1165 _memory_barrier_intrinsic(shader_image_load_store,
1166 ir_intrinsic_memory_barrier),
1167 NULL);
1168 add_function("__intrinsic_group_memory_barrier",
1169 _memory_barrier_intrinsic(compute_shader,
1170 ir_intrinsic_group_memory_barrier),
1171 NULL);
1172 add_function("__intrinsic_memory_barrier_atomic_counter",
1173 _memory_barrier_intrinsic(compute_shader_supported,
1174 ir_intrinsic_memory_barrier_atomic_counter),
1175 NULL);
1176 add_function("__intrinsic_memory_barrier_buffer",
1177 _memory_barrier_intrinsic(compute_shader_supported,
1178 ir_intrinsic_memory_barrier_buffer),
1179 NULL);
1180 add_function("__intrinsic_memory_barrier_image",
1181 _memory_barrier_intrinsic(compute_shader_supported,
1182 ir_intrinsic_memory_barrier_image),
1183 NULL);
1184 add_function("__intrinsic_memory_barrier_shared",
1185 _memory_barrier_intrinsic(compute_shader,
1186 ir_intrinsic_memory_barrier_shared),
1187 NULL);
1188
1189 add_function("__intrinsic_shader_clock",
1190 _shader_clock_intrinsic(shader_clock,
1191 glsl_type::uvec2_type),
1192 NULL);
1193 }
1194
1195 /**
1196 * Create ir_function and ir_function_signature objects for each built-in.
1197 *
1198 * Contains a list of every available built-in.
1199 */
1200 void
1201 builtin_builder::create_builtins()
1202 {
1203 #define F(NAME) \
1204 add_function(#NAME, \
1205 _##NAME(glsl_type::float_type), \
1206 _##NAME(glsl_type::vec2_type), \
1207 _##NAME(glsl_type::vec3_type), \
1208 _##NAME(glsl_type::vec4_type), \
1209 NULL);
1210
1211 #define FD(NAME) \
1212 add_function(#NAME, \
1213 _##NAME(always_available, glsl_type::float_type), \
1214 _##NAME(always_available, glsl_type::vec2_type), \
1215 _##NAME(always_available, glsl_type::vec3_type), \
1216 _##NAME(always_available, glsl_type::vec4_type), \
1217 _##NAME(fp64, glsl_type::double_type), \
1218 _##NAME(fp64, glsl_type::dvec2_type), \
1219 _##NAME(fp64, glsl_type::dvec3_type), \
1220 _##NAME(fp64, glsl_type::dvec4_type), \
1221 NULL);
1222
1223 #define FD130(NAME) \
1224 add_function(#NAME, \
1225 _##NAME(v130, glsl_type::float_type), \
1226 _##NAME(v130, glsl_type::vec2_type), \
1227 _##NAME(v130, glsl_type::vec3_type), \
1228 _##NAME(v130, glsl_type::vec4_type), \
1229 _##NAME(fp64, glsl_type::double_type), \
1230 _##NAME(fp64, glsl_type::dvec2_type), \
1231 _##NAME(fp64, glsl_type::dvec3_type), \
1232 _##NAME(fp64, glsl_type::dvec4_type), \
1233 NULL);
1234
1235 #define FDGS5(NAME) \
1236 add_function(#NAME, \
1237 _##NAME(gpu_shader5_es, glsl_type::float_type), \
1238 _##NAME(gpu_shader5_es, glsl_type::vec2_type), \
1239 _##NAME(gpu_shader5_es, glsl_type::vec3_type), \
1240 _##NAME(gpu_shader5_es, glsl_type::vec4_type), \
1241 _##NAME(fp64, glsl_type::double_type), \
1242 _##NAME(fp64, glsl_type::dvec2_type), \
1243 _##NAME(fp64, glsl_type::dvec3_type), \
1244 _##NAME(fp64, glsl_type::dvec4_type), \
1245 NULL);
1246
1247 #define FI(NAME) \
1248 add_function(#NAME, \
1249 _##NAME(glsl_type::float_type), \
1250 _##NAME(glsl_type::vec2_type), \
1251 _##NAME(glsl_type::vec3_type), \
1252 _##NAME(glsl_type::vec4_type), \
1253 _##NAME(glsl_type::int_type), \
1254 _##NAME(glsl_type::ivec2_type), \
1255 _##NAME(glsl_type::ivec3_type), \
1256 _##NAME(glsl_type::ivec4_type), \
1257 NULL);
1258
1259 #define FI64(NAME) \
1260 add_function(#NAME, \
1261 _##NAME(always_available, glsl_type::float_type), \
1262 _##NAME(always_available, glsl_type::vec2_type), \
1263 _##NAME(always_available, glsl_type::vec3_type), \
1264 _##NAME(always_available, glsl_type::vec4_type), \
1265 _##NAME(always_available, glsl_type::int_type), \
1266 _##NAME(always_available, glsl_type::ivec2_type), \
1267 _##NAME(always_available, glsl_type::ivec3_type), \
1268 _##NAME(always_available, glsl_type::ivec4_type), \
1269 _##NAME(fp64, glsl_type::double_type), \
1270 _##NAME(fp64, glsl_type::dvec2_type), \
1271 _##NAME(fp64, glsl_type::dvec3_type), \
1272 _##NAME(fp64, glsl_type::dvec4_type), \
1273 _##NAME(int64, glsl_type::int64_t_type), \
1274 _##NAME(int64, glsl_type::i64vec2_type), \
1275 _##NAME(int64, glsl_type::i64vec3_type), \
1276 _##NAME(int64, glsl_type::i64vec4_type), \
1277 NULL);
1278
1279 #define FIUD_VEC(NAME) \
1280 add_function(#NAME, \
1281 _##NAME(always_available, glsl_type::vec2_type), \
1282 _##NAME(always_available, glsl_type::vec3_type), \
1283 _##NAME(always_available, glsl_type::vec4_type), \
1284 \
1285 _##NAME(always_available, glsl_type::ivec2_type), \
1286 _##NAME(always_available, glsl_type::ivec3_type), \
1287 _##NAME(always_available, glsl_type::ivec4_type), \
1288 \
1289 _##NAME(v130, glsl_type::uvec2_type), \
1290 _##NAME(v130, glsl_type::uvec3_type), \
1291 _##NAME(v130, glsl_type::uvec4_type), \
1292 _##NAME(fp64, glsl_type::dvec2_type), \
1293 _##NAME(fp64, glsl_type::dvec3_type), \
1294 _##NAME(fp64, glsl_type::dvec4_type), \
1295 _##NAME(int64, glsl_type::int64_t_type), \
1296 _##NAME(int64, glsl_type::i64vec2_type), \
1297 _##NAME(int64, glsl_type::i64vec3_type), \
1298 _##NAME(int64, glsl_type::i64vec4_type), \
1299 _##NAME(int64, glsl_type::uint64_t_type), \
1300 _##NAME(int64, glsl_type::u64vec2_type), \
1301 _##NAME(int64, glsl_type::u64vec3_type), \
1302 _##NAME(int64, glsl_type::u64vec4_type), \
1303 NULL);
1304
1305 #define IU(NAME) \
1306 add_function(#NAME, \
1307 _##NAME(glsl_type::int_type), \
1308 _##NAME(glsl_type::ivec2_type), \
1309 _##NAME(glsl_type::ivec3_type), \
1310 _##NAME(glsl_type::ivec4_type), \
1311 \
1312 _##NAME(glsl_type::uint_type), \
1313 _##NAME(glsl_type::uvec2_type), \
1314 _##NAME(glsl_type::uvec3_type), \
1315 _##NAME(glsl_type::uvec4_type), \
1316 NULL);
1317
1318 #define FIUBD_VEC(NAME) \
1319 add_function(#NAME, \
1320 _##NAME(always_available, glsl_type::vec2_type), \
1321 _##NAME(always_available, glsl_type::vec3_type), \
1322 _##NAME(always_available, glsl_type::vec4_type), \
1323 \
1324 _##NAME(always_available, glsl_type::ivec2_type), \
1325 _##NAME(always_available, glsl_type::ivec3_type), \
1326 _##NAME(always_available, glsl_type::ivec4_type), \
1327 \
1328 _##NAME(v130, glsl_type::uvec2_type), \
1329 _##NAME(v130, glsl_type::uvec3_type), \
1330 _##NAME(v130, glsl_type::uvec4_type), \
1331 \
1332 _##NAME(always_available, glsl_type::bvec2_type), \
1333 _##NAME(always_available, glsl_type::bvec3_type), \
1334 _##NAME(always_available, glsl_type::bvec4_type), \
1335 \
1336 _##NAME(fp64, glsl_type::dvec2_type), \
1337 _##NAME(fp64, glsl_type::dvec3_type), \
1338 _##NAME(fp64, glsl_type::dvec4_type), \
1339 _##NAME(int64, glsl_type::int64_t_type), \
1340 _##NAME(int64, glsl_type::i64vec2_type), \
1341 _##NAME(int64, glsl_type::i64vec3_type), \
1342 _##NAME(int64, glsl_type::i64vec4_type), \
1343 _##NAME(int64, glsl_type::uint64_t_type), \
1344 _##NAME(int64, glsl_type::u64vec2_type), \
1345 _##NAME(int64, glsl_type::u64vec3_type), \
1346 _##NAME(int64, glsl_type::u64vec4_type), \
1347 NULL);
1348
1349 #define FIUD2_MIXED(NAME) \
1350 add_function(#NAME, \
1351 _##NAME(always_available, glsl_type::float_type, glsl_type::float_type), \
1352 _##NAME(always_available, glsl_type::vec2_type, glsl_type::float_type), \
1353 _##NAME(always_available, glsl_type::vec3_type, glsl_type::float_type), \
1354 _##NAME(always_available, glsl_type::vec4_type, glsl_type::float_type), \
1355 \
1356 _##NAME(always_available, glsl_type::vec2_type, glsl_type::vec2_type), \
1357 _##NAME(always_available, glsl_type::vec3_type, glsl_type::vec3_type), \
1358 _##NAME(always_available, glsl_type::vec4_type, glsl_type::vec4_type), \
1359 \
1360 _##NAME(always_available, glsl_type::int_type, glsl_type::int_type), \
1361 _##NAME(always_available, glsl_type::ivec2_type, glsl_type::int_type), \
1362 _##NAME(always_available, glsl_type::ivec3_type, glsl_type::int_type), \
1363 _##NAME(always_available, glsl_type::ivec4_type, glsl_type::int_type), \
1364 \
1365 _##NAME(always_available, glsl_type::ivec2_type, glsl_type::ivec2_type), \
1366 _##NAME(always_available, glsl_type::ivec3_type, glsl_type::ivec3_type), \
1367 _##NAME(always_available, glsl_type::ivec4_type, glsl_type::ivec4_type), \
1368 \
1369 _##NAME(v130, glsl_type::uint_type, glsl_type::uint_type), \
1370 _##NAME(v130, glsl_type::uvec2_type, glsl_type::uint_type), \
1371 _##NAME(v130, glsl_type::uvec3_type, glsl_type::uint_type), \
1372 _##NAME(v130, glsl_type::uvec4_type, glsl_type::uint_type), \
1373 \
1374 _##NAME(v130, glsl_type::uvec2_type, glsl_type::uvec2_type), \
1375 _##NAME(v130, glsl_type::uvec3_type, glsl_type::uvec3_type), \
1376 _##NAME(v130, glsl_type::uvec4_type, glsl_type::uvec4_type), \
1377 \
1378 _##NAME(fp64, glsl_type::double_type, glsl_type::double_type), \
1379 _##NAME(fp64, glsl_type::dvec2_type, glsl_type::double_type), \
1380 _##NAME(fp64, glsl_type::dvec3_type, glsl_type::double_type), \
1381 _##NAME(fp64, glsl_type::dvec4_type, glsl_type::double_type), \
1382 _##NAME(fp64, glsl_type::dvec2_type, glsl_type::dvec2_type), \
1383 _##NAME(fp64, glsl_type::dvec3_type, glsl_type::dvec3_type), \
1384 _##NAME(fp64, glsl_type::dvec4_type, glsl_type::dvec4_type), \
1385 \
1386 _##NAME(int64, glsl_type::int64_t_type, glsl_type::int64_t_type), \
1387 _##NAME(int64, glsl_type::i64vec2_type, glsl_type::int64_t_type), \
1388 _##NAME(int64, glsl_type::i64vec3_type, glsl_type::int64_t_type), \
1389 _##NAME(int64, glsl_type::i64vec4_type, glsl_type::int64_t_type), \
1390 _##NAME(int64, glsl_type::i64vec2_type, glsl_type::i64vec2_type), \
1391 _##NAME(int64, glsl_type::i64vec3_type, glsl_type::i64vec3_type), \
1392 _##NAME(int64, glsl_type::i64vec4_type, glsl_type::i64vec4_type), \
1393 _##NAME(int64, glsl_type::uint64_t_type, glsl_type::uint64_t_type), \
1394 _##NAME(int64, glsl_type::u64vec2_type, glsl_type::uint64_t_type), \
1395 _##NAME(int64, glsl_type::u64vec3_type, glsl_type::uint64_t_type), \
1396 _##NAME(int64, glsl_type::u64vec4_type, glsl_type::uint64_t_type), \
1397 _##NAME(int64, glsl_type::u64vec2_type, glsl_type::u64vec2_type), \
1398 _##NAME(int64, glsl_type::u64vec3_type, glsl_type::u64vec3_type), \
1399 _##NAME(int64, glsl_type::u64vec4_type, glsl_type::u64vec4_type), \
1400 NULL);
1401
1402 F(radians)
1403 F(degrees)
1404 F(sin)
1405 F(cos)
1406 F(tan)
1407 F(asin)
1408 F(acos)
1409
1410 add_function("atan",
1411 _atan(glsl_type::float_type),
1412 _atan(glsl_type::vec2_type),
1413 _atan(glsl_type::vec3_type),
1414 _atan(glsl_type::vec4_type),
1415 _atan2(glsl_type::float_type),
1416 _atan2(glsl_type::vec2_type),
1417 _atan2(glsl_type::vec3_type),
1418 _atan2(glsl_type::vec4_type),
1419 NULL);
1420
1421 F(sinh)
1422 F(cosh)
1423 F(tanh)
1424 F(asinh)
1425 F(acosh)
1426 F(atanh)
1427 F(pow)
1428 F(exp)
1429 F(log)
1430 F(exp2)
1431 F(log2)
1432 FD(sqrt)
1433 FD(inversesqrt)
1434 FI64(abs)
1435 FI64(sign)
1436 FD(floor)
1437 FD(trunc)
1438 FD(round)
1439 FD(roundEven)
1440 FD(ceil)
1441 FD(fract)
1442
1443 add_function("mod",
1444 _mod(always_available, glsl_type::float_type, glsl_type::float_type),
1445 _mod(always_available, glsl_type::vec2_type, glsl_type::float_type),
1446 _mod(always_available, glsl_type::vec3_type, glsl_type::float_type),
1447 _mod(always_available, glsl_type::vec4_type, glsl_type::float_type),
1448
1449 _mod(always_available, glsl_type::vec2_type, glsl_type::vec2_type),
1450 _mod(always_available, glsl_type::vec3_type, glsl_type::vec3_type),
1451 _mod(always_available, glsl_type::vec4_type, glsl_type::vec4_type),
1452
1453 _mod(fp64, glsl_type::double_type, glsl_type::double_type),
1454 _mod(fp64, glsl_type::dvec2_type, glsl_type::double_type),
1455 _mod(fp64, glsl_type::dvec3_type, glsl_type::double_type),
1456 _mod(fp64, glsl_type::dvec4_type, glsl_type::double_type),
1457
1458 _mod(fp64, glsl_type::dvec2_type, glsl_type::dvec2_type),
1459 _mod(fp64, glsl_type::dvec3_type, glsl_type::dvec3_type),
1460 _mod(fp64, glsl_type::dvec4_type, glsl_type::dvec4_type),
1461 NULL);
1462
1463 FD(modf)
1464
1465 FIUD2_MIXED(min)
1466 FIUD2_MIXED(max)
1467 FIUD2_MIXED(clamp)
1468
1469 add_function("mix",
1470 _mix_lrp(always_available, glsl_type::float_type, glsl_type::float_type),
1471 _mix_lrp(always_available, glsl_type::vec2_type, glsl_type::float_type),
1472 _mix_lrp(always_available, glsl_type::vec3_type, glsl_type::float_type),
1473 _mix_lrp(always_available, glsl_type::vec4_type, glsl_type::float_type),
1474
1475 _mix_lrp(always_available, glsl_type::vec2_type, glsl_type::vec2_type),
1476 _mix_lrp(always_available, glsl_type::vec3_type, glsl_type::vec3_type),
1477 _mix_lrp(always_available, glsl_type::vec4_type, glsl_type::vec4_type),
1478
1479 _mix_lrp(fp64, glsl_type::double_type, glsl_type::double_type),
1480 _mix_lrp(fp64, glsl_type::dvec2_type, glsl_type::double_type),
1481 _mix_lrp(fp64, glsl_type::dvec3_type, glsl_type::double_type),
1482 _mix_lrp(fp64, glsl_type::dvec4_type, glsl_type::double_type),
1483
1484 _mix_lrp(fp64, glsl_type::dvec2_type, glsl_type::dvec2_type),
1485 _mix_lrp(fp64, glsl_type::dvec3_type, glsl_type::dvec3_type),
1486 _mix_lrp(fp64, glsl_type::dvec4_type, glsl_type::dvec4_type),
1487
1488 _mix_sel(v130, glsl_type::float_type, glsl_type::bool_type),
1489 _mix_sel(v130, glsl_type::vec2_type, glsl_type::bvec2_type),
1490 _mix_sel(v130, glsl_type::vec3_type, glsl_type::bvec3_type),
1491 _mix_sel(v130, glsl_type::vec4_type, glsl_type::bvec4_type),
1492
1493 _mix_sel(fp64, glsl_type::double_type, glsl_type::bool_type),
1494 _mix_sel(fp64, glsl_type::dvec2_type, glsl_type::bvec2_type),
1495 _mix_sel(fp64, glsl_type::dvec3_type, glsl_type::bvec3_type),
1496 _mix_sel(fp64, glsl_type::dvec4_type, glsl_type::bvec4_type),
1497
1498 _mix_sel(shader_integer_mix, glsl_type::int_type, glsl_type::bool_type),
1499 _mix_sel(shader_integer_mix, glsl_type::ivec2_type, glsl_type::bvec2_type),
1500 _mix_sel(shader_integer_mix, glsl_type::ivec3_type, glsl_type::bvec3_type),
1501 _mix_sel(shader_integer_mix, glsl_type::ivec4_type, glsl_type::bvec4_type),
1502
1503 _mix_sel(shader_integer_mix, glsl_type::uint_type, glsl_type::bool_type),
1504 _mix_sel(shader_integer_mix, glsl_type::uvec2_type, glsl_type::bvec2_type),
1505 _mix_sel(shader_integer_mix, glsl_type::uvec3_type, glsl_type::bvec3_type),
1506 _mix_sel(shader_integer_mix, glsl_type::uvec4_type, glsl_type::bvec4_type),
1507
1508 _mix_sel(shader_integer_mix, glsl_type::bool_type, glsl_type::bool_type),
1509 _mix_sel(shader_integer_mix, glsl_type::bvec2_type, glsl_type::bvec2_type),
1510 _mix_sel(shader_integer_mix, glsl_type::bvec3_type, glsl_type::bvec3_type),
1511 _mix_sel(shader_integer_mix, glsl_type::bvec4_type, glsl_type::bvec4_type),
1512
1513 _mix_sel(int64, glsl_type::int64_t_type, glsl_type::bool_type),
1514 _mix_sel(int64, glsl_type::i64vec2_type, glsl_type::bvec2_type),
1515 _mix_sel(int64, glsl_type::i64vec3_type, glsl_type::bvec3_type),
1516 _mix_sel(int64, glsl_type::i64vec4_type, glsl_type::bvec4_type),
1517
1518 _mix_sel(int64, glsl_type::uint64_t_type, glsl_type::bool_type),
1519 _mix_sel(int64, glsl_type::u64vec2_type, glsl_type::bvec2_type),
1520 _mix_sel(int64, glsl_type::u64vec3_type, glsl_type::bvec3_type),
1521 _mix_sel(int64, glsl_type::u64vec4_type, glsl_type::bvec4_type),
1522 NULL);
1523
1524 add_function("step",
1525 _step(always_available, glsl_type::float_type, glsl_type::float_type),
1526 _step(always_available, glsl_type::float_type, glsl_type::vec2_type),
1527 _step(always_available, glsl_type::float_type, glsl_type::vec3_type),
1528 _step(always_available, glsl_type::float_type, glsl_type::vec4_type),
1529
1530 _step(always_available, glsl_type::vec2_type, glsl_type::vec2_type),
1531 _step(always_available, glsl_type::vec3_type, glsl_type::vec3_type),
1532 _step(always_available, glsl_type::vec4_type, glsl_type::vec4_type),
1533 _step(fp64, glsl_type::double_type, glsl_type::double_type),
1534 _step(fp64, glsl_type::double_type, glsl_type::dvec2_type),
1535 _step(fp64, glsl_type::double_type, glsl_type::dvec3_type),
1536 _step(fp64, glsl_type::double_type, glsl_type::dvec4_type),
1537
1538 _step(fp64, glsl_type::dvec2_type, glsl_type::dvec2_type),
1539 _step(fp64, glsl_type::dvec3_type, glsl_type::dvec3_type),
1540 _step(fp64, glsl_type::dvec4_type, glsl_type::dvec4_type),
1541 NULL);
1542
1543 add_function("smoothstep",
1544 _smoothstep(always_available, glsl_type::float_type, glsl_type::float_type),
1545 _smoothstep(always_available, glsl_type::float_type, glsl_type::vec2_type),
1546 _smoothstep(always_available, glsl_type::float_type, glsl_type::vec3_type),
1547 _smoothstep(always_available, glsl_type::float_type, glsl_type::vec4_type),
1548
1549 _smoothstep(always_available, glsl_type::vec2_type, glsl_type::vec2_type),
1550 _smoothstep(always_available, glsl_type::vec3_type, glsl_type::vec3_type),
1551 _smoothstep(always_available, glsl_type::vec4_type, glsl_type::vec4_type),
1552 _smoothstep(fp64, glsl_type::double_type, glsl_type::double_type),
1553 _smoothstep(fp64, glsl_type::double_type, glsl_type::dvec2_type),
1554 _smoothstep(fp64, glsl_type::double_type, glsl_type::dvec3_type),
1555 _smoothstep(fp64, glsl_type::double_type, glsl_type::dvec4_type),
1556
1557 _smoothstep(fp64, glsl_type::dvec2_type, glsl_type::dvec2_type),
1558 _smoothstep(fp64, glsl_type::dvec3_type, glsl_type::dvec3_type),
1559 _smoothstep(fp64, glsl_type::dvec4_type, glsl_type::dvec4_type),
1560 NULL);
1561
1562 FD130(isnan)
1563 FD130(isinf)
1564
1565 F(floatBitsToInt)
1566 F(floatBitsToUint)
1567 add_function("intBitsToFloat",
1568 _intBitsToFloat(glsl_type::int_type),
1569 _intBitsToFloat(glsl_type::ivec2_type),
1570 _intBitsToFloat(glsl_type::ivec3_type),
1571 _intBitsToFloat(glsl_type::ivec4_type),
1572 NULL);
1573 add_function("uintBitsToFloat",
1574 _uintBitsToFloat(glsl_type::uint_type),
1575 _uintBitsToFloat(glsl_type::uvec2_type),
1576 _uintBitsToFloat(glsl_type::uvec3_type),
1577 _uintBitsToFloat(glsl_type::uvec4_type),
1578 NULL);
1579
1580 add_function("doubleBitsToInt64",
1581 _doubleBitsToInt64(int64_fp64, glsl_type::double_type),
1582 _doubleBitsToInt64(int64_fp64, glsl_type::dvec2_type),
1583 _doubleBitsToInt64(int64_fp64, glsl_type::dvec3_type),
1584 _doubleBitsToInt64(int64_fp64, glsl_type::dvec4_type),
1585 NULL);
1586
1587 add_function("doubleBitsToUint64",
1588 _doubleBitsToUint64(int64_fp64, glsl_type::double_type),
1589 _doubleBitsToUint64(int64_fp64, glsl_type::dvec2_type),
1590 _doubleBitsToUint64(int64_fp64, glsl_type::dvec3_type),
1591 _doubleBitsToUint64(int64_fp64, glsl_type::dvec4_type),
1592 NULL);
1593
1594 add_function("int64BitsToDouble",
1595 _int64BitsToDouble(int64_fp64, glsl_type::int64_t_type),
1596 _int64BitsToDouble(int64_fp64, glsl_type::i64vec2_type),
1597 _int64BitsToDouble(int64_fp64, glsl_type::i64vec3_type),
1598 _int64BitsToDouble(int64_fp64, glsl_type::i64vec4_type),
1599 NULL);
1600
1601 add_function("uint64BitsToDouble",
1602 _uint64BitsToDouble(int64_fp64, glsl_type::uint64_t_type),
1603 _uint64BitsToDouble(int64_fp64, glsl_type::u64vec2_type),
1604 _uint64BitsToDouble(int64_fp64, glsl_type::u64vec3_type),
1605 _uint64BitsToDouble(int64_fp64, glsl_type::u64vec4_type),
1606 NULL);
1607
1608 add_function("packUnorm2x16", _packUnorm2x16(shader_packing_or_es3_or_gpu_shader5), NULL);
1609 add_function("packSnorm2x16", _packSnorm2x16(shader_packing_or_es3), NULL);
1610 add_function("packUnorm4x8", _packUnorm4x8(shader_packing_or_es31_or_gpu_shader5), NULL);
1611 add_function("packSnorm4x8", _packSnorm4x8(shader_packing_or_es31_or_gpu_shader5), NULL);
1612 add_function("unpackUnorm2x16", _unpackUnorm2x16(shader_packing_or_es3_or_gpu_shader5), NULL);
1613 add_function("unpackSnorm2x16", _unpackSnorm2x16(shader_packing_or_es3), NULL);
1614 add_function("unpackUnorm4x8", _unpackUnorm4x8(shader_packing_or_es31_or_gpu_shader5), NULL);
1615 add_function("unpackSnorm4x8", _unpackSnorm4x8(shader_packing_or_es31_or_gpu_shader5), NULL);
1616 add_function("packHalf2x16", _packHalf2x16(shader_packing_or_es3), NULL);
1617 add_function("unpackHalf2x16", _unpackHalf2x16(shader_packing_or_es3), NULL);
1618 add_function("packDouble2x32", _packDouble2x32(fp64), NULL);
1619 add_function("unpackDouble2x32", _unpackDouble2x32(fp64), NULL);
1620
1621 add_function("packInt2x32", _packInt2x32(int64), NULL);
1622 add_function("unpackInt2x32", _unpackInt2x32(int64), NULL);
1623 add_function("packUint2x32", _packUint2x32(int64), NULL);
1624 add_function("unpackUint2x32", _unpackUint2x32(int64), NULL);
1625
1626 FD(length)
1627 FD(distance)
1628 FD(dot)
1629
1630 add_function("cross", _cross(always_available, glsl_type::vec3_type),
1631 _cross(fp64, glsl_type::dvec3_type), NULL);
1632
1633 FD(normalize)
1634 add_function("ftransform", _ftransform(), NULL);
1635 FD(faceforward)
1636 FD(reflect)
1637 FD(refract)
1638 // ...
1639 add_function("matrixCompMult",
1640 _matrixCompMult(always_available, glsl_type::mat2_type),
1641 _matrixCompMult(always_available, glsl_type::mat3_type),
1642 _matrixCompMult(always_available, glsl_type::mat4_type),
1643 _matrixCompMult(always_available, glsl_type::mat2x3_type),
1644 _matrixCompMult(always_available, glsl_type::mat2x4_type),
1645 _matrixCompMult(always_available, glsl_type::mat3x2_type),
1646 _matrixCompMult(always_available, glsl_type::mat3x4_type),
1647 _matrixCompMult(always_available, glsl_type::mat4x2_type),
1648 _matrixCompMult(always_available, glsl_type::mat4x3_type),
1649 _matrixCompMult(fp64, glsl_type::dmat2_type),
1650 _matrixCompMult(fp64, glsl_type::dmat3_type),
1651 _matrixCompMult(fp64, glsl_type::dmat4_type),
1652 _matrixCompMult(fp64, glsl_type::dmat2x3_type),
1653 _matrixCompMult(fp64, glsl_type::dmat2x4_type),
1654 _matrixCompMult(fp64, glsl_type::dmat3x2_type),
1655 _matrixCompMult(fp64, glsl_type::dmat3x4_type),
1656 _matrixCompMult(fp64, glsl_type::dmat4x2_type),
1657 _matrixCompMult(fp64, glsl_type::dmat4x3_type),
1658 NULL);
1659 add_function("outerProduct",
1660 _outerProduct(v120, glsl_type::mat2_type),
1661 _outerProduct(v120, glsl_type::mat3_type),
1662 _outerProduct(v120, glsl_type::mat4_type),
1663 _outerProduct(v120, glsl_type::mat2x3_type),
1664 _outerProduct(v120, glsl_type::mat2x4_type),
1665 _outerProduct(v120, glsl_type::mat3x2_type),
1666 _outerProduct(v120, glsl_type::mat3x4_type),
1667 _outerProduct(v120, glsl_type::mat4x2_type),
1668 _outerProduct(v120, glsl_type::mat4x3_type),
1669 _outerProduct(fp64, glsl_type::dmat2_type),
1670 _outerProduct(fp64, glsl_type::dmat3_type),
1671 _outerProduct(fp64, glsl_type::dmat4_type),
1672 _outerProduct(fp64, glsl_type::dmat2x3_type),
1673 _outerProduct(fp64, glsl_type::dmat2x4_type),
1674 _outerProduct(fp64, glsl_type::dmat3x2_type),
1675 _outerProduct(fp64, glsl_type::dmat3x4_type),
1676 _outerProduct(fp64, glsl_type::dmat4x2_type),
1677 _outerProduct(fp64, glsl_type::dmat4x3_type),
1678 NULL);
1679 add_function("determinant",
1680 _determinant_mat2(v120, glsl_type::mat2_type),
1681 _determinant_mat3(v120, glsl_type::mat3_type),
1682 _determinant_mat4(v120, glsl_type::mat4_type),
1683 _determinant_mat2(fp64, glsl_type::dmat2_type),
1684 _determinant_mat3(fp64, glsl_type::dmat3_type),
1685 _determinant_mat4(fp64, glsl_type::dmat4_type),
1686
1687 NULL);
1688 add_function("inverse",
1689 _inverse_mat2(v140_or_es3, glsl_type::mat2_type),
1690 _inverse_mat3(v140_or_es3, glsl_type::mat3_type),
1691 _inverse_mat4(v140_or_es3, glsl_type::mat4_type),
1692 _inverse_mat2(fp64, glsl_type::dmat2_type),
1693 _inverse_mat3(fp64, glsl_type::dmat3_type),
1694 _inverse_mat4(fp64, glsl_type::dmat4_type),
1695 NULL);
1696 add_function("transpose",
1697 _transpose(v120, glsl_type::mat2_type),
1698 _transpose(v120, glsl_type::mat3_type),
1699 _transpose(v120, glsl_type::mat4_type),
1700 _transpose(v120, glsl_type::mat2x3_type),
1701 _transpose(v120, glsl_type::mat2x4_type),
1702 _transpose(v120, glsl_type::mat3x2_type),
1703 _transpose(v120, glsl_type::mat3x4_type),
1704 _transpose(v120, glsl_type::mat4x2_type),
1705 _transpose(v120, glsl_type::mat4x3_type),
1706 _transpose(fp64, glsl_type::dmat2_type),
1707 _transpose(fp64, glsl_type::dmat3_type),
1708 _transpose(fp64, glsl_type::dmat4_type),
1709 _transpose(fp64, glsl_type::dmat2x3_type),
1710 _transpose(fp64, glsl_type::dmat2x4_type),
1711 _transpose(fp64, glsl_type::dmat3x2_type),
1712 _transpose(fp64, glsl_type::dmat3x4_type),
1713 _transpose(fp64, glsl_type::dmat4x2_type),
1714 _transpose(fp64, glsl_type::dmat4x3_type),
1715 NULL);
1716 FIUD_VEC(lessThan)
1717 FIUD_VEC(lessThanEqual)
1718 FIUD_VEC(greaterThan)
1719 FIUD_VEC(greaterThanEqual)
1720 FIUBD_VEC(notEqual)
1721 FIUBD_VEC(equal)
1722
1723 add_function("any",
1724 _any(glsl_type::bvec2_type),
1725 _any(glsl_type::bvec3_type),
1726 _any(glsl_type::bvec4_type),
1727 NULL);
1728
1729 add_function("all",
1730 _all(glsl_type::bvec2_type),
1731 _all(glsl_type::bvec3_type),
1732 _all(glsl_type::bvec4_type),
1733 NULL);
1734
1735 add_function("not",
1736 _not(glsl_type::bvec2_type),
1737 _not(glsl_type::bvec3_type),
1738 _not(glsl_type::bvec4_type),
1739 NULL);
1740
1741 add_function("textureSize",
1742 _textureSize(v130, glsl_type::int_type, glsl_type::sampler1D_type),
1743 _textureSize(v130, glsl_type::int_type, glsl_type::isampler1D_type),
1744 _textureSize(v130, glsl_type::int_type, glsl_type::usampler1D_type),
1745
1746 _textureSize(v130, glsl_type::ivec2_type, glsl_type::sampler2D_type),
1747 _textureSize(v130, glsl_type::ivec2_type, glsl_type::isampler2D_type),
1748 _textureSize(v130, glsl_type::ivec2_type, glsl_type::usampler2D_type),
1749
1750 _textureSize(v130, glsl_type::ivec3_type, glsl_type::sampler3D_type),
1751 _textureSize(v130, glsl_type::ivec3_type, glsl_type::isampler3D_type),
1752 _textureSize(v130, glsl_type::ivec3_type, glsl_type::usampler3D_type),
1753
1754 _textureSize(v130, glsl_type::ivec2_type, glsl_type::samplerCube_type),
1755 _textureSize(v130, glsl_type::ivec2_type, glsl_type::isamplerCube_type),
1756 _textureSize(v130, glsl_type::ivec2_type, glsl_type::usamplerCube_type),
1757
1758 _textureSize(v130, glsl_type::int_type, glsl_type::sampler1DShadow_type),
1759 _textureSize(v130, glsl_type::ivec2_type, glsl_type::sampler2DShadow_type),
1760 _textureSize(v130, glsl_type::ivec2_type, glsl_type::samplerCubeShadow_type),
1761
1762 _textureSize(v130, glsl_type::ivec2_type, glsl_type::sampler1DArray_type),
1763 _textureSize(v130, glsl_type::ivec2_type, glsl_type::isampler1DArray_type),
1764 _textureSize(v130, glsl_type::ivec2_type, glsl_type::usampler1DArray_type),
1765 _textureSize(v130, glsl_type::ivec3_type, glsl_type::sampler2DArray_type),
1766 _textureSize(v130, glsl_type::ivec3_type, glsl_type::isampler2DArray_type),
1767 _textureSize(v130, glsl_type::ivec3_type, glsl_type::usampler2DArray_type),
1768
1769 _textureSize(v130, glsl_type::ivec2_type, glsl_type::sampler1DArrayShadow_type),
1770 _textureSize(v130, glsl_type::ivec3_type, glsl_type::sampler2DArrayShadow_type),
1771
1772 _textureSize(texture_cube_map_array, glsl_type::ivec3_type, glsl_type::samplerCubeArray_type),
1773 _textureSize(texture_cube_map_array, glsl_type::ivec3_type, glsl_type::isamplerCubeArray_type),
1774 _textureSize(texture_cube_map_array, glsl_type::ivec3_type, glsl_type::usamplerCubeArray_type),
1775 _textureSize(texture_cube_map_array, glsl_type::ivec3_type, glsl_type::samplerCubeArrayShadow_type),
1776
1777 _textureSize(v130, glsl_type::ivec2_type, glsl_type::sampler2DRect_type),
1778 _textureSize(v130, glsl_type::ivec2_type, glsl_type::isampler2DRect_type),
1779 _textureSize(v130, glsl_type::ivec2_type, glsl_type::usampler2DRect_type),
1780 _textureSize(v130, glsl_type::ivec2_type, glsl_type::sampler2DRectShadow_type),
1781
1782 _textureSize(texture_buffer, glsl_type::int_type, glsl_type::samplerBuffer_type),
1783 _textureSize(texture_buffer, glsl_type::int_type, glsl_type::isamplerBuffer_type),
1784 _textureSize(texture_buffer, glsl_type::int_type, glsl_type::usamplerBuffer_type),
1785 _textureSize(texture_multisample, glsl_type::ivec2_type, glsl_type::sampler2DMS_type),
1786 _textureSize(texture_multisample, glsl_type::ivec2_type, glsl_type::isampler2DMS_type),
1787 _textureSize(texture_multisample, glsl_type::ivec2_type, glsl_type::usampler2DMS_type),
1788
1789 _textureSize(texture_multisample_array, glsl_type::ivec3_type, glsl_type::sampler2DMSArray_type),
1790 _textureSize(texture_multisample_array, glsl_type::ivec3_type, glsl_type::isampler2DMSArray_type),
1791 _textureSize(texture_multisample_array, glsl_type::ivec3_type, glsl_type::usampler2DMSArray_type),
1792 NULL);
1793
1794 add_function("textureSamples",
1795 _textureSamples(glsl_type::sampler2DMS_type),
1796 _textureSamples(glsl_type::isampler2DMS_type),
1797 _textureSamples(glsl_type::usampler2DMS_type),
1798
1799 _textureSamples(glsl_type::sampler2DMSArray_type),
1800 _textureSamples(glsl_type::isampler2DMSArray_type),
1801 _textureSamples(glsl_type::usampler2DMSArray_type),
1802 NULL);
1803
1804 add_function("texture",
1805 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type),
1806 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::float_type),
1807 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::float_type),
1808
1809 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type),
1810 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type),
1811 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type),
1812
1813 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type),
1814 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec3_type),
1815 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec3_type),
1816
1817 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type),
1818 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isamplerCube_type, glsl_type::vec3_type),
1819 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usamplerCube_type, glsl_type::vec3_type),
1820
1821 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type),
1822 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type),
1823 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::samplerCubeShadow_type, glsl_type::vec4_type),
1824
1825 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type),
1826 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::vec2_type),
1827 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::vec2_type),
1828
1829 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type),
1830 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type),
1831 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type),
1832
1833 _texture(ir_tex, texture_cube_map_array, glsl_type::vec4_type, glsl_type::samplerCubeArray_type, glsl_type::vec4_type),
1834 _texture(ir_tex, texture_cube_map_array, glsl_type::ivec4_type, glsl_type::isamplerCubeArray_type, glsl_type::vec4_type),
1835 _texture(ir_tex, texture_cube_map_array, glsl_type::uvec4_type, glsl_type::usamplerCubeArray_type, glsl_type::vec4_type),
1836
1837 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type),
1838 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec4_type),
1839 /* samplerCubeArrayShadow is special; it has an extra parameter
1840 * for the shadow comparator since there is no vec5 type.
1841 */
1842 _textureCubeArrayShadow(texture_cube_map_array, glsl_type::samplerCubeArrayShadow_type),
1843
1844 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type),
1845 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type),
1846 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type),
1847
1848 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec3_type),
1849
1850 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type),
1851 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::float_type),
1852 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::float_type),
1853
1854 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type),
1855 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type),
1856 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type),
1857
1858 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type),
1859 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec3_type),
1860 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec3_type),
1861
1862 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type),
1863 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isamplerCube_type, glsl_type::vec3_type),
1864 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usamplerCube_type, glsl_type::vec3_type),
1865
1866 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type),
1867 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type),
1868 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::samplerCubeShadow_type, glsl_type::vec4_type),
1869
1870 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type),
1871 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::vec2_type),
1872 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::vec2_type),
1873
1874 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type),
1875 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type),
1876 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type),
1877
1878 _texture(ir_txb, fs_texture_cube_map_array, glsl_type::vec4_type, glsl_type::samplerCubeArray_type, glsl_type::vec4_type),
1879 _texture(ir_txb, fs_texture_cube_map_array, glsl_type::ivec4_type, glsl_type::isamplerCubeArray_type, glsl_type::vec4_type),
1880 _texture(ir_txb, fs_texture_cube_map_array, glsl_type::uvec4_type, glsl_type::usamplerCubeArray_type, glsl_type::vec4_type),
1881
1882 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type),
1883 NULL);
1884
1885 add_function("textureLod",
1886 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type),
1887 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::float_type),
1888 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::float_type),
1889
1890 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type),
1891 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type),
1892 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type),
1893
1894 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type),
1895 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec3_type),
1896 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec3_type),
1897
1898 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type),
1899 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isamplerCube_type, glsl_type::vec3_type),
1900 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usamplerCube_type, glsl_type::vec3_type),
1901
1902 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type),
1903 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type),
1904
1905 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type),
1906 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::vec2_type),
1907 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::vec2_type),
1908
1909 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type),
1910 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type),
1911 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type),
1912
1913 _texture(ir_txl, texture_cube_map_array, glsl_type::vec4_type, glsl_type::samplerCubeArray_type, glsl_type::vec4_type),
1914 _texture(ir_txl, texture_cube_map_array, glsl_type::ivec4_type, glsl_type::isamplerCubeArray_type, glsl_type::vec4_type),
1915 _texture(ir_txl, texture_cube_map_array, glsl_type::uvec4_type, glsl_type::usamplerCubeArray_type, glsl_type::vec4_type),
1916
1917 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type),
1918 NULL);
1919
1920 add_function("textureOffset",
1921 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type, TEX_OFFSET),
1922 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::float_type, TEX_OFFSET),
1923 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::float_type, TEX_OFFSET),
1924
1925 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
1926 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
1927 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
1928
1929 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
1930 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
1931 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
1932
1933 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET),
1934 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET),
1935 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET),
1936
1937 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec3_type, TEX_OFFSET),
1938
1939 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type, TEX_OFFSET),
1940 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type, TEX_OFFSET),
1941
1942 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
1943 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
1944 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
1945
1946 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
1947 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
1948 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
1949
1950 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type, TEX_OFFSET),
1951 /* The next one was forgotten in GLSL 1.30 spec. It's from
1952 * EXT_gpu_shader4 originally. It was added in 4.30 with the
1953 * wrong syntax. This was corrected in 4.40. 4.30 indicates
1954 * that it was intended to be included previously, so allow it
1955 * in 1.30.
1956 */
1957 _texture(ir_tex, v130_desktop, glsl_type::float_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec4_type, TEX_OFFSET),
1958
1959 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type, TEX_OFFSET),
1960 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::float_type, TEX_OFFSET),
1961 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::float_type, TEX_OFFSET),
1962
1963 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
1964 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
1965 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
1966
1967 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
1968 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
1969 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
1970
1971 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type, TEX_OFFSET),
1972 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type, TEX_OFFSET),
1973
1974 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
1975 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
1976 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
1977
1978 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
1979 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
1980 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
1981
1982 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type, TEX_OFFSET),
1983 NULL);
1984
1985 add_function("textureProj",
1986 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
1987 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
1988 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
1989 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
1990 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
1991 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
1992
1993 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
1994 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
1995 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
1996 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
1997 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
1998 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
1999
2000 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2001 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2002 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2003
2004 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2005 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2006
2007 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT),
2008 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT),
2009 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT),
2010 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT),
2011 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT),
2012 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT),
2013
2014 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2015
2016 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2017 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2018 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2019 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2020 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2021 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2022
2023 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2024 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2025 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2026 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2027 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2028 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2029
2030 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2031 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2032 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2033
2034 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2035 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2036 NULL);
2037
2038 add_function("texelFetch",
2039 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::int_type),
2040 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::int_type),
2041 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::int_type),
2042
2043 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::ivec2_type),
2044 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::ivec2_type),
2045 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::ivec2_type),
2046
2047 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::ivec3_type),
2048 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::ivec3_type),
2049 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::ivec3_type),
2050
2051 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::ivec2_type),
2052 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::ivec2_type),
2053 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::ivec2_type),
2054
2055 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::ivec2_type),
2056 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::ivec2_type),
2057 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::ivec2_type),
2058
2059 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::ivec3_type),
2060 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::ivec3_type),
2061 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::ivec3_type),
2062
2063 _texelFetch(texture_buffer, glsl_type::vec4_type, glsl_type::samplerBuffer_type, glsl_type::int_type),
2064 _texelFetch(texture_buffer, glsl_type::ivec4_type, glsl_type::isamplerBuffer_type, glsl_type::int_type),
2065 _texelFetch(texture_buffer, glsl_type::uvec4_type, glsl_type::usamplerBuffer_type, glsl_type::int_type),
2066
2067 _texelFetch(texture_multisample, glsl_type::vec4_type, glsl_type::sampler2DMS_type, glsl_type::ivec2_type),
2068 _texelFetch(texture_multisample, glsl_type::ivec4_type, glsl_type::isampler2DMS_type, glsl_type::ivec2_type),
2069 _texelFetch(texture_multisample, glsl_type::uvec4_type, glsl_type::usampler2DMS_type, glsl_type::ivec2_type),
2070
2071 _texelFetch(texture_multisample_array, glsl_type::vec4_type, glsl_type::sampler2DMSArray_type, glsl_type::ivec3_type),
2072 _texelFetch(texture_multisample_array, glsl_type::ivec4_type, glsl_type::isampler2DMSArray_type, glsl_type::ivec3_type),
2073 _texelFetch(texture_multisample_array, glsl_type::uvec4_type, glsl_type::usampler2DMSArray_type, glsl_type::ivec3_type),
2074 NULL);
2075
2076 add_function("texelFetchOffset",
2077 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::int_type, glsl_type::int_type),
2078 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::int_type, glsl_type::int_type),
2079 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::int_type, glsl_type::int_type),
2080
2081 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::ivec2_type, glsl_type::ivec2_type),
2082 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::ivec2_type, glsl_type::ivec2_type),
2083 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::ivec2_type, glsl_type::ivec2_type),
2084
2085 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::ivec3_type, glsl_type::ivec3_type),
2086 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::ivec3_type, glsl_type::ivec3_type),
2087 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::ivec3_type, glsl_type::ivec3_type),
2088
2089 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::ivec2_type, glsl_type::ivec2_type),
2090 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::ivec2_type, glsl_type::ivec2_type),
2091 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::ivec2_type, glsl_type::ivec2_type),
2092
2093 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::ivec2_type, glsl_type::int_type),
2094 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::ivec2_type, glsl_type::int_type),
2095 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::ivec2_type, glsl_type::int_type),
2096
2097 _texelFetch(v130, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::ivec3_type, glsl_type::ivec2_type),
2098 _texelFetch(v130, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::ivec3_type, glsl_type::ivec2_type),
2099 _texelFetch(v130, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::ivec3_type, glsl_type::ivec2_type),
2100
2101 NULL);
2102
2103 add_function("textureProjOffset",
2104 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2105 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2106 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2107 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2108 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2109 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2110
2111 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2112 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2113 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2114 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2115 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2116 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2117
2118 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2119 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2120 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2121
2122 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2123 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2124
2125 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2126 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2127 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2128 _texture(ir_tex, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2129 _texture(ir_tex, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2130 _texture(ir_tex, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2131
2132 _texture(ir_tex, v130, glsl_type::float_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2133
2134 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2135 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2136 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2137 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2138 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2139 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2140
2141 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2142 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2143 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2144 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2145 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2146 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2147
2148 _texture(ir_txb, v130_fs_only, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2149 _texture(ir_txb, v130_fs_only, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2150 _texture(ir_txb, v130_fs_only, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2151
2152 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2153 _texture(ir_txb, v130_fs_only, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2154 NULL);
2155
2156 add_function("textureLodOffset",
2157 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type, TEX_OFFSET),
2158 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::float_type, TEX_OFFSET),
2159 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::float_type, TEX_OFFSET),
2160
2161 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
2162 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
2163 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
2164
2165 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
2166 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
2167 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
2168
2169 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type, TEX_OFFSET),
2170 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type, TEX_OFFSET),
2171
2172 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
2173 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
2174 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
2175
2176 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
2177 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
2178 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
2179
2180 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type, TEX_OFFSET),
2181 NULL);
2182
2183 add_function("textureProjLod",
2184 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2185 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2186 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2187 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2188 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2189 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2190
2191 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2192 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2193 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2194 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2195 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2196 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2197
2198 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2199 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2200 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2201
2202 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2203 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2204 NULL);
2205
2206 add_function("textureProjLodOffset",
2207 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2208 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2209 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2210 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2211 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2212 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2213
2214 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2215 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2216 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2217 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2218 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2219 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2220
2221 _texture(ir_txl, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2222 _texture(ir_txl, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2223 _texture(ir_txl, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2224
2225 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2226 _texture(ir_txl, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2227 NULL);
2228
2229 add_function("textureGrad",
2230 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type),
2231 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::float_type),
2232 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::float_type),
2233
2234 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type),
2235 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type),
2236 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type),
2237
2238 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type),
2239 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec3_type),
2240 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec3_type),
2241
2242 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type),
2243 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isamplerCube_type, glsl_type::vec3_type),
2244 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usamplerCube_type, glsl_type::vec3_type),
2245
2246 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type),
2247 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type),
2248 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type),
2249
2250 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec3_type),
2251
2252 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type),
2253 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type),
2254 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::samplerCubeShadow_type, glsl_type::vec4_type),
2255
2256 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type),
2257 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::vec2_type),
2258 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::vec2_type),
2259
2260 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type),
2261 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type),
2262 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type),
2263
2264 _texture(ir_txd, texture_cube_map_array, glsl_type::vec4_type, glsl_type::samplerCubeArray_type, glsl_type::vec4_type),
2265 _texture(ir_txd, texture_cube_map_array, glsl_type::ivec4_type, glsl_type::isamplerCubeArray_type, glsl_type::vec4_type),
2266 _texture(ir_txd, texture_cube_map_array, glsl_type::uvec4_type, glsl_type::usamplerCubeArray_type, glsl_type::vec4_type),
2267
2268 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type),
2269 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec4_type),
2270 NULL);
2271
2272 add_function("textureGradOffset",
2273 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type, TEX_OFFSET),
2274 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::float_type, TEX_OFFSET),
2275 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::float_type, TEX_OFFSET),
2276
2277 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
2278 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
2279 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
2280
2281 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
2282 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
2283 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec3_type, TEX_OFFSET),
2284
2285 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET),
2286 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET),
2287 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET),
2288
2289 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec3_type, TEX_OFFSET),
2290
2291 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type, TEX_OFFSET),
2292 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type, TEX_OFFSET),
2293
2294 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
2295 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
2296 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler1DArray_type, glsl_type::vec2_type, TEX_OFFSET),
2297
2298 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
2299 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
2300 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
2301
2302 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type, TEX_OFFSET),
2303 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec4_type, TEX_OFFSET),
2304 NULL);
2305
2306 add_function("textureProjGrad",
2307 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2308 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2309 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2310 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2311 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2312 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2313
2314 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2315 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2316 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2317 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2318 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2319 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2320
2321 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2322 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2323 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2324
2325 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT),
2326 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT),
2327 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT),
2328 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT),
2329 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT),
2330 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT),
2331
2332 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2333
2334 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2335 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2336 NULL);
2337
2338 add_function("textureProjGradOffset",
2339 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2340 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2341 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec2_type, TEX_PROJECT | TEX_OFFSET),
2342 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2343 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2344 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler1D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2345
2346 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2347 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2348 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2349 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2350 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2351 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2352
2353 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2354 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2355 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler3D_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2356
2357 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2358 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2359 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT | TEX_OFFSET),
2360 _texture(ir_txd, v130, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2361 _texture(ir_txd, v130, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2362 _texture(ir_txd, v130, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2363
2364 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2365
2366 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2367 _texture(ir_txd, v130, glsl_type::float_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT | TEX_OFFSET),
2368 NULL);
2369
2370 add_function("EmitVertex", _EmitVertex(), NULL);
2371 add_function("EndPrimitive", _EndPrimitive(), NULL);
2372 add_function("EmitStreamVertex",
2373 _EmitStreamVertex(gs_streams, glsl_type::uint_type),
2374 _EmitStreamVertex(gs_streams, glsl_type::int_type),
2375 NULL);
2376 add_function("EndStreamPrimitive",
2377 _EndStreamPrimitive(gs_streams, glsl_type::uint_type),
2378 _EndStreamPrimitive(gs_streams, glsl_type::int_type),
2379 NULL);
2380 add_function("barrier", _barrier(), NULL);
2381
2382 add_function("textureQueryLOD",
2383 _textureQueryLod(texture_query_lod, glsl_type::sampler1D_type, glsl_type::float_type),
2384 _textureQueryLod(texture_query_lod, glsl_type::isampler1D_type, glsl_type::float_type),
2385 _textureQueryLod(texture_query_lod, glsl_type::usampler1D_type, glsl_type::float_type),
2386
2387 _textureQueryLod(texture_query_lod, glsl_type::sampler2D_type, glsl_type::vec2_type),
2388 _textureQueryLod(texture_query_lod, glsl_type::isampler2D_type, glsl_type::vec2_type),
2389 _textureQueryLod(texture_query_lod, glsl_type::usampler2D_type, glsl_type::vec2_type),
2390
2391 _textureQueryLod(texture_query_lod, glsl_type::sampler3D_type, glsl_type::vec3_type),
2392 _textureQueryLod(texture_query_lod, glsl_type::isampler3D_type, glsl_type::vec3_type),
2393 _textureQueryLod(texture_query_lod, glsl_type::usampler3D_type, glsl_type::vec3_type),
2394
2395 _textureQueryLod(texture_query_lod, glsl_type::samplerCube_type, glsl_type::vec3_type),
2396 _textureQueryLod(texture_query_lod, glsl_type::isamplerCube_type, glsl_type::vec3_type),
2397 _textureQueryLod(texture_query_lod, glsl_type::usamplerCube_type, glsl_type::vec3_type),
2398
2399 _textureQueryLod(texture_query_lod, glsl_type::sampler1DArray_type, glsl_type::float_type),
2400 _textureQueryLod(texture_query_lod, glsl_type::isampler1DArray_type, glsl_type::float_type),
2401 _textureQueryLod(texture_query_lod, glsl_type::usampler1DArray_type, glsl_type::float_type),
2402
2403 _textureQueryLod(texture_query_lod, glsl_type::sampler2DArray_type, glsl_type::vec2_type),
2404 _textureQueryLod(texture_query_lod, glsl_type::isampler2DArray_type, glsl_type::vec2_type),
2405 _textureQueryLod(texture_query_lod, glsl_type::usampler2DArray_type, glsl_type::vec2_type),
2406
2407 _textureQueryLod(texture_query_lod, glsl_type::samplerCubeArray_type, glsl_type::vec3_type),
2408 _textureQueryLod(texture_query_lod, glsl_type::isamplerCubeArray_type, glsl_type::vec3_type),
2409 _textureQueryLod(texture_query_lod, glsl_type::usamplerCubeArray_type, glsl_type::vec3_type),
2410
2411 _textureQueryLod(texture_query_lod, glsl_type::sampler1DShadow_type, glsl_type::float_type),
2412 _textureQueryLod(texture_query_lod, glsl_type::sampler2DShadow_type, glsl_type::vec2_type),
2413 _textureQueryLod(texture_query_lod, glsl_type::samplerCubeShadow_type, glsl_type::vec3_type),
2414 _textureQueryLod(texture_query_lod, glsl_type::sampler1DArrayShadow_type, glsl_type::float_type),
2415 _textureQueryLod(texture_query_lod, glsl_type::sampler2DArrayShadow_type, glsl_type::vec2_type),
2416 _textureQueryLod(texture_query_lod, glsl_type::samplerCubeArrayShadow_type, glsl_type::vec3_type),
2417 NULL);
2418
2419 add_function("textureQueryLod",
2420 _textureQueryLod(v400_fs_only, glsl_type::sampler1D_type, glsl_type::float_type),
2421 _textureQueryLod(v400_fs_only, glsl_type::isampler1D_type, glsl_type::float_type),
2422 _textureQueryLod(v400_fs_only, glsl_type::usampler1D_type, glsl_type::float_type),
2423
2424 _textureQueryLod(v400_fs_only, glsl_type::sampler2D_type, glsl_type::vec2_type),
2425 _textureQueryLod(v400_fs_only, glsl_type::isampler2D_type, glsl_type::vec2_type),
2426 _textureQueryLod(v400_fs_only, glsl_type::usampler2D_type, glsl_type::vec2_type),
2427
2428 _textureQueryLod(v400_fs_only, glsl_type::sampler3D_type, glsl_type::vec3_type),
2429 _textureQueryLod(v400_fs_only, glsl_type::isampler3D_type, glsl_type::vec3_type),
2430 _textureQueryLod(v400_fs_only, glsl_type::usampler3D_type, glsl_type::vec3_type),
2431
2432 _textureQueryLod(v400_fs_only, glsl_type::samplerCube_type, glsl_type::vec3_type),
2433 _textureQueryLod(v400_fs_only, glsl_type::isamplerCube_type, glsl_type::vec3_type),
2434 _textureQueryLod(v400_fs_only, glsl_type::usamplerCube_type, glsl_type::vec3_type),
2435
2436 _textureQueryLod(v400_fs_only, glsl_type::sampler1DArray_type, glsl_type::float_type),
2437 _textureQueryLod(v400_fs_only, glsl_type::isampler1DArray_type, glsl_type::float_type),
2438 _textureQueryLod(v400_fs_only, glsl_type::usampler1DArray_type, glsl_type::float_type),
2439
2440 _textureQueryLod(v400_fs_only, glsl_type::sampler2DArray_type, glsl_type::vec2_type),
2441 _textureQueryLod(v400_fs_only, glsl_type::isampler2DArray_type, glsl_type::vec2_type),
2442 _textureQueryLod(v400_fs_only, glsl_type::usampler2DArray_type, glsl_type::vec2_type),
2443
2444 _textureQueryLod(v400_fs_only, glsl_type::samplerCubeArray_type, glsl_type::vec3_type),
2445 _textureQueryLod(v400_fs_only, glsl_type::isamplerCubeArray_type, glsl_type::vec3_type),
2446 _textureQueryLod(v400_fs_only, glsl_type::usamplerCubeArray_type, glsl_type::vec3_type),
2447
2448 _textureQueryLod(v400_fs_only, glsl_type::sampler1DShadow_type, glsl_type::float_type),
2449 _textureQueryLod(v400_fs_only, glsl_type::sampler2DShadow_type, glsl_type::vec2_type),
2450 _textureQueryLod(v400_fs_only, glsl_type::samplerCubeShadow_type, glsl_type::vec3_type),
2451 _textureQueryLod(v400_fs_only, glsl_type::sampler1DArrayShadow_type, glsl_type::float_type),
2452 _textureQueryLod(v400_fs_only, glsl_type::sampler2DArrayShadow_type, glsl_type::vec2_type),
2453 _textureQueryLod(v400_fs_only, glsl_type::samplerCubeArrayShadow_type, glsl_type::vec3_type),
2454 NULL);
2455
2456 add_function("textureQueryLevels",
2457 _textureQueryLevels(glsl_type::sampler1D_type),
2458 _textureQueryLevels(glsl_type::sampler2D_type),
2459 _textureQueryLevels(glsl_type::sampler3D_type),
2460 _textureQueryLevels(glsl_type::samplerCube_type),
2461 _textureQueryLevels(glsl_type::sampler1DArray_type),
2462 _textureQueryLevels(glsl_type::sampler2DArray_type),
2463 _textureQueryLevels(glsl_type::samplerCubeArray_type),
2464 _textureQueryLevels(glsl_type::sampler1DShadow_type),
2465 _textureQueryLevels(glsl_type::sampler2DShadow_type),
2466 _textureQueryLevels(glsl_type::samplerCubeShadow_type),
2467 _textureQueryLevels(glsl_type::sampler1DArrayShadow_type),
2468 _textureQueryLevels(glsl_type::sampler2DArrayShadow_type),
2469 _textureQueryLevels(glsl_type::samplerCubeArrayShadow_type),
2470
2471 _textureQueryLevels(glsl_type::isampler1D_type),
2472 _textureQueryLevels(glsl_type::isampler2D_type),
2473 _textureQueryLevels(glsl_type::isampler3D_type),
2474 _textureQueryLevels(glsl_type::isamplerCube_type),
2475 _textureQueryLevels(glsl_type::isampler1DArray_type),
2476 _textureQueryLevels(glsl_type::isampler2DArray_type),
2477 _textureQueryLevels(glsl_type::isamplerCubeArray_type),
2478
2479 _textureQueryLevels(glsl_type::usampler1D_type),
2480 _textureQueryLevels(glsl_type::usampler2D_type),
2481 _textureQueryLevels(glsl_type::usampler3D_type),
2482 _textureQueryLevels(glsl_type::usamplerCube_type),
2483 _textureQueryLevels(glsl_type::usampler1DArray_type),
2484 _textureQueryLevels(glsl_type::usampler2DArray_type),
2485 _textureQueryLevels(glsl_type::usamplerCubeArray_type),
2486
2487 NULL);
2488
2489 add_function("textureSamplesIdenticalEXT",
2490 _textureSamplesIdentical(texture_samples_identical, glsl_type::sampler2DMS_type, glsl_type::ivec2_type),
2491 _textureSamplesIdentical(texture_samples_identical, glsl_type::isampler2DMS_type, glsl_type::ivec2_type),
2492 _textureSamplesIdentical(texture_samples_identical, glsl_type::usampler2DMS_type, glsl_type::ivec2_type),
2493
2494 _textureSamplesIdentical(texture_samples_identical_array, glsl_type::sampler2DMSArray_type, glsl_type::ivec3_type),
2495 _textureSamplesIdentical(texture_samples_identical_array, glsl_type::isampler2DMSArray_type, glsl_type::ivec3_type),
2496 _textureSamplesIdentical(texture_samples_identical_array, glsl_type::usampler2DMSArray_type, glsl_type::ivec3_type),
2497 NULL);
2498
2499 add_function("texture1D",
2500 _texture(ir_tex, v110, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type),
2501 _texture(ir_txb, v110_fs_only, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type),
2502 NULL);
2503
2504 add_function("texture1DArray",
2505 _texture(ir_tex, texture_array, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type),
2506 _texture(ir_txb, fs_texture_array, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type),
2507 NULL);
2508
2509 add_function("texture1DProj",
2510 _texture(ir_tex, v110, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2511 _texture(ir_tex, v110, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2512 _texture(ir_txb, v110_fs_only, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2513 _texture(ir_txb, v110_fs_only, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2514 NULL);
2515
2516 add_function("texture1DLod",
2517 _texture(ir_txl, tex1d_lod, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type),
2518 NULL);
2519
2520 add_function("texture1DArrayLod",
2521 _texture(ir_txl, texture_array_lod, glsl_type::vec4_type, glsl_type::sampler1DArray_type, glsl_type::vec2_type),
2522 NULL);
2523
2524 add_function("texture1DProjLod",
2525 _texture(ir_txl, tex1d_lod, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2526 _texture(ir_txl, tex1d_lod, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2527 NULL);
2528
2529 add_function("texture2D",
2530 _texture(ir_tex, always_available, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type),
2531 _texture(ir_txb, fs_only, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type),
2532 _texture(ir_tex, texture_external, glsl_type::vec4_type, glsl_type::samplerExternalOES_type, glsl_type::vec2_type),
2533 NULL);
2534
2535 add_function("texture2DArray",
2536 _texture(ir_tex, texture_array, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type),
2537 _texture(ir_txb, fs_texture_array, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type),
2538 NULL);
2539
2540 add_function("texture2DProj",
2541 _texture(ir_tex, always_available, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2542 _texture(ir_tex, always_available, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2543 _texture(ir_txb, fs_only, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2544 _texture(ir_txb, fs_only, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2545 _texture(ir_tex, texture_external, glsl_type::vec4_type, glsl_type::samplerExternalOES_type, glsl_type::vec3_type, TEX_PROJECT),
2546 _texture(ir_tex, texture_external, glsl_type::vec4_type, glsl_type::samplerExternalOES_type, glsl_type::vec4_type, TEX_PROJECT),
2547 NULL);
2548
2549 add_function("texture2DLod",
2550 _texture(ir_txl, lod_exists_in_stage, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type),
2551 NULL);
2552
2553 add_function("texture2DArrayLod",
2554 _texture(ir_txl, texture_array_lod, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type),
2555 NULL);
2556
2557 add_function("texture2DProjLod",
2558 _texture(ir_txl, lod_exists_in_stage, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2559 _texture(ir_txl, lod_exists_in_stage, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2560 NULL);
2561
2562 add_function("texture3D",
2563 _texture(ir_tex, tex3d, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type),
2564 _texture(ir_txb, fs_tex3d, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type),
2565 NULL);
2566
2567 add_function("texture3DProj",
2568 _texture(ir_tex, tex3d, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2569 _texture(ir_txb, fs_tex3d, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2570 NULL);
2571
2572 add_function("texture3DLod",
2573 _texture(ir_txl, tex3d_lod, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type),
2574 NULL);
2575
2576 add_function("texture3DProjLod",
2577 _texture(ir_txl, tex3d_lod, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2578 NULL);
2579
2580 add_function("textureCube",
2581 _texture(ir_tex, always_available, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type),
2582 _texture(ir_txb, fs_only, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type),
2583 NULL);
2584
2585 add_function("textureCubeLod",
2586 _texture(ir_txl, lod_exists_in_stage, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type),
2587 NULL);
2588
2589 add_function("texture2DRect",
2590 _texture(ir_tex, texture_rectangle, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type),
2591 NULL);
2592
2593 add_function("texture2DRectProj",
2594 _texture(ir_tex, texture_rectangle, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT),
2595 _texture(ir_tex, texture_rectangle, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT),
2596 NULL);
2597
2598 add_function("shadow1D",
2599 _texture(ir_tex, v110, glsl_type::vec4_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type),
2600 _texture(ir_txb, v110_fs_only, glsl_type::vec4_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type),
2601 NULL);
2602
2603 add_function("shadow1DArray",
2604 _texture(ir_tex, texture_array, glsl_type::vec4_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type),
2605 _texture(ir_txb, fs_texture_array, glsl_type::vec4_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type),
2606 NULL);
2607
2608 add_function("shadow2D",
2609 _texture(ir_tex, v110, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type),
2610 _texture(ir_txb, v110_fs_only, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type),
2611 NULL);
2612
2613 add_function("shadow2DArray",
2614 _texture(ir_tex, texture_array, glsl_type::vec4_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec4_type),
2615 _texture(ir_txb, fs_texture_array, glsl_type::vec4_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec4_type),
2616 NULL);
2617
2618 add_function("shadow1DProj",
2619 _texture(ir_tex, v110, glsl_type::vec4_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2620 _texture(ir_txb, v110_fs_only, glsl_type::vec4_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2621 NULL);
2622
2623 add_function("shadow2DProj",
2624 _texture(ir_tex, v110, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2625 _texture(ir_txb, v110_fs_only, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2626 NULL);
2627
2628 add_function("shadow1DLod",
2629 _texture(ir_txl, v110_lod, glsl_type::vec4_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type),
2630 NULL);
2631
2632 add_function("shadow2DLod",
2633 _texture(ir_txl, v110_lod, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type),
2634 NULL);
2635
2636 add_function("shadow1DArrayLod",
2637 _texture(ir_txl, texture_array_lod, glsl_type::vec4_type, glsl_type::sampler1DArrayShadow_type, glsl_type::vec3_type),
2638 NULL);
2639
2640 add_function("shadow1DProjLod",
2641 _texture(ir_txl, v110_lod, glsl_type::vec4_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2642 NULL);
2643
2644 add_function("shadow2DProjLod",
2645 _texture(ir_txl, v110_lod, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2646 NULL);
2647
2648 add_function("shadow2DRect",
2649 _texture(ir_tex, texture_rectangle, glsl_type::vec4_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec3_type),
2650 NULL);
2651
2652 add_function("shadow2DRectProj",
2653 _texture(ir_tex, texture_rectangle, glsl_type::vec4_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2654 NULL);
2655
2656 add_function("texture1DGradARB",
2657 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::float_type),
2658 NULL);
2659
2660 add_function("texture1DProjGradARB",
2661 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec2_type, TEX_PROJECT),
2662 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler1D_type, glsl_type::vec4_type, TEX_PROJECT),
2663 NULL);
2664
2665 add_function("texture2DGradARB",
2666 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type),
2667 NULL);
2668
2669 add_function("texture2DProjGradARB",
2670 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec3_type, TEX_PROJECT),
2671 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec4_type, TEX_PROJECT),
2672 NULL);
2673
2674 add_function("texture3DGradARB",
2675 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec3_type),
2676 NULL);
2677
2678 add_function("texture3DProjGradARB",
2679 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler3D_type, glsl_type::vec4_type, TEX_PROJECT),
2680 NULL);
2681
2682 add_function("textureCubeGradARB",
2683 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type),
2684 NULL);
2685
2686 add_function("shadow1DGradARB",
2687 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler1DShadow_type, glsl_type::vec3_type),
2688 NULL);
2689
2690 add_function("shadow1DProjGradARB",
2691 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler1DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2692 NULL);
2693
2694 add_function("shadow2DGradARB",
2695 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec3_type),
2696 NULL);
2697
2698 add_function("shadow2DProjGradARB",
2699 _texture(ir_txd, shader_texture_lod, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2700 NULL);
2701
2702 add_function("texture2DRectGradARB",
2703 _texture(ir_txd, shader_texture_lod_and_rect, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type),
2704 NULL);
2705
2706 add_function("texture2DRectProjGradARB",
2707 _texture(ir_txd, shader_texture_lod_and_rect, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec3_type, TEX_PROJECT),
2708 _texture(ir_txd, shader_texture_lod_and_rect, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec4_type, TEX_PROJECT),
2709 NULL);
2710
2711 add_function("shadow2DRectGradARB",
2712 _texture(ir_txd, shader_texture_lod_and_rect, glsl_type::vec4_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec3_type),
2713 NULL);
2714
2715 add_function("shadow2DRectProjGradARB",
2716 _texture(ir_txd, shader_texture_lod_and_rect, glsl_type::vec4_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec4_type, TEX_PROJECT),
2717 NULL);
2718
2719 add_function("textureGather",
2720 _texture(ir_tg4, texture_gather_or_es31, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type),
2721 _texture(ir_tg4, texture_gather_or_es31, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type),
2722 _texture(ir_tg4, texture_gather_or_es31, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type),
2723
2724 _texture(ir_tg4, gpu_shader5, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type),
2725 _texture(ir_tg4, gpu_shader5, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type),
2726 _texture(ir_tg4, gpu_shader5, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type),
2727
2728 _texture(ir_tg4, texture_gather_or_es31, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type),
2729 _texture(ir_tg4, texture_gather_or_es31, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type),
2730 _texture(ir_tg4, texture_gather_or_es31, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type),
2731
2732 _texture(ir_tg4, texture_gather_or_es31, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type),
2733 _texture(ir_tg4, texture_gather_or_es31, glsl_type::ivec4_type, glsl_type::isamplerCube_type, glsl_type::vec3_type),
2734 _texture(ir_tg4, texture_gather_or_es31, glsl_type::uvec4_type, glsl_type::usamplerCube_type, glsl_type::vec3_type),
2735
2736 _texture(ir_tg4, texture_gather_cube_map_array, glsl_type::vec4_type, glsl_type::samplerCubeArray_type, glsl_type::vec4_type),
2737 _texture(ir_tg4, texture_gather_cube_map_array, glsl_type::ivec4_type, glsl_type::isamplerCubeArray_type, glsl_type::vec4_type),
2738 _texture(ir_tg4, texture_gather_cube_map_array, glsl_type::uvec4_type, glsl_type::usamplerCubeArray_type, glsl_type::vec4_type),
2739
2740 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_COMPONENT),
2741 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_COMPONENT),
2742 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_COMPONENT),
2743
2744 _texture(ir_tg4, gpu_shader5, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type, TEX_COMPONENT),
2745 _texture(ir_tg4, gpu_shader5, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type, TEX_COMPONENT),
2746 _texture(ir_tg4, gpu_shader5, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type, TEX_COMPONENT),
2747
2748 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_COMPONENT),
2749 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_COMPONENT),
2750 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_COMPONENT),
2751
2752 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::vec4_type, glsl_type::samplerCube_type, glsl_type::vec3_type, TEX_COMPONENT),
2753 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::ivec4_type, glsl_type::isamplerCube_type, glsl_type::vec3_type, TEX_COMPONENT),
2754 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::uvec4_type, glsl_type::usamplerCube_type, glsl_type::vec3_type, TEX_COMPONENT),
2755
2756 _texture(ir_tg4, gpu_shader5_or_OES_texture_cube_map_array, glsl_type::vec4_type, glsl_type::samplerCubeArray_type, glsl_type::vec4_type, TEX_COMPONENT),
2757 _texture(ir_tg4, gpu_shader5_or_OES_texture_cube_map_array, glsl_type::ivec4_type, glsl_type::isamplerCubeArray_type, glsl_type::vec4_type, TEX_COMPONENT),
2758 _texture(ir_tg4, gpu_shader5_or_OES_texture_cube_map_array, glsl_type::uvec4_type, glsl_type::usamplerCubeArray_type, glsl_type::vec4_type, TEX_COMPONENT),
2759
2760 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec2_type),
2761 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::vec4_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec3_type),
2762 _texture(ir_tg4, gpu_shader5_or_es31, glsl_type::vec4_type, glsl_type::samplerCubeShadow_type, glsl_type::vec3_type),
2763 _texture(ir_tg4, gpu_shader5_or_OES_texture_cube_map_array, glsl_type::vec4_type, glsl_type::samplerCubeArrayShadow_type, glsl_type::vec4_type),
2764 _texture(ir_tg4, gpu_shader5, glsl_type::vec4_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec2_type),
2765 NULL);
2766
2767 add_function("textureGatherOffset",
2768 _texture(ir_tg4, texture_gather_only_or_es31, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
2769 _texture(ir_tg4, texture_gather_only_or_es31, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
2770 _texture(ir_tg4, texture_gather_only_or_es31, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET),
2771
2772 _texture(ir_tg4, texture_gather_only_or_es31, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
2773 _texture(ir_tg4, texture_gather_only_or_es31, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
2774 _texture(ir_tg4, texture_gather_only_or_es31, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET),
2775
2776 _texture(ir_tg4, es31_not_gs5, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET | TEX_COMPONENT),
2777 _texture(ir_tg4, es31_not_gs5, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET | TEX_COMPONENT),
2778 _texture(ir_tg4, es31_not_gs5, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET | TEX_COMPONENT),
2779
2780 _texture(ir_tg4, es31_not_gs5, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET | TEX_COMPONENT),
2781 _texture(ir_tg4, es31_not_gs5, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET | TEX_COMPONENT),
2782 _texture(ir_tg4, es31_not_gs5, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET | TEX_COMPONENT),
2783
2784 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST),
2785 _texture(ir_tg4, gpu_shader5_es, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST),
2786 _texture(ir_tg4, gpu_shader5_es, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST),
2787
2788 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_NONCONST),
2789 _texture(ir_tg4, gpu_shader5_es, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_NONCONST),
2790 _texture(ir_tg4, gpu_shader5_es, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_NONCONST),
2791
2792 _texture(ir_tg4, gpu_shader5, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST),
2793 _texture(ir_tg4, gpu_shader5, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST),
2794 _texture(ir_tg4, gpu_shader5, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST),
2795
2796 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST | TEX_COMPONENT),
2797 _texture(ir_tg4, gpu_shader5_es, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST | TEX_COMPONENT),
2798 _texture(ir_tg4, gpu_shader5_es, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST | TEX_COMPONENT),
2799
2800 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_NONCONST | TEX_COMPONENT),
2801 _texture(ir_tg4, gpu_shader5_es, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_NONCONST | TEX_COMPONENT),
2802 _texture(ir_tg4, gpu_shader5_es, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_NONCONST | TEX_COMPONENT),
2803
2804 _texture(ir_tg4, gpu_shader5, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST | TEX_COMPONENT),
2805 _texture(ir_tg4, gpu_shader5, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST | TEX_COMPONENT),
2806 _texture(ir_tg4, gpu_shader5, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST | TEX_COMPONENT),
2807
2808 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST),
2809 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec3_type, TEX_OFFSET_NONCONST),
2810 _texture(ir_tg4, gpu_shader5, glsl_type::vec4_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec2_type, TEX_OFFSET_NONCONST),
2811
2812 _texture(ir_tg4, es31_not_gs5, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec2_type, TEX_OFFSET),
2813 _texture(ir_tg4, es31_not_gs5, glsl_type::vec4_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec3_type, TEX_OFFSET),
2814 NULL);
2815
2816 add_function("textureGatherOffsets",
2817 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY),
2818 _texture(ir_tg4, gpu_shader5_es, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY),
2819 _texture(ir_tg4, gpu_shader5_es, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY),
2820
2821 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2D_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY | TEX_COMPONENT),
2822 _texture(ir_tg4, gpu_shader5_es, glsl_type::ivec4_type, glsl_type::isampler2D_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY | TEX_COMPONENT),
2823 _texture(ir_tg4, gpu_shader5_es, glsl_type::uvec4_type, glsl_type::usampler2D_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY | TEX_COMPONENT),
2824
2825 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_ARRAY),
2826 _texture(ir_tg4, gpu_shader5_es, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_ARRAY),
2827 _texture(ir_tg4, gpu_shader5_es, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_ARRAY),
2828
2829 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_ARRAY | TEX_COMPONENT),
2830 _texture(ir_tg4, gpu_shader5_es, glsl_type::ivec4_type, glsl_type::isampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_ARRAY | TEX_COMPONENT),
2831 _texture(ir_tg4, gpu_shader5_es, glsl_type::uvec4_type, glsl_type::usampler2DArray_type, glsl_type::vec3_type, TEX_OFFSET_ARRAY | TEX_COMPONENT),
2832
2833 _texture(ir_tg4, gpu_shader5, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY),
2834 _texture(ir_tg4, gpu_shader5, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY),
2835 _texture(ir_tg4, gpu_shader5, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY),
2836
2837 _texture(ir_tg4, gpu_shader5, glsl_type::vec4_type, glsl_type::sampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY | TEX_COMPONENT),
2838 _texture(ir_tg4, gpu_shader5, glsl_type::ivec4_type, glsl_type::isampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY | TEX_COMPONENT),
2839 _texture(ir_tg4, gpu_shader5, glsl_type::uvec4_type, glsl_type::usampler2DRect_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY | TEX_COMPONENT),
2840
2841 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2DShadow_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY),
2842 _texture(ir_tg4, gpu_shader5_es, glsl_type::vec4_type, glsl_type::sampler2DArrayShadow_type, glsl_type::vec3_type, TEX_OFFSET_ARRAY),
2843 _texture(ir_tg4, gpu_shader5, glsl_type::vec4_type, glsl_type::sampler2DRectShadow_type, glsl_type::vec2_type, TEX_OFFSET_ARRAY),
2844 NULL);
2845
2846 F(dFdx)
2847 F(dFdy)
2848 F(fwidth)
2849 F(dFdxCoarse)
2850 F(dFdyCoarse)
2851 F(fwidthCoarse)
2852 F(dFdxFine)
2853 F(dFdyFine)
2854 F(fwidthFine)
2855 F(noise1)
2856 F(noise2)
2857 F(noise3)
2858 F(noise4)
2859
2860 IU(bitfieldExtract)
2861 IU(bitfieldInsert)
2862 IU(bitfieldReverse)
2863 IU(bitCount)
2864 IU(findLSB)
2865 IU(findMSB)
2866 FDGS5(fma)
2867
2868 add_function("ldexp",
2869 _ldexp(glsl_type::float_type, glsl_type::int_type),
2870 _ldexp(glsl_type::vec2_type, glsl_type::ivec2_type),
2871 _ldexp(glsl_type::vec3_type, glsl_type::ivec3_type),
2872 _ldexp(glsl_type::vec4_type, glsl_type::ivec4_type),
2873 _ldexp(glsl_type::double_type, glsl_type::int_type),
2874 _ldexp(glsl_type::dvec2_type, glsl_type::ivec2_type),
2875 _ldexp(glsl_type::dvec3_type, glsl_type::ivec3_type),
2876 _ldexp(glsl_type::dvec4_type, glsl_type::ivec4_type),
2877 NULL);
2878
2879 add_function("frexp",
2880 _frexp(glsl_type::float_type, glsl_type::int_type),
2881 _frexp(glsl_type::vec2_type, glsl_type::ivec2_type),
2882 _frexp(glsl_type::vec3_type, glsl_type::ivec3_type),
2883 _frexp(glsl_type::vec4_type, glsl_type::ivec4_type),
2884 _dfrexp(glsl_type::double_type, glsl_type::int_type),
2885 _dfrexp(glsl_type::dvec2_type, glsl_type::ivec2_type),
2886 _dfrexp(glsl_type::dvec3_type, glsl_type::ivec3_type),
2887 _dfrexp(glsl_type::dvec4_type, glsl_type::ivec4_type),
2888 NULL);
2889 add_function("uaddCarry",
2890 _uaddCarry(glsl_type::uint_type),
2891 _uaddCarry(glsl_type::uvec2_type),
2892 _uaddCarry(glsl_type::uvec3_type),
2893 _uaddCarry(glsl_type::uvec4_type),
2894 NULL);
2895 add_function("usubBorrow",
2896 _usubBorrow(glsl_type::uint_type),
2897 _usubBorrow(glsl_type::uvec2_type),
2898 _usubBorrow(glsl_type::uvec3_type),
2899 _usubBorrow(glsl_type::uvec4_type),
2900 NULL);
2901 add_function("imulExtended",
2902 _mulExtended(glsl_type::int_type),
2903 _mulExtended(glsl_type::ivec2_type),
2904 _mulExtended(glsl_type::ivec3_type),
2905 _mulExtended(glsl_type::ivec4_type),
2906 NULL);
2907 add_function("umulExtended",
2908 _mulExtended(glsl_type::uint_type),
2909 _mulExtended(glsl_type::uvec2_type),
2910 _mulExtended(glsl_type::uvec3_type),
2911 _mulExtended(glsl_type::uvec4_type),
2912 NULL);
2913 add_function("interpolateAtCentroid",
2914 _interpolateAtCentroid(glsl_type::float_type),
2915 _interpolateAtCentroid(glsl_type::vec2_type),
2916 _interpolateAtCentroid(glsl_type::vec3_type),
2917 _interpolateAtCentroid(glsl_type::vec4_type),
2918 NULL);
2919 add_function("interpolateAtOffset",
2920 _interpolateAtOffset(glsl_type::float_type),
2921 _interpolateAtOffset(glsl_type::vec2_type),
2922 _interpolateAtOffset(glsl_type::vec3_type),
2923 _interpolateAtOffset(glsl_type::vec4_type),
2924 NULL);
2925 add_function("interpolateAtSample",
2926 _interpolateAtSample(glsl_type::float_type),
2927 _interpolateAtSample(glsl_type::vec2_type),
2928 _interpolateAtSample(glsl_type::vec3_type),
2929 _interpolateAtSample(glsl_type::vec4_type),
2930 NULL);
2931
2932 add_function("atomicCounter",
2933 _atomic_counter_op("__intrinsic_atomic_read",
2934 shader_atomic_counters),
2935 NULL);
2936 add_function("atomicCounterIncrement",
2937 _atomic_counter_op("__intrinsic_atomic_increment",
2938 shader_atomic_counters),
2939 NULL);
2940 add_function("atomicCounterDecrement",
2941 _atomic_counter_op("__intrinsic_atomic_predecrement",
2942 shader_atomic_counters),
2943 NULL);
2944
2945 add_function("atomicCounterAddARB",
2946 _atomic_counter_op1("__intrinsic_atomic_add",
2947 shader_atomic_counter_ops),
2948 NULL);
2949 add_function("atomicCounterSubtractARB",
2950 _atomic_counter_op1("__intrinsic_atomic_sub",
2951 shader_atomic_counter_ops),
2952 NULL);
2953 add_function("atomicCounterMinARB",
2954 _atomic_counter_op1("__intrinsic_atomic_min",
2955 shader_atomic_counter_ops),
2956 NULL);
2957 add_function("atomicCounterMaxARB",
2958 _atomic_counter_op1("__intrinsic_atomic_max",
2959 shader_atomic_counter_ops),
2960 NULL);
2961 add_function("atomicCounterAndARB",
2962 _atomic_counter_op1("__intrinsic_atomic_and",
2963 shader_atomic_counter_ops),
2964 NULL);
2965 add_function("atomicCounterOrARB",
2966 _atomic_counter_op1("__intrinsic_atomic_or",
2967 shader_atomic_counter_ops),
2968 NULL);
2969 add_function("atomicCounterXorARB",
2970 _atomic_counter_op1("__intrinsic_atomic_xor",
2971 shader_atomic_counter_ops),
2972 NULL);
2973 add_function("atomicCounterExchangeARB",
2974 _atomic_counter_op1("__intrinsic_atomic_exchange",
2975 shader_atomic_counter_ops),
2976 NULL);
2977 add_function("atomicCounterCompSwapARB",
2978 _atomic_counter_op2("__intrinsic_atomic_comp_swap",
2979 shader_atomic_counter_ops),
2980 NULL);
2981
2982 add_function("atomicAdd",
2983 _atomic_op2("__intrinsic_atomic_add",
2984 buffer_atomics_supported,
2985 glsl_type::uint_type),
2986 _atomic_op2("__intrinsic_atomic_add",
2987 buffer_atomics_supported,
2988 glsl_type::int_type),
2989 NULL);
2990 add_function("atomicMin",
2991 _atomic_op2("__intrinsic_atomic_min",
2992 buffer_atomics_supported,
2993 glsl_type::uint_type),
2994 _atomic_op2("__intrinsic_atomic_min",
2995 buffer_atomics_supported,
2996 glsl_type::int_type),
2997 NULL);
2998 add_function("atomicMax",
2999 _atomic_op2("__intrinsic_atomic_max",
3000 buffer_atomics_supported,
3001 glsl_type::uint_type),
3002 _atomic_op2("__intrinsic_atomic_max",
3003 buffer_atomics_supported,
3004 glsl_type::int_type),
3005 NULL);
3006 add_function("atomicAnd",
3007 _atomic_op2("__intrinsic_atomic_and",
3008 buffer_atomics_supported,
3009 glsl_type::uint_type),
3010 _atomic_op2("__intrinsic_atomic_and",
3011 buffer_atomics_supported,
3012 glsl_type::int_type),
3013 NULL);
3014 add_function("atomicOr",
3015 _atomic_op2("__intrinsic_atomic_or",
3016 buffer_atomics_supported,
3017 glsl_type::uint_type),
3018 _atomic_op2("__intrinsic_atomic_or",
3019 buffer_atomics_supported,
3020 glsl_type::int_type),
3021 NULL);
3022 add_function("atomicXor",
3023 _atomic_op2("__intrinsic_atomic_xor",
3024 buffer_atomics_supported,
3025 glsl_type::uint_type),
3026 _atomic_op2("__intrinsic_atomic_xor",
3027 buffer_atomics_supported,
3028 glsl_type::int_type),
3029 NULL);
3030 add_function("atomicExchange",
3031 _atomic_op2("__intrinsic_atomic_exchange",
3032 buffer_atomics_supported,
3033 glsl_type::uint_type),
3034 _atomic_op2("__intrinsic_atomic_exchange",
3035 buffer_atomics_supported,
3036 glsl_type::int_type),
3037 NULL);
3038 add_function("atomicCompSwap",
3039 _atomic_op3("__intrinsic_atomic_comp_swap",
3040 buffer_atomics_supported,
3041 glsl_type::uint_type),
3042 _atomic_op3("__intrinsic_atomic_comp_swap",
3043 buffer_atomics_supported,
3044 glsl_type::int_type),
3045 NULL);
3046
3047 add_function("min3",
3048 _min3(glsl_type::float_type),
3049 _min3(glsl_type::vec2_type),
3050 _min3(glsl_type::vec3_type),
3051 _min3(glsl_type::vec4_type),
3052
3053 _min3(glsl_type::int_type),
3054 _min3(glsl_type::ivec2_type),
3055 _min3(glsl_type::ivec3_type),
3056 _min3(glsl_type::ivec4_type),
3057
3058 _min3(glsl_type::uint_type),
3059 _min3(glsl_type::uvec2_type),
3060 _min3(glsl_type::uvec3_type),
3061 _min3(glsl_type::uvec4_type),
3062 NULL);
3063
3064 add_function("max3",
3065 _max3(glsl_type::float_type),
3066 _max3(glsl_type::vec2_type),
3067 _max3(glsl_type::vec3_type),
3068 _max3(glsl_type::vec4_type),
3069
3070 _max3(glsl_type::int_type),
3071 _max3(glsl_type::ivec2_type),
3072 _max3(glsl_type::ivec3_type),
3073 _max3(glsl_type::ivec4_type),
3074
3075 _max3(glsl_type::uint_type),
3076 _max3(glsl_type::uvec2_type),
3077 _max3(glsl_type::uvec3_type),
3078 _max3(glsl_type::uvec4_type),
3079 NULL);
3080
3081 add_function("mid3",
3082 _mid3(glsl_type::float_type),
3083 _mid3(glsl_type::vec2_type),
3084 _mid3(glsl_type::vec3_type),
3085 _mid3(glsl_type::vec4_type),
3086
3087 _mid3(glsl_type::int_type),
3088 _mid3(glsl_type::ivec2_type),
3089 _mid3(glsl_type::ivec3_type),
3090 _mid3(glsl_type::ivec4_type),
3091
3092 _mid3(glsl_type::uint_type),
3093 _mid3(glsl_type::uvec2_type),
3094 _mid3(glsl_type::uvec3_type),
3095 _mid3(glsl_type::uvec4_type),
3096 NULL);
3097
3098 add_image_functions(true);
3099
3100 add_function("memoryBarrier",
3101 _memory_barrier("__intrinsic_memory_barrier",
3102 shader_image_load_store),
3103 NULL);
3104 add_function("groupMemoryBarrier",
3105 _memory_barrier("__intrinsic_group_memory_barrier",
3106 compute_shader),
3107 NULL);
3108 add_function("memoryBarrierAtomicCounter",
3109 _memory_barrier("__intrinsic_memory_barrier_atomic_counter",
3110 compute_shader_supported),
3111 NULL);
3112 add_function("memoryBarrierBuffer",
3113 _memory_barrier("__intrinsic_memory_barrier_buffer",
3114 compute_shader_supported),
3115 NULL);
3116 add_function("memoryBarrierImage",
3117 _memory_barrier("__intrinsic_memory_barrier_image",
3118 compute_shader_supported),
3119 NULL);
3120 add_function("memoryBarrierShared",
3121 _memory_barrier("__intrinsic_memory_barrier_shared",
3122 compute_shader),
3123 NULL);
3124
3125 add_function("ballotARB", _ballot(), NULL);
3126
3127 add_function("readInvocationARB",
3128 _read_invocation(glsl_type::float_type),
3129 _read_invocation(glsl_type::vec2_type),
3130 _read_invocation(glsl_type::vec3_type),
3131 _read_invocation(glsl_type::vec4_type),
3132
3133 _read_invocation(glsl_type::int_type),
3134 _read_invocation(glsl_type::ivec2_type),
3135 _read_invocation(glsl_type::ivec3_type),
3136 _read_invocation(glsl_type::ivec4_type),
3137
3138 _read_invocation(glsl_type::uint_type),
3139 _read_invocation(glsl_type::uvec2_type),
3140 _read_invocation(glsl_type::uvec3_type),
3141 _read_invocation(glsl_type::uvec4_type),
3142 NULL);
3143
3144 add_function("readFirstInvocationARB",
3145 _read_first_invocation(glsl_type::float_type),
3146 _read_first_invocation(glsl_type::vec2_type),
3147 _read_first_invocation(glsl_type::vec3_type),
3148 _read_first_invocation(glsl_type::vec4_type),
3149
3150 _read_first_invocation(glsl_type::int_type),
3151 _read_first_invocation(glsl_type::ivec2_type),
3152 _read_first_invocation(glsl_type::ivec3_type),
3153 _read_first_invocation(glsl_type::ivec4_type),
3154
3155 _read_first_invocation(glsl_type::uint_type),
3156 _read_first_invocation(glsl_type::uvec2_type),
3157 _read_first_invocation(glsl_type::uvec3_type),
3158 _read_first_invocation(glsl_type::uvec4_type),
3159 NULL);
3160
3161 add_function("clock2x32ARB",
3162 _shader_clock(shader_clock,
3163 glsl_type::uvec2_type),
3164 NULL);
3165
3166 add_function("clockARB",
3167 _shader_clock(shader_clock_int64,
3168 glsl_type::uint64_t_type),
3169 NULL);
3170
3171 add_function("anyInvocationARB", _vote(ir_unop_vote_any), NULL);
3172 add_function("allInvocationsARB", _vote(ir_unop_vote_all), NULL);
3173 add_function("allInvocationsEqualARB", _vote(ir_unop_vote_eq), NULL);
3174
3175 add_function("__builtin_idiv64",
3176 generate_ir::idiv64(mem_ctx, integer_functions_supported),
3177 NULL);
3178
3179 add_function("__builtin_imod64",
3180 generate_ir::imod64(mem_ctx, integer_functions_supported),
3181 NULL);
3182
3183 add_function("__builtin_sign64",
3184 generate_ir::sign64(mem_ctx, integer_functions_supported),
3185 NULL);
3186
3187 add_function("__builtin_udiv64",
3188 generate_ir::udiv64(mem_ctx, integer_functions_supported),
3189 NULL);
3190
3191 add_function("__builtin_umod64",
3192 generate_ir::umod64(mem_ctx, integer_functions_supported),
3193 NULL);
3194
3195 add_function("__builtin_umul64",
3196 generate_ir::umul64(mem_ctx, integer_functions_supported),
3197 NULL);
3198
3199 #undef F
3200 #undef FI
3201 #undef FIUD_VEC
3202 #undef FIUBD_VEC
3203 #undef FIU2_MIXED
3204 }
3205
3206 void
3207 builtin_builder::add_function(const char *name, ...)
3208 {
3209 va_list ap;
3210
3211 ir_function *f = new(mem_ctx) ir_function(name);
3212
3213 va_start(ap, name);
3214 while (true) {
3215 ir_function_signature *sig = va_arg(ap, ir_function_signature *);
3216 if (sig == NULL)
3217 break;
3218
3219 if (false) {
3220 exec_list stuff;
3221 stuff.push_tail(sig);
3222 validate_ir_tree(&stuff);
3223 }
3224
3225 f->add_signature(sig);
3226 }
3227 va_end(ap);
3228
3229 shader->symbols->add_function(f);
3230 }
3231
3232 void
3233 builtin_builder::add_image_function(const char *name,
3234 const char *intrinsic_name,
3235 image_prototype_ctr prototype,
3236 unsigned num_arguments,
3237 unsigned flags,
3238 enum ir_intrinsic_id intrinsic_id)
3239 {
3240 static const glsl_type *const types[] = {
3241 glsl_type::image1D_type,
3242 glsl_type::image2D_type,
3243 glsl_type::image3D_type,
3244 glsl_type::image2DRect_type,
3245 glsl_type::imageCube_type,
3246 glsl_type::imageBuffer_type,
3247 glsl_type::image1DArray_type,
3248 glsl_type::image2DArray_type,
3249 glsl_type::imageCubeArray_type,
3250 glsl_type::image2DMS_type,
3251 glsl_type::image2DMSArray_type,
3252 glsl_type::iimage1D_type,
3253 glsl_type::iimage2D_type,
3254 glsl_type::iimage3D_type,
3255 glsl_type::iimage2DRect_type,
3256 glsl_type::iimageCube_type,
3257 glsl_type::iimageBuffer_type,
3258 glsl_type::iimage1DArray_type,
3259 glsl_type::iimage2DArray_type,
3260 glsl_type::iimageCubeArray_type,
3261 glsl_type::iimage2DMS_type,
3262 glsl_type::iimage2DMSArray_type,
3263 glsl_type::uimage1D_type,
3264 glsl_type::uimage2D_type,
3265 glsl_type::uimage3D_type,
3266 glsl_type::uimage2DRect_type,
3267 glsl_type::uimageCube_type,
3268 glsl_type::uimageBuffer_type,
3269 glsl_type::uimage1DArray_type,
3270 glsl_type::uimage2DArray_type,
3271 glsl_type::uimageCubeArray_type,
3272 glsl_type::uimage2DMS_type,
3273 glsl_type::uimage2DMSArray_type
3274 };
3275
3276 ir_function *f = new(mem_ctx) ir_function(name);
3277
3278 for (unsigned i = 0; i < ARRAY_SIZE(types); ++i) {
3279 if ((types[i]->sampled_type != GLSL_TYPE_FLOAT ||
3280 (flags & IMAGE_FUNCTION_SUPPORTS_FLOAT_DATA_TYPE)) &&
3281 (types[i]->sampler_dimensionality == GLSL_SAMPLER_DIM_MS ||
3282 !(flags & IMAGE_FUNCTION_MS_ONLY)))
3283 f->add_signature(_image(prototype, types[i], intrinsic_name,
3284 num_arguments, flags, intrinsic_id));
3285 }
3286
3287 shader->symbols->add_function(f);
3288 }
3289
3290 void
3291 builtin_builder::add_image_functions(bool glsl)
3292 {
3293 const unsigned flags = (glsl ? IMAGE_FUNCTION_EMIT_STUB : 0);
3294
3295 add_image_function(glsl ? "imageLoad" : "__intrinsic_image_load",
3296 "__intrinsic_image_load",
3297 &builtin_builder::_image_prototype, 0,
3298 (flags | IMAGE_FUNCTION_HAS_VECTOR_DATA_TYPE |
3299 IMAGE_FUNCTION_SUPPORTS_FLOAT_DATA_TYPE |
3300 IMAGE_FUNCTION_READ_ONLY),
3301 ir_intrinsic_image_load);
3302
3303 add_image_function(glsl ? "imageStore" : "__intrinsic_image_store",
3304 "__intrinsic_image_store",
3305 &builtin_builder::_image_prototype, 1,
3306 (flags | IMAGE_FUNCTION_RETURNS_VOID |
3307 IMAGE_FUNCTION_HAS_VECTOR_DATA_TYPE |
3308 IMAGE_FUNCTION_SUPPORTS_FLOAT_DATA_TYPE |
3309 IMAGE_FUNCTION_WRITE_ONLY),
3310 ir_intrinsic_image_store);
3311
3312 const unsigned atom_flags = flags | IMAGE_FUNCTION_AVAIL_ATOMIC;
3313
3314 add_image_function(glsl ? "imageAtomicAdd" : "__intrinsic_image_atomic_add",
3315 "__intrinsic_image_atomic_add",
3316 &builtin_builder::_image_prototype, 1, atom_flags,
3317 ir_intrinsic_image_atomic_add);
3318
3319 add_image_function(glsl ? "imageAtomicMin" : "__intrinsic_image_atomic_min",
3320 "__intrinsic_image_atomic_min",
3321 &builtin_builder::_image_prototype, 1, atom_flags,
3322 ir_intrinsic_image_atomic_min);
3323
3324 add_image_function(glsl ? "imageAtomicMax" : "__intrinsic_image_atomic_max",
3325 "__intrinsic_image_atomic_max",
3326 &builtin_builder::_image_prototype, 1, atom_flags,
3327 ir_intrinsic_image_atomic_max);
3328
3329 add_image_function(glsl ? "imageAtomicAnd" : "__intrinsic_image_atomic_and",
3330 "__intrinsic_image_atomic_and",
3331 &builtin_builder::_image_prototype, 1, atom_flags,
3332 ir_intrinsic_image_atomic_and);
3333
3334 add_image_function(glsl ? "imageAtomicOr" : "__intrinsic_image_atomic_or",
3335 "__intrinsic_image_atomic_or",
3336 &builtin_builder::_image_prototype, 1, atom_flags,
3337 ir_intrinsic_image_atomic_or);
3338
3339 add_image_function(glsl ? "imageAtomicXor" : "__intrinsic_image_atomic_xor",
3340 "__intrinsic_image_atomic_xor",
3341 &builtin_builder::_image_prototype, 1, atom_flags,
3342 ir_intrinsic_image_atomic_xor);
3343
3344 add_image_function((glsl ? "imageAtomicExchange" :
3345 "__intrinsic_image_atomic_exchange"),
3346 "__intrinsic_image_atomic_exchange",
3347 &builtin_builder::_image_prototype, 1,
3348 (flags | IMAGE_FUNCTION_AVAIL_ATOMIC_EXCHANGE |
3349 IMAGE_FUNCTION_SUPPORTS_FLOAT_DATA_TYPE),
3350 ir_intrinsic_image_atomic_exchange);
3351
3352 add_image_function((glsl ? "imageAtomicCompSwap" :
3353 "__intrinsic_image_atomic_comp_swap"),
3354 "__intrinsic_image_atomic_comp_swap",
3355 &builtin_builder::_image_prototype, 2, atom_flags,
3356 ir_intrinsic_image_atomic_comp_swap);
3357
3358 add_image_function(glsl ? "imageSize" : "__intrinsic_image_size",
3359 "__intrinsic_image_size",
3360 &builtin_builder::_image_size_prototype, 1,
3361 flags | IMAGE_FUNCTION_SUPPORTS_FLOAT_DATA_TYPE,
3362 ir_intrinsic_image_size);
3363
3364 add_image_function(glsl ? "imageSamples" : "__intrinsic_image_samples",
3365 "__intrinsic_image_samples",
3366 &builtin_builder::_image_samples_prototype, 1,
3367 flags | IMAGE_FUNCTION_SUPPORTS_FLOAT_DATA_TYPE |
3368 IMAGE_FUNCTION_MS_ONLY,
3369 ir_intrinsic_image_samples);
3370 }
3371
3372 ir_variable *
3373 builtin_builder::in_var(const glsl_type *type, const char *name)
3374 {
3375 return new(mem_ctx) ir_variable(type, name, ir_var_function_in);
3376 }
3377
3378 ir_variable *
3379 builtin_builder::out_var(const glsl_type *type, const char *name)
3380 {
3381 return new(mem_ctx) ir_variable(type, name, ir_var_function_out);
3382 }
3383
3384 ir_constant *
3385 builtin_builder::imm(bool b, unsigned vector_elements)
3386 {
3387 return new(mem_ctx) ir_constant(b, vector_elements);
3388 }
3389
3390 ir_constant *
3391 builtin_builder::imm(float f, unsigned vector_elements)
3392 {
3393 return new(mem_ctx) ir_constant(f, vector_elements);
3394 }
3395
3396 ir_constant *
3397 builtin_builder::imm(int i, unsigned vector_elements)
3398 {
3399 return new(mem_ctx) ir_constant(i, vector_elements);
3400 }
3401
3402 ir_constant *
3403 builtin_builder::imm(unsigned u, unsigned vector_elements)
3404 {
3405 return new(mem_ctx) ir_constant(u, vector_elements);
3406 }
3407
3408 ir_constant *
3409 builtin_builder::imm(double d, unsigned vector_elements)
3410 {
3411 return new(mem_ctx) ir_constant(d, vector_elements);
3412 }
3413
3414 ir_constant *
3415 builtin_builder::imm(const glsl_type *type, const ir_constant_data &data)
3416 {
3417 return new(mem_ctx) ir_constant(type, &data);
3418 }
3419
3420 #define IMM_FP(type, val) (type->base_type == GLSL_TYPE_DOUBLE) ? imm(val) : imm((float)val)
3421
3422 ir_dereference_variable *
3423 builtin_builder::var_ref(ir_variable *var)
3424 {
3425 return new(mem_ctx) ir_dereference_variable(var);
3426 }
3427
3428 ir_dereference_array *
3429 builtin_builder::array_ref(ir_variable *var, int idx)
3430 {
3431 return new(mem_ctx) ir_dereference_array(var, imm(idx));
3432 }
3433
3434 /** Return an element of a matrix */
3435 ir_swizzle *
3436 builtin_builder::matrix_elt(ir_variable *var, int column, int row)
3437 {
3438 return swizzle(array_ref(var, column), row, 1);
3439 }
3440
3441 /**
3442 * Implementations of built-in functions:
3443 * @{
3444 */
3445 ir_function_signature *
3446 builtin_builder::new_sig(const glsl_type *return_type,
3447 builtin_available_predicate avail,
3448 int num_params,
3449 ...)
3450 {
3451 va_list ap;
3452
3453 ir_function_signature *sig =
3454 new(mem_ctx) ir_function_signature(return_type, avail);
3455
3456 exec_list plist;
3457 va_start(ap, num_params);
3458 for (int i = 0; i < num_params; i++) {
3459 plist.push_tail(va_arg(ap, ir_variable *));
3460 }
3461 va_end(ap);
3462
3463 sig->replace_parameters(&plist);
3464 return sig;
3465 }
3466
3467 #define MAKE_SIG(return_type, avail, ...) \
3468 ir_function_signature *sig = \
3469 new_sig(return_type, avail, __VA_ARGS__); \
3470 ir_factory body(&sig->body, mem_ctx); \
3471 sig->is_defined = true;
3472
3473 #define MAKE_INTRINSIC(return_type, id, avail, ...) \
3474 ir_function_signature *sig = \
3475 new_sig(return_type, avail, __VA_ARGS__); \
3476 sig->intrinsic_id = id;
3477
3478 ir_function_signature *
3479 builtin_builder::unop(builtin_available_predicate avail,
3480 ir_expression_operation opcode,
3481 const glsl_type *return_type,
3482 const glsl_type *param_type)
3483 {
3484 ir_variable *x = in_var(param_type, "x");
3485 MAKE_SIG(return_type, avail, 1, x);
3486 body.emit(ret(expr(opcode, x)));
3487 return sig;
3488 }
3489
3490 #define UNOP(NAME, OPCODE, AVAIL) \
3491 ir_function_signature * \
3492 builtin_builder::_##NAME(const glsl_type *type) \
3493 { \
3494 return unop(&AVAIL, OPCODE, type, type); \
3495 }
3496
3497 #define UNOPA(NAME, OPCODE) \
3498 ir_function_signature * \
3499 builtin_builder::_##NAME(builtin_available_predicate avail, const glsl_type *type) \
3500 { \
3501 return unop(avail, OPCODE, type, type); \
3502 }
3503
3504 ir_function_signature *
3505 builtin_builder::binop(builtin_available_predicate avail,
3506 ir_expression_operation opcode,
3507 const glsl_type *return_type,
3508 const glsl_type *param0_type,
3509 const glsl_type *param1_type)
3510 {
3511 ir_variable *x = in_var(param0_type, "x");
3512 ir_variable *y = in_var(param1_type, "y");
3513 MAKE_SIG(return_type, avail, 2, x, y);
3514 body.emit(ret(expr(opcode, x, y)));
3515 return sig;
3516 }
3517
3518 #define BINOP(NAME, OPCODE, AVAIL) \
3519 ir_function_signature * \
3520 builtin_builder::_##NAME(const glsl_type *return_type, \
3521 const glsl_type *param0_type, \
3522 const glsl_type *param1_type) \
3523 { \
3524 return binop(&AVAIL, OPCODE, return_type, param0_type, param1_type); \
3525 }
3526
3527 /**
3528 * Angle and Trigonometry Functions @{
3529 */
3530
3531 ir_function_signature *
3532 builtin_builder::_radians(const glsl_type *type)
3533 {
3534 ir_variable *degrees = in_var(type, "degrees");
3535 MAKE_SIG(type, always_available, 1, degrees);
3536 body.emit(ret(mul(degrees, imm(0.0174532925f))));
3537 return sig;
3538 }
3539
3540 ir_function_signature *
3541 builtin_builder::_degrees(const glsl_type *type)
3542 {
3543 ir_variable *radians = in_var(type, "radians");
3544 MAKE_SIG(type, always_available, 1, radians);
3545 body.emit(ret(mul(radians, imm(57.29578f))));
3546 return sig;
3547 }
3548
3549 UNOP(sin, ir_unop_sin, always_available)
3550 UNOP(cos, ir_unop_cos, always_available)
3551
3552 ir_function_signature *
3553 builtin_builder::_tan(const glsl_type *type)
3554 {
3555 ir_variable *theta = in_var(type, "theta");
3556 MAKE_SIG(type, always_available, 1, theta);
3557 body.emit(ret(div(sin(theta), cos(theta))));
3558 return sig;
3559 }
3560
3561 ir_expression *
3562 builtin_builder::asin_expr(ir_variable *x, float p0, float p1)
3563 {
3564 return mul(sign(x),
3565 sub(imm(M_PI_2f),
3566 mul(sqrt(sub(imm(1.0f), abs(x))),
3567 add(imm(M_PI_2f),
3568 mul(abs(x),
3569 add(imm(M_PI_4f - 1.0f),
3570 mul(abs(x),
3571 add(imm(p0),
3572 mul(abs(x), imm(p1))))))))));
3573 }
3574
3575 /**
3576 * Generate a ir_call to a function with a set of parameters
3577 *
3578 * The input \c params can either be a list of \c ir_variable or a list of
3579 * \c ir_dereference_variable. In the latter case, all nodes will be removed
3580 * from \c params and used directly as the parameters to the generated
3581 * \c ir_call.
3582 */
3583 ir_call *
3584 builtin_builder::call(ir_function *f, ir_variable *ret, exec_list params)
3585 {
3586 exec_list actual_params;
3587
3588 foreach_in_list_safe(ir_instruction, ir, &params) {
3589 ir_dereference_variable *d = ir->as_dereference_variable();
3590 if (d != NULL) {
3591 d->remove();
3592 actual_params.push_tail(d);
3593 } else {
3594 ir_variable *var = ir->as_variable();
3595 assert(var != NULL);
3596 actual_params.push_tail(var_ref(var));
3597 }
3598 }
3599
3600 ir_function_signature *sig =
3601 f->exact_matching_signature(NULL, &actual_params);
3602 if (!sig)
3603 return NULL;
3604
3605 ir_dereference_variable *deref =
3606 (sig->return_type->is_void() ? NULL : var_ref(ret));
3607
3608 return new(mem_ctx) ir_call(sig, deref, &actual_params);
3609 }
3610
3611 ir_function_signature *
3612 builtin_builder::_asin(const glsl_type *type)
3613 {
3614 ir_variable *x = in_var(type, "x");
3615 MAKE_SIG(type, always_available, 1, x);
3616
3617 body.emit(ret(asin_expr(x, 0.086566724f, -0.03102955f)));
3618
3619 return sig;
3620 }
3621
3622 ir_function_signature *
3623 builtin_builder::_acos(const glsl_type *type)
3624 {
3625 ir_variable *x = in_var(type, "x");
3626 MAKE_SIG(type, always_available, 1, x);
3627
3628 body.emit(ret(sub(imm(M_PI_2f), asin_expr(x, 0.08132463f, -0.02363318f))));
3629
3630 return sig;
3631 }
3632
3633 ir_function_signature *
3634 builtin_builder::_atan2(const glsl_type *type)
3635 {
3636 const unsigned n = type->vector_elements;
3637 ir_variable *y = in_var(type, "y");
3638 ir_variable *x = in_var(type, "x");
3639 MAKE_SIG(type, always_available, 2, y, x);
3640
3641 /* If we're on the left half-plane rotate the coordinates π/2 clock-wise
3642 * for the y=0 discontinuity to end up aligned with the vertical
3643 * discontinuity of atan(s/t) along t=0. This also makes sure that we
3644 * don't attempt to divide by zero along the vertical line, which may give
3645 * unspecified results on non-GLSL 4.1-capable hardware.
3646 */
3647 ir_variable *flip = body.make_temp(glsl_type::bvec(n), "flip");
3648 body.emit(assign(flip, gequal(imm(0.0f, n), x)));
3649 ir_variable *s = body.make_temp(type, "s");
3650 body.emit(assign(s, csel(flip, abs(x), y)));
3651 ir_variable *t = body.make_temp(type, "t");
3652 body.emit(assign(t, csel(flip, y, abs(x))));
3653
3654 /* If the magnitude of the denominator exceeds some huge value, scale down
3655 * the arguments in order to prevent the reciprocal operation from flushing
3656 * its result to zero, which would cause precision problems, and for s
3657 * infinite would cause us to return a NaN instead of the correct finite
3658 * value.
3659 *
3660 * If fmin and fmax are respectively the smallest and largest positive
3661 * normalized floating point values representable by the implementation,
3662 * the constants below should be in agreement with:
3663 *
3664 * huge <= 1 / fmin
3665 * scale <= 1 / fmin / fmax (for |t| >= huge)
3666 *
3667 * In addition scale should be a negative power of two in order to avoid
3668 * loss of precision. The values chosen below should work for most usual
3669 * floating point representations with at least the dynamic range of ATI's
3670 * 24-bit representation.
3671 */
3672 ir_constant *huge = imm(1e18f, n);
3673 ir_variable *scale = body.make_temp(type, "scale");
3674 body.emit(assign(scale, csel(gequal(abs(t), huge),
3675 imm(0.25f, n), imm(1.0f, n))));
3676 ir_variable *rcp_scaled_t = body.make_temp(type, "rcp_scaled_t");
3677 body.emit(assign(rcp_scaled_t, rcp(mul(t, scale))));
3678 ir_expression *s_over_t = mul(mul(s, scale), rcp_scaled_t);
3679
3680 /* For |x| = |y| assume tan = 1 even if infinite (i.e. pretend momentarily
3681 * that ∞/∞ = 1) in order to comply with the rather artificial rules
3682 * inherited from IEEE 754-2008, namely:
3683 *
3684 * "atan2(±∞, −∞) is ±3π/4
3685 * atan2(±∞, +∞) is ±π/4"
3686 *
3687 * Note that this is inconsistent with the rules for the neighborhood of
3688 * zero that are based on iterated limits:
3689 *
3690 * "atan2(±0, −0) is ±π
3691 * atan2(±0, +0) is ±0"
3692 *
3693 * but GLSL specifically allows implementations to deviate from IEEE rules
3694 * at (0,0), so we take that license (i.e. pretend that 0/0 = 1 here as
3695 * well).
3696 */
3697 ir_expression *tan = csel(equal(abs(x), abs(y)),
3698 imm(1.0f, n), abs(s_over_t));
3699
3700 /* Calculate the arctangent and fix up the result if we had flipped the
3701 * coordinate system.
3702 */
3703 ir_variable *arc = body.make_temp(type, "arc");
3704 do_atan(body, type, arc, tan);
3705 body.emit(assign(arc, add(arc, mul(b2f(flip), imm(M_PI_2f)))));
3706
3707 /* Rather convoluted calculation of the sign of the result. When x < 0 we
3708 * cannot use fsign because we need to be able to distinguish between
3709 * negative and positive zero. Unfortunately we cannot use bitwise
3710 * arithmetic tricks either because of back-ends without integer support.
3711 * When x >= 0 rcp_scaled_t will always be non-negative so this won't be
3712 * able to distinguish between negative and positive zero, but we don't
3713 * care because atan2 is continuous along the whole positive y = 0
3714 * half-line, so it won't affect the result significantly.
3715 */
3716 body.emit(ret(csel(less(min2(y, rcp_scaled_t), imm(0.0f, n)),
3717 neg(arc), arc)));
3718
3719 return sig;
3720 }
3721
3722 void
3723 builtin_builder::do_atan(ir_factory &body, const glsl_type *type, ir_variable *res, operand y_over_x)
3724 {
3725 /*
3726 * range-reduction, first step:
3727 *
3728 * / y_over_x if |y_over_x| <= 1.0;
3729 * x = <
3730 * \ 1.0 / y_over_x otherwise
3731 */
3732 ir_variable *x = body.make_temp(type, "atan_x");
3733 body.emit(assign(x, div(min2(abs(y_over_x),
3734 imm(1.0f)),
3735 max2(abs(y_over_x),
3736 imm(1.0f)))));
3737
3738 /*
3739 * approximate atan by evaluating polynomial:
3740 *
3741 * x * 0.9999793128310355 - x^3 * 0.3326756418091246 +
3742 * x^5 * 0.1938924977115610 - x^7 * 0.1173503194786851 +
3743 * x^9 * 0.0536813784310406 - x^11 * 0.0121323213173444
3744 */
3745 ir_variable *tmp = body.make_temp(type, "atan_tmp");
3746 body.emit(assign(tmp, mul(x, x)));
3747 body.emit(assign(tmp, mul(add(mul(sub(mul(add(mul(sub(mul(add(mul(imm(-0.0121323213173444f),
3748 tmp),
3749 imm(0.0536813784310406f)),
3750 tmp),
3751 imm(0.1173503194786851f)),
3752 tmp),
3753 imm(0.1938924977115610f)),
3754 tmp),
3755 imm(0.3326756418091246f)),
3756 tmp),
3757 imm(0.9999793128310355f)),
3758 x)));
3759
3760 /* range-reduction fixup */
3761 body.emit(assign(tmp, add(tmp,
3762 mul(b2f(greater(abs(y_over_x),
3763 imm(1.0f, type->components()))),
3764 add(mul(tmp,
3765 imm(-2.0f)),
3766 imm(M_PI_2f))))));
3767
3768 /* sign fixup */
3769 body.emit(assign(res, mul(tmp, sign(y_over_x))));
3770 }
3771
3772 ir_function_signature *
3773 builtin_builder::_atan(const glsl_type *type)
3774 {
3775 ir_variable *y_over_x = in_var(type, "y_over_x");
3776 MAKE_SIG(type, always_available, 1, y_over_x);
3777
3778 ir_variable *tmp = body.make_temp(type, "tmp");
3779 do_atan(body, type, tmp, y_over_x);
3780 body.emit(ret(tmp));
3781
3782 return sig;
3783 }
3784
3785 ir_function_signature *
3786 builtin_builder::_sinh(const glsl_type *type)
3787 {
3788 ir_variable *x = in_var(type, "x");
3789 MAKE_SIG(type, v130, 1, x);
3790
3791 /* 0.5 * (e^x - e^(-x)) */
3792 body.emit(ret(mul(imm(0.5f), sub(exp(x), exp(neg(x))))));
3793
3794 return sig;
3795 }
3796
3797 ir_function_signature *
3798 builtin_builder::_cosh(const glsl_type *type)
3799 {
3800 ir_variable *x = in_var(type, "x");
3801 MAKE_SIG(type, v130, 1, x);
3802
3803 /* 0.5 * (e^x + e^(-x)) */
3804 body.emit(ret(mul(imm(0.5f), add(exp(x), exp(neg(x))))));
3805
3806 return sig;
3807 }
3808
3809 ir_function_signature *
3810 builtin_builder::_tanh(const glsl_type *type)
3811 {
3812 ir_variable *x = in_var(type, "x");
3813 MAKE_SIG(type, v130, 1, x);
3814
3815 /* tanh(x) := (0.5 * (e^x - e^(-x))) / (0.5 * (e^x + e^(-x)))
3816 *
3817 * With a little algebra this reduces to (e^2x - 1) / (e^2x + 1)
3818 *
3819 * Clamp x to (-inf, +10] to avoid precision problems. When x > 10, e^2x
3820 * is so much larger than 1.0 that 1.0 gets flushed to zero in the
3821 * computation e^2x +/- 1 so it can be ignored.
3822 */
3823 ir_variable *t = body.make_temp(type, "tmp");
3824 body.emit(assign(t, min2(x, imm(10.0f))));
3825
3826 body.emit(ret(div(sub(exp(mul(t, imm(2.0f))), imm(1.0f)),
3827 add(exp(mul(t, imm(2.0f))), imm(1.0f)))));
3828
3829 return sig;
3830 }
3831
3832 ir_function_signature *
3833 builtin_builder::_asinh(const glsl_type *type)
3834 {
3835 ir_variable *x = in_var(type, "x");
3836 MAKE_SIG(type, v130, 1, x);
3837
3838 body.emit(ret(mul(sign(x), log(add(abs(x), sqrt(add(mul(x, x),
3839 imm(1.0f))))))));
3840 return sig;
3841 }
3842
3843 ir_function_signature *
3844 builtin_builder::_acosh(const glsl_type *type)
3845 {
3846 ir_variable *x = in_var(type, "x");
3847 MAKE_SIG(type, v130, 1, x);
3848
3849 body.emit(ret(log(add(x, sqrt(sub(mul(x, x), imm(1.0f)))))));
3850 return sig;
3851 }
3852
3853 ir_function_signature *
3854 builtin_builder::_atanh(const glsl_type *type)
3855 {
3856 ir_variable *x = in_var(type, "x");
3857 MAKE_SIG(type, v130, 1, x);
3858
3859 body.emit(ret(mul(imm(0.5f), log(div(add(imm(1.0f), x),
3860 sub(imm(1.0f), x))))));
3861 return sig;
3862 }
3863 /** @} */
3864
3865 /**
3866 * Exponential Functions @{
3867 */
3868
3869 ir_function_signature *
3870 builtin_builder::_pow(const glsl_type *type)
3871 {
3872 return binop(always_available, ir_binop_pow, type, type, type);
3873 }
3874
3875 UNOP(exp, ir_unop_exp, always_available)
3876 UNOP(log, ir_unop_log, always_available)
3877 UNOP(exp2, ir_unop_exp2, always_available)
3878 UNOP(log2, ir_unop_log2, always_available)
3879 UNOPA(sqrt, ir_unop_sqrt)
3880 UNOPA(inversesqrt, ir_unop_rsq)
3881
3882 /** @} */
3883
3884 UNOPA(abs, ir_unop_abs)
3885 UNOPA(sign, ir_unop_sign)
3886 UNOPA(floor, ir_unop_floor)
3887 UNOPA(trunc, ir_unop_trunc)
3888 UNOPA(round, ir_unop_round_even)
3889 UNOPA(roundEven, ir_unop_round_even)
3890 UNOPA(ceil, ir_unop_ceil)
3891 UNOPA(fract, ir_unop_fract)
3892
3893 ir_function_signature *
3894 builtin_builder::_mod(builtin_available_predicate avail,
3895 const glsl_type *x_type, const glsl_type *y_type)
3896 {
3897 return binop(avail, ir_binop_mod, x_type, x_type, y_type);
3898 }
3899
3900 ir_function_signature *
3901 builtin_builder::_modf(builtin_available_predicate avail, const glsl_type *type)
3902 {
3903 ir_variable *x = in_var(type, "x");
3904 ir_variable *i = out_var(type, "i");
3905 MAKE_SIG(type, avail, 2, x, i);
3906
3907 ir_variable *t = body.make_temp(type, "t");
3908 body.emit(assign(t, expr(ir_unop_trunc, x)));
3909 body.emit(assign(i, t));
3910 body.emit(ret(sub(x, t)));
3911
3912 return sig;
3913 }
3914
3915 ir_function_signature *
3916 builtin_builder::_min(builtin_available_predicate avail,
3917 const glsl_type *x_type, const glsl_type *y_type)
3918 {
3919 return binop(avail, ir_binop_min, x_type, x_type, y_type);
3920 }
3921
3922 ir_function_signature *
3923 builtin_builder::_max(builtin_available_predicate avail,
3924 const glsl_type *x_type, const glsl_type *y_type)
3925 {
3926 return binop(avail, ir_binop_max, x_type, x_type, y_type);
3927 }
3928
3929 ir_function_signature *
3930 builtin_builder::_clamp(builtin_available_predicate avail,
3931 const glsl_type *val_type, const glsl_type *bound_type)
3932 {
3933 ir_variable *x = in_var(val_type, "x");
3934 ir_variable *minVal = in_var(bound_type, "minVal");
3935 ir_variable *maxVal = in_var(bound_type, "maxVal");
3936 MAKE_SIG(val_type, avail, 3, x, minVal, maxVal);
3937
3938 body.emit(ret(clamp(x, minVal, maxVal)));
3939
3940 return sig;
3941 }
3942
3943 ir_function_signature *
3944 builtin_builder::_mix_lrp(builtin_available_predicate avail, const glsl_type *val_type, const glsl_type *blend_type)
3945 {
3946 ir_variable *x = in_var(val_type, "x");
3947 ir_variable *y = in_var(val_type, "y");
3948 ir_variable *a = in_var(blend_type, "a");
3949 MAKE_SIG(val_type, avail, 3, x, y, a);
3950
3951 body.emit(ret(lrp(x, y, a)));
3952
3953 return sig;
3954 }
3955
3956 ir_function_signature *
3957 builtin_builder::_mix_sel(builtin_available_predicate avail,
3958 const glsl_type *val_type,
3959 const glsl_type *blend_type)
3960 {
3961 ir_variable *x = in_var(val_type, "x");
3962 ir_variable *y = in_var(val_type, "y");
3963 ir_variable *a = in_var(blend_type, "a");
3964 MAKE_SIG(val_type, avail, 3, x, y, a);
3965
3966 /* csel matches the ternary operator in that a selector of true choses the
3967 * first argument. This differs from mix(x, y, false) which choses the
3968 * second argument (to remain consistent with the interpolating version of
3969 * mix() which takes a blend factor from 0.0 to 1.0 where 0.0 is only x.
3970 *
3971 * To handle the behavior mismatch, reverse the x and y arguments.
3972 */
3973 body.emit(ret(csel(a, y, x)));
3974
3975 return sig;
3976 }
3977
3978 ir_function_signature *
3979 builtin_builder::_step(builtin_available_predicate avail, const glsl_type *edge_type, const glsl_type *x_type)
3980 {
3981 ir_variable *edge = in_var(edge_type, "edge");
3982 ir_variable *x = in_var(x_type, "x");
3983 MAKE_SIG(x_type, avail, 2, edge, x);
3984
3985 ir_variable *t = body.make_temp(x_type, "t");
3986 if (x_type->vector_elements == 1) {
3987 /* Both are floats */
3988 if (edge_type->base_type == GLSL_TYPE_DOUBLE)
3989 body.emit(assign(t, f2d(b2f(gequal(x, edge)))));
3990 else
3991 body.emit(assign(t, b2f(gequal(x, edge))));
3992 } else if (edge_type->vector_elements == 1) {
3993 /* x is a vector but edge is a float */
3994 for (int i = 0; i < x_type->vector_elements; i++) {
3995 if (edge_type->base_type == GLSL_TYPE_DOUBLE)
3996 body.emit(assign(t, f2d(b2f(gequal(swizzle(x, i, 1), edge))), 1 << i));
3997 else
3998 body.emit(assign(t, b2f(gequal(swizzle(x, i, 1), edge)), 1 << i));
3999 }
4000 } else {
4001 /* Both are vectors */
4002 for (int i = 0; i < x_type->vector_elements; i++) {
4003 if (edge_type->base_type == GLSL_TYPE_DOUBLE)
4004 body.emit(assign(t, f2d(b2f(gequal(swizzle(x, i, 1), swizzle(edge, i, 1)))),
4005 1 << i));
4006 else
4007 body.emit(assign(t, b2f(gequal(swizzle(x, i, 1), swizzle(edge, i, 1))),
4008 1 << i));
4009
4010 }
4011 }
4012 body.emit(ret(t));
4013
4014 return sig;
4015 }
4016
4017 ir_function_signature *
4018 builtin_builder::_smoothstep(builtin_available_predicate avail, const glsl_type *edge_type, const glsl_type *x_type)
4019 {
4020 ir_variable *edge0 = in_var(edge_type, "edge0");
4021 ir_variable *edge1 = in_var(edge_type, "edge1");
4022 ir_variable *x = in_var(x_type, "x");
4023 MAKE_SIG(x_type, avail, 3, edge0, edge1, x);
4024
4025 /* From the GLSL 1.10 specification:
4026 *
4027 * genType t;
4028 * t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
4029 * return t * t * (3 - 2 * t);
4030 */
4031
4032 ir_variable *t = body.make_temp(x_type, "t");
4033 body.emit(assign(t, clamp(div(sub(x, edge0), sub(edge1, edge0)),
4034 IMM_FP(x_type, 0.0), IMM_FP(x_type, 1.0))));
4035
4036 body.emit(ret(mul(t, mul(t, sub(IMM_FP(x_type, 3.0), mul(IMM_FP(x_type, 2.0), t))))));
4037
4038 return sig;
4039 }
4040
4041 ir_function_signature *
4042 builtin_builder::_isnan(builtin_available_predicate avail, const glsl_type *type)
4043 {
4044 ir_variable *x = in_var(type, "x");
4045 MAKE_SIG(glsl_type::bvec(type->vector_elements), avail, 1, x);
4046
4047 body.emit(ret(nequal(x, x)));
4048
4049 return sig;
4050 }
4051
4052 ir_function_signature *
4053 builtin_builder::_isinf(builtin_available_predicate avail, const glsl_type *type)
4054 {
4055 ir_variable *x = in_var(type, "x");
4056 MAKE_SIG(glsl_type::bvec(type->vector_elements), avail, 1, x);
4057
4058 ir_constant_data infinities;
4059 for (int i = 0; i < type->vector_elements; i++) {
4060 switch (type->base_type) {
4061 case GLSL_TYPE_FLOAT:
4062 infinities.f[i] = INFINITY;
4063 break;
4064 case GLSL_TYPE_DOUBLE:
4065 infinities.d[i] = INFINITY;
4066 break;
4067 default:
4068 unreachable("unknown type");
4069 }
4070 }
4071
4072 body.emit(ret(equal(abs(x), imm(type, infinities))));
4073
4074 return sig;
4075 }
4076
4077 ir_function_signature *
4078 builtin_builder::_floatBitsToInt(const glsl_type *type)
4079 {
4080 ir_variable *x = in_var(type, "x");
4081 MAKE_SIG(glsl_type::ivec(type->vector_elements), shader_bit_encoding, 1, x);
4082 body.emit(ret(bitcast_f2i(x)));
4083 return sig;
4084 }
4085
4086 ir_function_signature *
4087 builtin_builder::_floatBitsToUint(const glsl_type *type)
4088 {
4089 ir_variable *x = in_var(type, "x");
4090 MAKE_SIG(glsl_type::uvec(type->vector_elements), shader_bit_encoding, 1, x);
4091 body.emit(ret(bitcast_f2u(x)));
4092 return sig;
4093 }
4094
4095 ir_function_signature *
4096 builtin_builder::_intBitsToFloat(const glsl_type *type)
4097 {
4098 ir_variable *x = in_var(type, "x");
4099 MAKE_SIG(glsl_type::vec(type->vector_elements), shader_bit_encoding, 1, x);
4100 body.emit(ret(bitcast_i2f(x)));
4101 return sig;
4102 }
4103
4104 ir_function_signature *
4105 builtin_builder::_uintBitsToFloat(const glsl_type *type)
4106 {
4107 ir_variable *x = in_var(type, "x");
4108 MAKE_SIG(glsl_type::vec(type->vector_elements), shader_bit_encoding, 1, x);
4109 body.emit(ret(bitcast_u2f(x)));
4110 return sig;
4111 }
4112
4113 ir_function_signature *
4114 builtin_builder::_doubleBitsToInt64(builtin_available_predicate avail, const glsl_type *type)
4115 {
4116 ir_variable *x = in_var(type, "x");
4117 MAKE_SIG(glsl_type::i64vec(type->vector_elements), avail, 1, x);
4118 body.emit(ret(bitcast_d2i64(x)));
4119 return sig;
4120 }
4121
4122 ir_function_signature *
4123 builtin_builder::_doubleBitsToUint64(builtin_available_predicate avail, const glsl_type *type)
4124 {
4125 ir_variable *x = in_var(type, "x");
4126 MAKE_SIG(glsl_type::u64vec(type->vector_elements), avail, 1, x);
4127 body.emit(ret(bitcast_d2u64(x)));
4128 return sig;
4129 }
4130
4131 ir_function_signature *
4132 builtin_builder::_int64BitsToDouble(builtin_available_predicate avail, const glsl_type *type)
4133 {
4134 ir_variable *x = in_var(type, "x");
4135 MAKE_SIG(glsl_type::dvec(type->vector_elements), avail, 1, x);
4136 body.emit(ret(bitcast_i642d(x)));
4137 return sig;
4138 }
4139
4140 ir_function_signature *
4141 builtin_builder::_uint64BitsToDouble(builtin_available_predicate avail, const glsl_type *type)
4142 {
4143 ir_variable *x = in_var(type, "x");
4144 MAKE_SIG(glsl_type::dvec(type->vector_elements), avail, 1, x);
4145 body.emit(ret(bitcast_u642d(x)));
4146 return sig;
4147 }
4148
4149 ir_function_signature *
4150 builtin_builder::_packUnorm2x16(builtin_available_predicate avail)
4151 {
4152 ir_variable *v = in_var(glsl_type::vec2_type, "v");
4153 MAKE_SIG(glsl_type::uint_type, avail, 1, v);
4154 body.emit(ret(expr(ir_unop_pack_unorm_2x16, v)));
4155 return sig;
4156 }
4157
4158 ir_function_signature *
4159 builtin_builder::_packSnorm2x16(builtin_available_predicate avail)
4160 {
4161 ir_variable *v = in_var(glsl_type::vec2_type, "v");
4162 MAKE_SIG(glsl_type::uint_type, avail, 1, v);
4163 body.emit(ret(expr(ir_unop_pack_snorm_2x16, v)));
4164 return sig;
4165 }
4166
4167 ir_function_signature *
4168 builtin_builder::_packUnorm4x8(builtin_available_predicate avail)
4169 {
4170 ir_variable *v = in_var(glsl_type::vec4_type, "v");
4171 MAKE_SIG(glsl_type::uint_type, avail, 1, v);
4172 body.emit(ret(expr(ir_unop_pack_unorm_4x8, v)));
4173 return sig;
4174 }
4175
4176 ir_function_signature *
4177 builtin_builder::_packSnorm4x8(builtin_available_predicate avail)
4178 {
4179 ir_variable *v = in_var(glsl_type::vec4_type, "v");
4180 MAKE_SIG(glsl_type::uint_type, avail, 1, v);
4181 body.emit(ret(expr(ir_unop_pack_snorm_4x8, v)));
4182 return sig;
4183 }
4184
4185 ir_function_signature *
4186 builtin_builder::_unpackUnorm2x16(builtin_available_predicate avail)
4187 {
4188 ir_variable *p = in_var(glsl_type::uint_type, "p");
4189 MAKE_SIG(glsl_type::vec2_type, avail, 1, p);
4190 body.emit(ret(expr(ir_unop_unpack_unorm_2x16, p)));
4191 return sig;
4192 }
4193
4194 ir_function_signature *
4195 builtin_builder::_unpackSnorm2x16(builtin_available_predicate avail)
4196 {
4197 ir_variable *p = in_var(glsl_type::uint_type, "p");
4198 MAKE_SIG(glsl_type::vec2_type, avail, 1, p);
4199 body.emit(ret(expr(ir_unop_unpack_snorm_2x16, p)));
4200 return sig;
4201 }
4202
4203
4204 ir_function_signature *
4205 builtin_builder::_unpackUnorm4x8(builtin_available_predicate avail)
4206 {
4207 ir_variable *p = in_var(glsl_type::uint_type, "p");
4208 MAKE_SIG(glsl_type::vec4_type, avail, 1, p);
4209 body.emit(ret(expr(ir_unop_unpack_unorm_4x8, p)));
4210 return sig;
4211 }
4212
4213 ir_function_signature *
4214 builtin_builder::_unpackSnorm4x8(builtin_available_predicate avail)
4215 {
4216 ir_variable *p = in_var(glsl_type::uint_type, "p");
4217 MAKE_SIG(glsl_type::vec4_type, avail, 1, p);
4218 body.emit(ret(expr(ir_unop_unpack_snorm_4x8, p)));
4219 return sig;
4220 }
4221
4222 ir_function_signature *
4223 builtin_builder::_packHalf2x16(builtin_available_predicate avail)
4224 {
4225 ir_variable *v = in_var(glsl_type::vec2_type, "v");
4226 MAKE_SIG(glsl_type::uint_type, avail, 1, v);
4227 body.emit(ret(expr(ir_unop_pack_half_2x16, v)));
4228 return sig;
4229 }
4230
4231 ir_function_signature *
4232 builtin_builder::_unpackHalf2x16(builtin_available_predicate avail)
4233 {
4234 ir_variable *p = in_var(glsl_type::uint_type, "p");
4235 MAKE_SIG(glsl_type::vec2_type, avail, 1, p);
4236 body.emit(ret(expr(ir_unop_unpack_half_2x16, p)));
4237 return sig;
4238 }
4239
4240 ir_function_signature *
4241 builtin_builder::_packDouble2x32(builtin_available_predicate avail)
4242 {
4243 ir_variable *v = in_var(glsl_type::uvec2_type, "v");
4244 MAKE_SIG(glsl_type::double_type, avail, 1, v);
4245 body.emit(ret(expr(ir_unop_pack_double_2x32, v)));
4246 return sig;
4247 }
4248
4249 ir_function_signature *
4250 builtin_builder::_unpackDouble2x32(builtin_available_predicate avail)
4251 {
4252 ir_variable *p = in_var(glsl_type::double_type, "p");
4253 MAKE_SIG(glsl_type::uvec2_type, avail, 1, p);
4254 body.emit(ret(expr(ir_unop_unpack_double_2x32, p)));
4255 return sig;
4256 }
4257
4258 ir_function_signature *
4259 builtin_builder::_packInt2x32(builtin_available_predicate avail)
4260 {
4261 ir_variable *v = in_var(glsl_type::ivec2_type, "v");
4262 MAKE_SIG(glsl_type::int64_t_type, avail, 1, v);
4263 body.emit(ret(expr(ir_unop_pack_int_2x32, v)));
4264 return sig;
4265 }
4266
4267 ir_function_signature *
4268 builtin_builder::_unpackInt2x32(builtin_available_predicate avail)
4269 {
4270 ir_variable *p = in_var(glsl_type::int64_t_type, "p");
4271 MAKE_SIG(glsl_type::ivec2_type, avail, 1, p);
4272 body.emit(ret(expr(ir_unop_unpack_int_2x32, p)));
4273 return sig;
4274 }
4275
4276 ir_function_signature *
4277 builtin_builder::_packUint2x32(builtin_available_predicate avail)
4278 {
4279 ir_variable *v = in_var(glsl_type::uvec2_type, "v");
4280 MAKE_SIG(glsl_type::uint64_t_type, avail, 1, v);
4281 body.emit(ret(expr(ir_unop_pack_uint_2x32, v)));
4282 return sig;
4283 }
4284
4285 ir_function_signature *
4286 builtin_builder::_unpackUint2x32(builtin_available_predicate avail)
4287 {
4288 ir_variable *p = in_var(glsl_type::uint64_t_type, "p");
4289 MAKE_SIG(glsl_type::uvec2_type, avail, 1, p);
4290 body.emit(ret(expr(ir_unop_unpack_uint_2x32, p)));
4291 return sig;
4292 }
4293
4294 ir_function_signature *
4295 builtin_builder::_length(builtin_available_predicate avail, const glsl_type *type)
4296 {
4297 ir_variable *x = in_var(type, "x");
4298 MAKE_SIG(type->get_base_type(), avail, 1, x);
4299
4300 body.emit(ret(sqrt(dot(x, x))));
4301
4302 return sig;
4303 }
4304
4305 ir_function_signature *
4306 builtin_builder::_distance(builtin_available_predicate avail, const glsl_type *type)
4307 {
4308 ir_variable *p0 = in_var(type, "p0");
4309 ir_variable *p1 = in_var(type, "p1");
4310 MAKE_SIG(type->get_base_type(), avail, 2, p0, p1);
4311
4312 if (type->vector_elements == 1) {
4313 body.emit(ret(abs(sub(p0, p1))));
4314 } else {
4315 ir_variable *p = body.make_temp(type, "p");
4316 body.emit(assign(p, sub(p0, p1)));
4317 body.emit(ret(sqrt(dot(p, p))));
4318 }
4319
4320 return sig;
4321 }
4322
4323 ir_function_signature *
4324 builtin_builder::_dot(builtin_available_predicate avail, const glsl_type *type)
4325 {
4326 if (type->vector_elements == 1)
4327 return binop(avail, ir_binop_mul, type, type, type);
4328
4329 return binop(avail, ir_binop_dot,
4330 type->get_base_type(), type, type);
4331 }
4332
4333 ir_function_signature *
4334 builtin_builder::_cross(builtin_available_predicate avail, const glsl_type *type)
4335 {
4336 ir_variable *a = in_var(type, "a");
4337 ir_variable *b = in_var(type, "b");
4338 MAKE_SIG(type, avail, 2, a, b);
4339
4340 int yzx = MAKE_SWIZZLE4(SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, 0);
4341 int zxy = MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, 0);
4342
4343 body.emit(ret(sub(mul(swizzle(a, yzx, 3), swizzle(b, zxy, 3)),
4344 mul(swizzle(a, zxy, 3), swizzle(b, yzx, 3)))));
4345
4346 return sig;
4347 }
4348
4349 ir_function_signature *
4350 builtin_builder::_normalize(builtin_available_predicate avail, const glsl_type *type)
4351 {
4352 ir_variable *x = in_var(type, "x");
4353 MAKE_SIG(type, avail, 1, x);
4354
4355 if (type->vector_elements == 1) {
4356 body.emit(ret(sign(x)));
4357 } else {
4358 body.emit(ret(mul(x, rsq(dot(x, x)))));
4359 }
4360
4361 return sig;
4362 }
4363
4364 ir_function_signature *
4365 builtin_builder::_ftransform()
4366 {
4367 MAKE_SIG(glsl_type::vec4_type, compatibility_vs_only, 0);
4368
4369 /* ftransform() refers to global variables, and is always emitted
4370 * directly by ast_function.cpp. Just emit a prototype here so we
4371 * can recognize calls to it.
4372 */
4373 return sig;
4374 }
4375
4376 ir_function_signature *
4377 builtin_builder::_faceforward(builtin_available_predicate avail, const glsl_type *type)
4378 {
4379 ir_variable *N = in_var(type, "N");
4380 ir_variable *I = in_var(type, "I");
4381 ir_variable *Nref = in_var(type, "Nref");
4382 MAKE_SIG(type, avail, 3, N, I, Nref);
4383
4384 body.emit(if_tree(less(dot(Nref, I), IMM_FP(type, 0.0)),
4385 ret(N), ret(neg(N))));
4386
4387 return sig;
4388 }
4389
4390 ir_function_signature *
4391 builtin_builder::_reflect(builtin_available_predicate avail, const glsl_type *type)
4392 {
4393 ir_variable *I = in_var(type, "I");
4394 ir_variable *N = in_var(type, "N");
4395 MAKE_SIG(type, avail, 2, I, N);
4396
4397 /* I - 2 * dot(N, I) * N */
4398 body.emit(ret(sub(I, mul(IMM_FP(type, 2.0), mul(dot(N, I), N)))));
4399
4400 return sig;
4401 }
4402
4403 ir_function_signature *
4404 builtin_builder::_refract(builtin_available_predicate avail, const glsl_type *type)
4405 {
4406 ir_variable *I = in_var(type, "I");
4407 ir_variable *N = in_var(type, "N");
4408 ir_variable *eta = in_var(type->get_base_type(), "eta");
4409 MAKE_SIG(type, avail, 3, I, N, eta);
4410
4411 ir_variable *n_dot_i = body.make_temp(type->get_base_type(), "n_dot_i");
4412 body.emit(assign(n_dot_i, dot(N, I)));
4413
4414 /* From the GLSL 1.10 specification:
4415 * k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I))
4416 * if (k < 0.0)
4417 * return genType(0.0)
4418 * else
4419 * return eta * I - (eta * dot(N, I) + sqrt(k)) * N
4420 */
4421 ir_variable *k = body.make_temp(type->get_base_type(), "k");
4422 body.emit(assign(k, sub(IMM_FP(type, 1.0),
4423 mul(eta, mul(eta, sub(IMM_FP(type, 1.0),
4424 mul(n_dot_i, n_dot_i)))))));
4425 body.emit(if_tree(less(k, IMM_FP(type, 0.0)),
4426 ret(ir_constant::zero(mem_ctx, type)),
4427 ret(sub(mul(eta, I),
4428 mul(add(mul(eta, n_dot_i), sqrt(k)), N)))));
4429
4430 return sig;
4431 }
4432
4433 ir_function_signature *
4434 builtin_builder::_matrixCompMult(builtin_available_predicate avail, const glsl_type *type)
4435 {
4436 ir_variable *x = in_var(type, "x");
4437 ir_variable *y = in_var(type, "y");
4438 MAKE_SIG(type, avail, 2, x, y);
4439
4440 ir_variable *z = body.make_temp(type, "z");
4441 for (int i = 0; i < type->matrix_columns; i++) {
4442 body.emit(assign(array_ref(z, i), mul(array_ref(x, i), array_ref(y, i))));
4443 }
4444 body.emit(ret(z));
4445
4446 return sig;
4447 }
4448
4449 ir_function_signature *
4450 builtin_builder::_outerProduct(builtin_available_predicate avail, const glsl_type *type)
4451 {
4452 ir_variable *c;
4453 ir_variable *r;
4454
4455 if (type->base_type == GLSL_TYPE_DOUBLE) {
4456 r = in_var(glsl_type::dvec(type->matrix_columns), "r");
4457 c = in_var(glsl_type::dvec(type->vector_elements), "c");
4458 } else {
4459 r = in_var(glsl_type::vec(type->matrix_columns), "r");
4460 c = in_var(glsl_type::vec(type->vector_elements), "c");
4461 }
4462 MAKE_SIG(type, avail, 2, c, r);
4463
4464 ir_variable *m = body.make_temp(type, "m");
4465 for (int i = 0; i < type->matrix_columns; i++) {
4466 body.emit(assign(array_ref(m, i), mul(c, swizzle(r, i, 1))));
4467 }
4468 body.emit(ret(m));
4469
4470 return sig;
4471 }
4472
4473 ir_function_signature *
4474 builtin_builder::_transpose(builtin_available_predicate avail, const glsl_type *orig_type)
4475 {
4476 const glsl_type *transpose_type =
4477 glsl_type::get_instance(orig_type->base_type,
4478 orig_type->matrix_columns,
4479 orig_type->vector_elements);
4480
4481 ir_variable *m = in_var(orig_type, "m");
4482 MAKE_SIG(transpose_type, avail, 1, m);
4483
4484 ir_variable *t = body.make_temp(transpose_type, "t");
4485 for (int i = 0; i < orig_type->matrix_columns; i++) {
4486 for (int j = 0; j < orig_type->vector_elements; j++) {
4487 body.emit(assign(array_ref(t, j),
4488 matrix_elt(m, i, j),
4489 1 << i));
4490 }
4491 }
4492 body.emit(ret(t));
4493
4494 return sig;
4495 }
4496
4497 ir_function_signature *
4498 builtin_builder::_determinant_mat2(builtin_available_predicate avail, const glsl_type *type)
4499 {
4500 ir_variable *m = in_var(type, "m");
4501 MAKE_SIG(type->get_base_type(), avail, 1, m);
4502
4503 body.emit(ret(sub(mul(matrix_elt(m, 0, 0), matrix_elt(m, 1, 1)),
4504 mul(matrix_elt(m, 1, 0), matrix_elt(m, 0, 1)))));
4505
4506 return sig;
4507 }
4508
4509 ir_function_signature *
4510 builtin_builder::_determinant_mat3(builtin_available_predicate avail, const glsl_type *type)
4511 {
4512 ir_variable *m = in_var(type, "m");
4513 MAKE_SIG(type->get_base_type(), avail, 1, m);
4514
4515 ir_expression *f1 =
4516 sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 2, 2)),
4517 mul(matrix_elt(m, 1, 2), matrix_elt(m, 2, 1)));
4518
4519 ir_expression *f2 =
4520 sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 2)),
4521 mul(matrix_elt(m, 1, 2), matrix_elt(m, 2, 0)));
4522
4523 ir_expression *f3 =
4524 sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 1)),
4525 mul(matrix_elt(m, 1, 1), matrix_elt(m, 2, 0)));
4526
4527 body.emit(ret(add(sub(mul(matrix_elt(m, 0, 0), f1),
4528 mul(matrix_elt(m, 0, 1), f2)),
4529 mul(matrix_elt(m, 0, 2), f3))));
4530
4531 return sig;
4532 }
4533
4534 ir_function_signature *
4535 builtin_builder::_determinant_mat4(builtin_available_predicate avail, const glsl_type *type)
4536 {
4537 ir_variable *m = in_var(type, "m");
4538 const glsl_type *btype = type->get_base_type();
4539 MAKE_SIG(btype, avail, 1, m);
4540
4541 ir_variable *SubFactor00 = body.make_temp(btype, "SubFactor00");
4542 ir_variable *SubFactor01 = body.make_temp(btype, "SubFactor01");
4543 ir_variable *SubFactor02 = body.make_temp(btype, "SubFactor02");
4544 ir_variable *SubFactor03 = body.make_temp(btype, "SubFactor03");
4545 ir_variable *SubFactor04 = body.make_temp(btype, "SubFactor04");
4546 ir_variable *SubFactor05 = body.make_temp(btype, "SubFactor05");
4547 ir_variable *SubFactor06 = body.make_temp(btype, "SubFactor06");
4548 ir_variable *SubFactor07 = body.make_temp(btype, "SubFactor07");
4549 ir_variable *SubFactor08 = body.make_temp(btype, "SubFactor08");
4550 ir_variable *SubFactor09 = body.make_temp(btype, "SubFactor09");
4551 ir_variable *SubFactor10 = body.make_temp(btype, "SubFactor10");
4552 ir_variable *SubFactor11 = body.make_temp(btype, "SubFactor11");
4553 ir_variable *SubFactor12 = body.make_temp(btype, "SubFactor12");
4554 ir_variable *SubFactor13 = body.make_temp(btype, "SubFactor13");
4555 ir_variable *SubFactor14 = body.make_temp(btype, "SubFactor14");
4556 ir_variable *SubFactor15 = body.make_temp(btype, "SubFactor15");
4557 ir_variable *SubFactor16 = body.make_temp(btype, "SubFactor16");
4558 ir_variable *SubFactor17 = body.make_temp(btype, "SubFactor17");
4559 ir_variable *SubFactor18 = body.make_temp(btype, "SubFactor18");
4560
4561 body.emit(assign(SubFactor00, sub(mul(matrix_elt(m, 2, 2), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 2), matrix_elt(m, 2, 3)))));
4562 body.emit(assign(SubFactor01, sub(mul(matrix_elt(m, 2, 1), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 2, 3)))));
4563 body.emit(assign(SubFactor02, sub(mul(matrix_elt(m, 2, 1), matrix_elt(m, 3, 2)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 2, 2)))));
4564 body.emit(assign(SubFactor03, sub(mul(matrix_elt(m, 2, 0), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 2, 3)))));
4565 body.emit(assign(SubFactor04, sub(mul(matrix_elt(m, 2, 0), matrix_elt(m, 3, 2)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 2, 2)))));
4566 body.emit(assign(SubFactor05, sub(mul(matrix_elt(m, 2, 0), matrix_elt(m, 3, 1)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 2, 1)))));
4567 body.emit(assign(SubFactor06, sub(mul(matrix_elt(m, 1, 2), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 2), matrix_elt(m, 1, 3)))));
4568 body.emit(assign(SubFactor07, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 1, 3)))));
4569 body.emit(assign(SubFactor08, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 3, 2)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 1, 2)))));
4570 body.emit(assign(SubFactor09, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 1, 3)))));
4571 body.emit(assign(SubFactor10, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 3, 2)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 1, 2)))));
4572 body.emit(assign(SubFactor11, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 1, 3)))));
4573 body.emit(assign(SubFactor12, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 3, 1)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 1, 1)))));
4574 body.emit(assign(SubFactor13, sub(mul(matrix_elt(m, 1, 2), matrix_elt(m, 2, 3)), mul(matrix_elt(m, 2, 2), matrix_elt(m, 1, 3)))));
4575 body.emit(assign(SubFactor14, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 2, 3)), mul(matrix_elt(m, 2, 1), matrix_elt(m, 1, 3)))));
4576 body.emit(assign(SubFactor15, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 2, 2)), mul(matrix_elt(m, 2, 1), matrix_elt(m, 1, 2)))));
4577 body.emit(assign(SubFactor16, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 3)), mul(matrix_elt(m, 2, 0), matrix_elt(m, 1, 3)))));
4578 body.emit(assign(SubFactor17, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 2)), mul(matrix_elt(m, 2, 0), matrix_elt(m, 1, 2)))));
4579 body.emit(assign(SubFactor18, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 1)), mul(matrix_elt(m, 2, 0), matrix_elt(m, 1, 1)))));
4580
4581 ir_variable *adj_0 = body.make_temp(btype == glsl_type::float_type ? glsl_type::vec4_type : glsl_type::dvec4_type, "adj_0");
4582
4583 body.emit(assign(adj_0,
4584 add(sub(mul(matrix_elt(m, 1, 1), SubFactor00),
4585 mul(matrix_elt(m, 1, 2), SubFactor01)),
4586 mul(matrix_elt(m, 1, 3), SubFactor02)),
4587 WRITEMASK_X));
4588 body.emit(assign(adj_0, neg(
4589 add(sub(mul(matrix_elt(m, 1, 0), SubFactor00),
4590 mul(matrix_elt(m, 1, 2), SubFactor03)),
4591 mul(matrix_elt(m, 1, 3), SubFactor04))),
4592 WRITEMASK_Y));
4593 body.emit(assign(adj_0,
4594 add(sub(mul(matrix_elt(m, 1, 0), SubFactor01),
4595 mul(matrix_elt(m, 1, 1), SubFactor03)),
4596 mul(matrix_elt(m, 1, 3), SubFactor05)),
4597 WRITEMASK_Z));
4598 body.emit(assign(adj_0, neg(
4599 add(sub(mul(matrix_elt(m, 1, 0), SubFactor02),
4600 mul(matrix_elt(m, 1, 1), SubFactor04)),
4601 mul(matrix_elt(m, 1, 2), SubFactor05))),
4602 WRITEMASK_W));
4603
4604 body.emit(ret(dot(array_ref(m, 0), adj_0)));
4605
4606 return sig;
4607 }
4608
4609 ir_function_signature *
4610 builtin_builder::_inverse_mat2(builtin_available_predicate avail, const glsl_type *type)
4611 {
4612 ir_variable *m = in_var(type, "m");
4613 MAKE_SIG(type, avail, 1, m);
4614
4615 ir_variable *adj = body.make_temp(type, "adj");
4616 body.emit(assign(array_ref(adj, 0), matrix_elt(m, 1, 1), 1 << 0));
4617 body.emit(assign(array_ref(adj, 0), neg(matrix_elt(m, 0, 1)), 1 << 1));
4618 body.emit(assign(array_ref(adj, 1), neg(matrix_elt(m, 1, 0)), 1 << 0));
4619 body.emit(assign(array_ref(adj, 1), matrix_elt(m, 0, 0), 1 << 1));
4620
4621 ir_expression *det =
4622 sub(mul(matrix_elt(m, 0, 0), matrix_elt(m, 1, 1)),
4623 mul(matrix_elt(m, 1, 0), matrix_elt(m, 0, 1)));
4624
4625 body.emit(ret(div(adj, det)));
4626 return sig;
4627 }
4628
4629 ir_function_signature *
4630 builtin_builder::_inverse_mat3(builtin_available_predicate avail, const glsl_type *type)
4631 {
4632 ir_variable *m = in_var(type, "m");
4633 const glsl_type *btype = type->get_base_type();
4634 MAKE_SIG(type, avail, 1, m);
4635
4636 ir_variable *f11_22_21_12 = body.make_temp(btype, "f11_22_21_12");
4637 ir_variable *f10_22_20_12 = body.make_temp(btype, "f10_22_20_12");
4638 ir_variable *f10_21_20_11 = body.make_temp(btype, "f10_21_20_11");
4639
4640 body.emit(assign(f11_22_21_12,
4641 sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 2, 2)),
4642 mul(matrix_elt(m, 2, 1), matrix_elt(m, 1, 2)))));
4643 body.emit(assign(f10_22_20_12,
4644 sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 2)),
4645 mul(matrix_elt(m, 2, 0), matrix_elt(m, 1, 2)))));
4646 body.emit(assign(f10_21_20_11,
4647 sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 1)),
4648 mul(matrix_elt(m, 2, 0), matrix_elt(m, 1, 1)))));
4649
4650 ir_variable *adj = body.make_temp(type, "adj");
4651 body.emit(assign(array_ref(adj, 0), f11_22_21_12, WRITEMASK_X));
4652 body.emit(assign(array_ref(adj, 1), neg(f10_22_20_12), WRITEMASK_X));
4653 body.emit(assign(array_ref(adj, 2), f10_21_20_11, WRITEMASK_X));
4654
4655 body.emit(assign(array_ref(adj, 0), neg(
4656 sub(mul(matrix_elt(m, 0, 1), matrix_elt(m, 2, 2)),
4657 mul(matrix_elt(m, 2, 1), matrix_elt(m, 0, 2)))),
4658 WRITEMASK_Y));
4659 body.emit(assign(array_ref(adj, 1),
4660 sub(mul(matrix_elt(m, 0, 0), matrix_elt(m, 2, 2)),
4661 mul(matrix_elt(m, 2, 0), matrix_elt(m, 0, 2))),
4662 WRITEMASK_Y));
4663 body.emit(assign(array_ref(adj, 2), neg(
4664 sub(mul(matrix_elt(m, 0, 0), matrix_elt(m, 2, 1)),
4665 mul(matrix_elt(m, 2, 0), matrix_elt(m, 0, 1)))),
4666 WRITEMASK_Y));
4667
4668 body.emit(assign(array_ref(adj, 0),
4669 sub(mul(matrix_elt(m, 0, 1), matrix_elt(m, 1, 2)),
4670 mul(matrix_elt(m, 1, 1), matrix_elt(m, 0, 2))),
4671 WRITEMASK_Z));
4672 body.emit(assign(array_ref(adj, 1), neg(
4673 sub(mul(matrix_elt(m, 0, 0), matrix_elt(m, 1, 2)),
4674 mul(matrix_elt(m, 1, 0), matrix_elt(m, 0, 2)))),
4675 WRITEMASK_Z));
4676 body.emit(assign(array_ref(adj, 2),
4677 sub(mul(matrix_elt(m, 0, 0), matrix_elt(m, 1, 1)),
4678 mul(matrix_elt(m, 1, 0), matrix_elt(m, 0, 1))),
4679 WRITEMASK_Z));
4680
4681 ir_expression *det =
4682 add(sub(mul(matrix_elt(m, 0, 0), f11_22_21_12),
4683 mul(matrix_elt(m, 0, 1), f10_22_20_12)),
4684 mul(matrix_elt(m, 0, 2), f10_21_20_11));
4685
4686 body.emit(ret(div(adj, det)));
4687
4688 return sig;
4689 }
4690
4691 ir_function_signature *
4692 builtin_builder::_inverse_mat4(builtin_available_predicate avail, const glsl_type *type)
4693 {
4694 ir_variable *m = in_var(type, "m");
4695 const glsl_type *btype = type->get_base_type();
4696 MAKE_SIG(type, avail, 1, m);
4697
4698 ir_variable *SubFactor00 = body.make_temp(btype, "SubFactor00");
4699 ir_variable *SubFactor01 = body.make_temp(btype, "SubFactor01");
4700 ir_variable *SubFactor02 = body.make_temp(btype, "SubFactor02");
4701 ir_variable *SubFactor03 = body.make_temp(btype, "SubFactor03");
4702 ir_variable *SubFactor04 = body.make_temp(btype, "SubFactor04");
4703 ir_variable *SubFactor05 = body.make_temp(btype, "SubFactor05");
4704 ir_variable *SubFactor06 = body.make_temp(btype, "SubFactor06");
4705 ir_variable *SubFactor07 = body.make_temp(btype, "SubFactor07");
4706 ir_variable *SubFactor08 = body.make_temp(btype, "SubFactor08");
4707 ir_variable *SubFactor09 = body.make_temp(btype, "SubFactor09");
4708 ir_variable *SubFactor10 = body.make_temp(btype, "SubFactor10");
4709 ir_variable *SubFactor11 = body.make_temp(btype, "SubFactor11");
4710 ir_variable *SubFactor12 = body.make_temp(btype, "SubFactor12");
4711 ir_variable *SubFactor13 = body.make_temp(btype, "SubFactor13");
4712 ir_variable *SubFactor14 = body.make_temp(btype, "SubFactor14");
4713 ir_variable *SubFactor15 = body.make_temp(btype, "SubFactor15");
4714 ir_variable *SubFactor16 = body.make_temp(btype, "SubFactor16");
4715 ir_variable *SubFactor17 = body.make_temp(btype, "SubFactor17");
4716 ir_variable *SubFactor18 = body.make_temp(btype, "SubFactor18");
4717
4718 body.emit(assign(SubFactor00, sub(mul(matrix_elt(m, 2, 2), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 2), matrix_elt(m, 2, 3)))));
4719 body.emit(assign(SubFactor01, sub(mul(matrix_elt(m, 2, 1), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 2, 3)))));
4720 body.emit(assign(SubFactor02, sub(mul(matrix_elt(m, 2, 1), matrix_elt(m, 3, 2)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 2, 2)))));
4721 body.emit(assign(SubFactor03, sub(mul(matrix_elt(m, 2, 0), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 2, 3)))));
4722 body.emit(assign(SubFactor04, sub(mul(matrix_elt(m, 2, 0), matrix_elt(m, 3, 2)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 2, 2)))));
4723 body.emit(assign(SubFactor05, sub(mul(matrix_elt(m, 2, 0), matrix_elt(m, 3, 1)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 2, 1)))));
4724 body.emit(assign(SubFactor06, sub(mul(matrix_elt(m, 1, 2), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 2), matrix_elt(m, 1, 3)))));
4725 body.emit(assign(SubFactor07, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 1, 3)))));
4726 body.emit(assign(SubFactor08, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 3, 2)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 1, 2)))));
4727 body.emit(assign(SubFactor09, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 1, 3)))));
4728 body.emit(assign(SubFactor10, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 3, 2)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 1, 2)))));
4729 body.emit(assign(SubFactor11, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 3, 3)), mul(matrix_elt(m, 3, 1), matrix_elt(m, 1, 3)))));
4730 body.emit(assign(SubFactor12, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 3, 1)), mul(matrix_elt(m, 3, 0), matrix_elt(m, 1, 1)))));
4731 body.emit(assign(SubFactor13, sub(mul(matrix_elt(m, 1, 2), matrix_elt(m, 2, 3)), mul(matrix_elt(m, 2, 2), matrix_elt(m, 1, 3)))));
4732 body.emit(assign(SubFactor14, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 2, 3)), mul(matrix_elt(m, 2, 1), matrix_elt(m, 1, 3)))));
4733 body.emit(assign(SubFactor15, sub(mul(matrix_elt(m, 1, 1), matrix_elt(m, 2, 2)), mul(matrix_elt(m, 2, 1), matrix_elt(m, 1, 2)))));
4734 body.emit(assign(SubFactor16, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 3)), mul(matrix_elt(m, 2, 0), matrix_elt(m, 1, 3)))));
4735 body.emit(assign(SubFactor17, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 2)), mul(matrix_elt(m, 2, 0), matrix_elt(m, 1, 2)))));
4736 body.emit(assign(SubFactor18, sub(mul(matrix_elt(m, 1, 0), matrix_elt(m, 2, 1)), mul(matrix_elt(m, 2, 0), matrix_elt(m, 1, 1)))));
4737
4738 ir_variable *adj = body.make_temp(btype == glsl_type::float_type ? glsl_type::mat4_type : glsl_type::dmat4_type, "adj");
4739 body.emit(assign(array_ref(adj, 0),
4740 add(sub(mul(matrix_elt(m, 1, 1), SubFactor00),
4741 mul(matrix_elt(m, 1, 2), SubFactor01)),
4742 mul(matrix_elt(m, 1, 3), SubFactor02)),
4743 WRITEMASK_X));
4744 body.emit(assign(array_ref(adj, 1), neg(
4745 add(sub(mul(matrix_elt(m, 1, 0), SubFactor00),
4746 mul(matrix_elt(m, 1, 2), SubFactor03)),
4747 mul(matrix_elt(m, 1, 3), SubFactor04))),
4748 WRITEMASK_X));
4749 body.emit(assign(array_ref(adj, 2),
4750 add(sub(mul(matrix_elt(m, 1, 0), SubFactor01),
4751 mul(matrix_elt(m, 1, 1), SubFactor03)),
4752 mul(matrix_elt(m, 1, 3), SubFactor05)),
4753 WRITEMASK_X));
4754 body.emit(assign(array_ref(adj, 3), neg(
4755 add(sub(mul(matrix_elt(m, 1, 0), SubFactor02),
4756 mul(matrix_elt(m, 1, 1), SubFactor04)),
4757 mul(matrix_elt(m, 1, 2), SubFactor05))),
4758 WRITEMASK_X));
4759
4760 body.emit(assign(array_ref(adj, 0), neg(
4761 add(sub(mul(matrix_elt(m, 0, 1), SubFactor00),
4762 mul(matrix_elt(m, 0, 2), SubFactor01)),
4763 mul(matrix_elt(m, 0, 3), SubFactor02))),
4764 WRITEMASK_Y));
4765 body.emit(assign(array_ref(adj, 1),
4766 add(sub(mul(matrix_elt(m, 0, 0), SubFactor00),
4767 mul(matrix_elt(m, 0, 2), SubFactor03)),
4768 mul(matrix_elt(m, 0, 3), SubFactor04)),
4769 WRITEMASK_Y));
4770 body.emit(assign(array_ref(adj, 2), neg(
4771 add(sub(mul(matrix_elt(m, 0, 0), SubFactor01),
4772 mul(matrix_elt(m, 0, 1), SubFactor03)),
4773 mul(matrix_elt(m, 0, 3), SubFactor05))),
4774 WRITEMASK_Y));
4775 body.emit(assign(array_ref(adj, 3),
4776 add(sub(mul(matrix_elt(m, 0, 0), SubFactor02),
4777 mul(matrix_elt(m, 0, 1), SubFactor04)),
4778 mul(matrix_elt(m, 0, 2), SubFactor05)),
4779 WRITEMASK_Y));
4780
4781 body.emit(assign(array_ref(adj, 0),
4782 add(sub(mul(matrix_elt(m, 0, 1), SubFactor06),
4783 mul(matrix_elt(m, 0, 2), SubFactor07)),
4784 mul(matrix_elt(m, 0, 3), SubFactor08)),
4785 WRITEMASK_Z));
4786 body.emit(assign(array_ref(adj, 1), neg(
4787 add(sub(mul(matrix_elt(m, 0, 0), SubFactor06),
4788 mul(matrix_elt(m, 0, 2), SubFactor09)),
4789 mul(matrix_elt(m, 0, 3), SubFactor10))),
4790 WRITEMASK_Z));
4791 body.emit(assign(array_ref(adj, 2),
4792 add(sub(mul(matrix_elt(m, 0, 0), SubFactor11),
4793 mul(matrix_elt(m, 0, 1), SubFactor09)),
4794 mul(matrix_elt(m, 0, 3), SubFactor12)),
4795 WRITEMASK_Z));
4796 body.emit(assign(array_ref(adj, 3), neg(
4797 add(sub(mul(matrix_elt(m, 0, 0), SubFactor08),
4798 mul(matrix_elt(m, 0, 1), SubFactor10)),
4799 mul(matrix_elt(m, 0, 2), SubFactor12))),
4800 WRITEMASK_Z));
4801
4802 body.emit(assign(array_ref(adj, 0), neg(
4803 add(sub(mul(matrix_elt(m, 0, 1), SubFactor13),
4804 mul(matrix_elt(m, 0, 2), SubFactor14)),
4805 mul(matrix_elt(m, 0, 3), SubFactor15))),
4806 WRITEMASK_W));
4807 body.emit(assign(array_ref(adj, 1),
4808 add(sub(mul(matrix_elt(m, 0, 0), SubFactor13),
4809 mul(matrix_elt(m, 0, 2), SubFactor16)),
4810 mul(matrix_elt(m, 0, 3), SubFactor17)),
4811 WRITEMASK_W));
4812 body.emit(assign(array_ref(adj, 2), neg(
4813 add(sub(mul(matrix_elt(m, 0, 0), SubFactor14),
4814 mul(matrix_elt(m, 0, 1), SubFactor16)),
4815 mul(matrix_elt(m, 0, 3), SubFactor18))),
4816 WRITEMASK_W));
4817 body.emit(assign(array_ref(adj, 3),
4818 add(sub(mul(matrix_elt(m, 0, 0), SubFactor15),
4819 mul(matrix_elt(m, 0, 1), SubFactor17)),
4820 mul(matrix_elt(m, 0, 2), SubFactor18)),
4821 WRITEMASK_W));
4822
4823 ir_expression *det =
4824 add(mul(matrix_elt(m, 0, 0), matrix_elt(adj, 0, 0)),
4825 add(mul(matrix_elt(m, 0, 1), matrix_elt(adj, 1, 0)),
4826 add(mul(matrix_elt(m, 0, 2), matrix_elt(adj, 2, 0)),
4827 mul(matrix_elt(m, 0, 3), matrix_elt(adj, 3, 0)))));
4828
4829 body.emit(ret(div(adj, det)));
4830
4831 return sig;
4832 }
4833
4834
4835 ir_function_signature *
4836 builtin_builder::_lessThan(builtin_available_predicate avail,
4837 const glsl_type *type)
4838 {
4839 return binop(avail, ir_binop_less,
4840 glsl_type::bvec(type->vector_elements), type, type);
4841 }
4842
4843 ir_function_signature *
4844 builtin_builder::_lessThanEqual(builtin_available_predicate avail,
4845 const glsl_type *type)
4846 {
4847 return binop(avail, ir_binop_lequal,
4848 glsl_type::bvec(type->vector_elements), type, type);
4849 }
4850
4851 ir_function_signature *
4852 builtin_builder::_greaterThan(builtin_available_predicate avail,
4853 const glsl_type *type)
4854 {
4855 return binop(avail, ir_binop_greater,
4856 glsl_type::bvec(type->vector_elements), type, type);
4857 }
4858
4859 ir_function_signature *
4860 builtin_builder::_greaterThanEqual(builtin_available_predicate avail,
4861 const glsl_type *type)
4862 {
4863 return binop(avail, ir_binop_gequal,
4864 glsl_type::bvec(type->vector_elements), type, type);
4865 }
4866
4867 ir_function_signature *
4868 builtin_builder::_equal(builtin_available_predicate avail,
4869 const glsl_type *type)
4870 {
4871 return binop(avail, ir_binop_equal,
4872 glsl_type::bvec(type->vector_elements), type, type);
4873 }
4874
4875 ir_function_signature *
4876 builtin_builder::_notEqual(builtin_available_predicate avail,
4877 const glsl_type *type)
4878 {
4879 return binop(avail, ir_binop_nequal,
4880 glsl_type::bvec(type->vector_elements), type, type);
4881 }
4882
4883 ir_function_signature *
4884 builtin_builder::_any(const glsl_type *type)
4885 {
4886 ir_variable *v = in_var(type, "v");
4887 MAKE_SIG(glsl_type::bool_type, always_available, 1, v);
4888
4889 const unsigned vec_elem = v->type->vector_elements;
4890 body.emit(ret(expr(ir_binop_any_nequal, v, imm(false, vec_elem))));
4891
4892 return sig;
4893 }
4894
4895 ir_function_signature *
4896 builtin_builder::_all(const glsl_type *type)
4897 {
4898 ir_variable *v = in_var(type, "v");
4899 MAKE_SIG(glsl_type::bool_type, always_available, 1, v);
4900
4901 const unsigned vec_elem = v->type->vector_elements;
4902 body.emit(ret(expr(ir_binop_all_equal, v, imm(true, vec_elem))));
4903
4904 return sig;
4905 }
4906
4907 UNOP(not, ir_unop_logic_not, always_available)
4908
4909 static bool
4910 has_lod(const glsl_type *sampler_type)
4911 {
4912 assert(sampler_type->is_sampler());
4913
4914 switch (sampler_type->sampler_dimensionality) {
4915 case GLSL_SAMPLER_DIM_RECT:
4916 case GLSL_SAMPLER_DIM_BUF:
4917 case GLSL_SAMPLER_DIM_MS:
4918 return false;
4919 default:
4920 return true;
4921 }
4922 }
4923
4924 ir_function_signature *
4925 builtin_builder::_textureSize(builtin_available_predicate avail,
4926 const glsl_type *return_type,
4927 const glsl_type *sampler_type)
4928 {
4929 ir_variable *s = in_var(sampler_type, "sampler");
4930 /* The sampler always exists; add optional lod later. */
4931 MAKE_SIG(return_type, avail, 1, s);
4932
4933 ir_texture *tex = new(mem_ctx) ir_texture(ir_txs);
4934 tex->set_sampler(new(mem_ctx) ir_dereference_variable(s), return_type);
4935
4936 if (has_lod(sampler_type)) {
4937 ir_variable *lod = in_var(glsl_type::int_type, "lod");
4938 sig->parameters.push_tail(lod);
4939 tex->lod_info.lod = var_ref(lod);
4940 } else {
4941 tex->lod_info.lod = imm(0u);
4942 }
4943
4944 body.emit(ret(tex));
4945
4946 return sig;
4947 }
4948
4949 ir_function_signature *
4950 builtin_builder::_textureSamples(const glsl_type *sampler_type)
4951 {
4952 ir_variable *s = in_var(sampler_type, "sampler");
4953 MAKE_SIG(glsl_type::int_type, shader_samples, 1, s);
4954
4955 ir_texture *tex = new(mem_ctx) ir_texture(ir_texture_samples);
4956 tex->set_sampler(new(mem_ctx) ir_dereference_variable(s), glsl_type::int_type);
4957 body.emit(ret(tex));
4958
4959 return sig;
4960 }
4961
4962 ir_function_signature *
4963 builtin_builder::_texture(ir_texture_opcode opcode,
4964 builtin_available_predicate avail,
4965 const glsl_type *return_type,
4966 const glsl_type *sampler_type,
4967 const glsl_type *coord_type,
4968 int flags)
4969 {
4970 ir_variable *s = in_var(sampler_type, "sampler");
4971 ir_variable *P = in_var(coord_type, "P");
4972 /* The sampler and coordinate always exist; add optional parameters later. */
4973 MAKE_SIG(return_type, avail, 2, s, P);
4974
4975 ir_texture *tex = new(mem_ctx) ir_texture(opcode);
4976 tex->set_sampler(var_ref(s), return_type);
4977
4978 const int coord_size = sampler_type->coordinate_components();
4979
4980 if (coord_size == coord_type->vector_elements) {
4981 tex->coordinate = var_ref(P);
4982 } else {
4983 /* The incoming coordinate also has the projector or shadow comparator,
4984 * so we need to swizzle those away.
4985 */
4986 tex->coordinate = swizzle_for_size(P, coord_size);
4987 }
4988
4989 /* The projector is always in the last component. */
4990 if (flags & TEX_PROJECT)
4991 tex->projector = swizzle(P, coord_type->vector_elements - 1, 1);
4992
4993 if (sampler_type->sampler_shadow) {
4994 if (opcode == ir_tg4) {
4995 /* gather has refz as a separate parameter, immediately after the
4996 * coordinate
4997 */
4998 ir_variable *refz = in_var(glsl_type::float_type, "refz");
4999 sig->parameters.push_tail(refz);
5000 tex->shadow_comparator = var_ref(refz);
5001 } else {
5002 /* The shadow comparator is normally in the Z component, but a few types
5003 * have sufficiently large coordinates that it's in W.
5004 */
5005 tex->shadow_comparator = swizzle(P, MAX2(coord_size, SWIZZLE_Z), 1);
5006 }
5007 }
5008
5009 if (opcode == ir_txl) {
5010 ir_variable *lod = in_var(glsl_type::float_type, "lod");
5011 sig->parameters.push_tail(lod);
5012 tex->lod_info.lod = var_ref(lod);
5013 } else if (opcode == ir_txd) {
5014 int grad_size = coord_size - (sampler_type->sampler_array ? 1 : 0);
5015 ir_variable *dPdx = in_var(glsl_type::vec(grad_size), "dPdx");
5016 ir_variable *dPdy = in_var(glsl_type::vec(grad_size), "dPdy");
5017 sig->parameters.push_tail(dPdx);
5018 sig->parameters.push_tail(dPdy);
5019 tex->lod_info.grad.dPdx = var_ref(dPdx);
5020 tex->lod_info.grad.dPdy = var_ref(dPdy);
5021 }
5022
5023 if (flags & (TEX_OFFSET | TEX_OFFSET_NONCONST)) {
5024 int offset_size = coord_size - (sampler_type->sampler_array ? 1 : 0);
5025 ir_variable *offset =
5026 new(mem_ctx) ir_variable(glsl_type::ivec(offset_size), "offset",
5027 (flags & TEX_OFFSET) ? ir_var_const_in : ir_var_function_in);
5028 sig->parameters.push_tail(offset);
5029 tex->offset = var_ref(offset);
5030 }
5031
5032 if (flags & TEX_OFFSET_ARRAY) {
5033 ir_variable *offsets =
5034 new(mem_ctx) ir_variable(glsl_type::get_array_instance(glsl_type::ivec2_type, 4),
5035 "offsets", ir_var_const_in);
5036 sig->parameters.push_tail(offsets);
5037 tex->offset = var_ref(offsets);
5038 }
5039
5040 if (opcode == ir_tg4) {
5041 if (flags & TEX_COMPONENT) {
5042 ir_variable *component =
5043 new(mem_ctx) ir_variable(glsl_type::int_type, "comp", ir_var_const_in);
5044 sig->parameters.push_tail(component);
5045 tex->lod_info.component = var_ref(component);
5046 }
5047 else {
5048 tex->lod_info.component = imm(0);
5049 }
5050 }
5051
5052 /* The "bias" parameter comes /after/ the "offset" parameter, which is
5053 * inconsistent with both textureLodOffset and textureGradOffset.
5054 */
5055 if (opcode == ir_txb) {
5056 ir_variable *bias = in_var(glsl_type::float_type, "bias");
5057 sig->parameters.push_tail(bias);
5058 tex->lod_info.bias = var_ref(bias);
5059 }
5060
5061 body.emit(ret(tex));
5062
5063 return sig;
5064 }
5065
5066 ir_function_signature *
5067 builtin_builder::_textureCubeArrayShadow(builtin_available_predicate avail,
5068 const glsl_type *sampler_type)
5069 {
5070 ir_variable *s = in_var(sampler_type, "sampler");
5071 ir_variable *P = in_var(glsl_type::vec4_type, "P");
5072 ir_variable *compare = in_var(glsl_type::float_type, "compare");
5073 MAKE_SIG(glsl_type::float_type, avail, 3, s, P, compare);
5074
5075 ir_texture *tex = new(mem_ctx) ir_texture(ir_tex);
5076 tex->set_sampler(var_ref(s), glsl_type::float_type);
5077
5078 tex->coordinate = var_ref(P);
5079 tex->shadow_comparator = var_ref(compare);
5080
5081 body.emit(ret(tex));
5082
5083 return sig;
5084 }
5085
5086 ir_function_signature *
5087 builtin_builder::_texelFetch(builtin_available_predicate avail,
5088 const glsl_type *return_type,
5089 const glsl_type *sampler_type,
5090 const glsl_type *coord_type,
5091 const glsl_type *offset_type)
5092 {
5093 ir_variable *s = in_var(sampler_type, "sampler");
5094 ir_variable *P = in_var(coord_type, "P");
5095 /* The sampler and coordinate always exist; add optional parameters later. */
5096 MAKE_SIG(return_type, avail, 2, s, P);
5097
5098 ir_texture *tex = new(mem_ctx) ir_texture(ir_txf);
5099 tex->coordinate = var_ref(P);
5100 tex->set_sampler(var_ref(s), return_type);
5101
5102 if (sampler_type->sampler_dimensionality == GLSL_SAMPLER_DIM_MS) {
5103 ir_variable *sample = in_var(glsl_type::int_type, "sample");
5104 sig->parameters.push_tail(sample);
5105 tex->lod_info.sample_index = var_ref(sample);
5106 tex->op = ir_txf_ms;
5107 } else if (has_lod(sampler_type)) {
5108 ir_variable *lod = in_var(glsl_type::int_type, "lod");
5109 sig->parameters.push_tail(lod);
5110 tex->lod_info.lod = var_ref(lod);
5111 } else {
5112 tex->lod_info.lod = imm(0u);
5113 }
5114
5115 if (offset_type != NULL) {
5116 ir_variable *offset =
5117 new(mem_ctx) ir_variable(offset_type, "offset", ir_var_const_in);
5118 sig->parameters.push_tail(offset);
5119 tex->offset = var_ref(offset);
5120 }
5121
5122 body.emit(ret(tex));
5123
5124 return sig;
5125 }
5126
5127 ir_function_signature *
5128 builtin_builder::_EmitVertex()
5129 {
5130 MAKE_SIG(glsl_type::void_type, gs_only, 0);
5131
5132 ir_rvalue *stream = new(mem_ctx) ir_constant(0, 1);
5133 body.emit(new(mem_ctx) ir_emit_vertex(stream));
5134
5135 return sig;
5136 }
5137
5138 ir_function_signature *
5139 builtin_builder::_EmitStreamVertex(builtin_available_predicate avail,
5140 const glsl_type *stream_type)
5141 {
5142 /* Section 8.12 (Geometry Shader Functions) of the GLSL 4.0 spec says:
5143 *
5144 * "Emit the current values of output variables to the current output
5145 * primitive on stream stream. The argument to stream must be a constant
5146 * integral expression."
5147 */
5148 ir_variable *stream =
5149 new(mem_ctx) ir_variable(stream_type, "stream", ir_var_const_in);
5150
5151 MAKE_SIG(glsl_type::void_type, avail, 1, stream);
5152
5153 body.emit(new(mem_ctx) ir_emit_vertex(var_ref(stream)));
5154
5155 return sig;
5156 }
5157
5158 ir_function_signature *
5159 builtin_builder::_EndPrimitive()
5160 {
5161 MAKE_SIG(glsl_type::void_type, gs_only, 0);
5162
5163 ir_rvalue *stream = new(mem_ctx) ir_constant(0, 1);
5164 body.emit(new(mem_ctx) ir_end_primitive(stream));
5165
5166 return sig;
5167 }
5168
5169 ir_function_signature *
5170 builtin_builder::_EndStreamPrimitive(builtin_available_predicate avail,
5171 const glsl_type *stream_type)
5172 {
5173 /* Section 8.12 (Geometry Shader Functions) of the GLSL 4.0 spec says:
5174 *
5175 * "Completes the current output primitive on stream stream and starts
5176 * a new one. The argument to stream must be a constant integral
5177 * expression."
5178 */
5179 ir_variable *stream =
5180 new(mem_ctx) ir_variable(stream_type, "stream", ir_var_const_in);
5181
5182 MAKE_SIG(glsl_type::void_type, avail, 1, stream);
5183
5184 body.emit(new(mem_ctx) ir_end_primitive(var_ref(stream)));
5185
5186 return sig;
5187 }
5188
5189 ir_function_signature *
5190 builtin_builder::_barrier()
5191 {
5192 MAKE_SIG(glsl_type::void_type, barrier_supported, 0);
5193
5194 body.emit(new(mem_ctx) ir_barrier());
5195 return sig;
5196 }
5197
5198 ir_function_signature *
5199 builtin_builder::_textureQueryLod(builtin_available_predicate avail,
5200 const glsl_type *sampler_type,
5201 const glsl_type *coord_type)
5202 {
5203 ir_variable *s = in_var(sampler_type, "sampler");
5204 ir_variable *coord = in_var(coord_type, "coord");
5205 /* The sampler and coordinate always exist; add optional parameters later. */
5206 MAKE_SIG(glsl_type::vec2_type, avail, 2, s, coord);
5207
5208 ir_texture *tex = new(mem_ctx) ir_texture(ir_lod);
5209 tex->coordinate = var_ref(coord);
5210 tex->set_sampler(var_ref(s), glsl_type::vec2_type);
5211
5212 body.emit(ret(tex));
5213
5214 return sig;
5215 }
5216
5217 ir_function_signature *
5218 builtin_builder::_textureQueryLevels(const glsl_type *sampler_type)
5219 {
5220 ir_variable *s = in_var(sampler_type, "sampler");
5221 const glsl_type *return_type = glsl_type::int_type;
5222 MAKE_SIG(return_type, texture_query_levels, 1, s);
5223
5224 ir_texture *tex = new(mem_ctx) ir_texture(ir_query_levels);
5225 tex->set_sampler(var_ref(s), return_type);
5226
5227 body.emit(ret(tex));
5228
5229 return sig;
5230 }
5231
5232 ir_function_signature *
5233 builtin_builder::_textureSamplesIdentical(builtin_available_predicate avail,
5234 const glsl_type *sampler_type,
5235 const glsl_type *coord_type)
5236 {
5237 ir_variable *s = in_var(sampler_type, "sampler");
5238 ir_variable *P = in_var(coord_type, "P");
5239 const glsl_type *return_type = glsl_type::bool_type;
5240 MAKE_SIG(return_type, avail, 2, s, P);
5241
5242 ir_texture *tex = new(mem_ctx) ir_texture(ir_samples_identical);
5243 tex->coordinate = var_ref(P);
5244 tex->set_sampler(var_ref(s), return_type);
5245
5246 body.emit(ret(tex));
5247
5248 return sig;
5249 }
5250
5251 UNOP(dFdx, ir_unop_dFdx, fs_oes_derivatives)
5252 UNOP(dFdxCoarse, ir_unop_dFdx_coarse, fs_derivative_control)
5253 UNOP(dFdxFine, ir_unop_dFdx_fine, fs_derivative_control)
5254 UNOP(dFdy, ir_unop_dFdy, fs_oes_derivatives)
5255 UNOP(dFdyCoarse, ir_unop_dFdy_coarse, fs_derivative_control)
5256 UNOP(dFdyFine, ir_unop_dFdy_fine, fs_derivative_control)
5257
5258 ir_function_signature *
5259 builtin_builder::_fwidth(const glsl_type *type)
5260 {
5261 ir_variable *p = in_var(type, "p");
5262 MAKE_SIG(type, fs_oes_derivatives, 1, p);
5263
5264 body.emit(ret(add(abs(expr(ir_unop_dFdx, p)), abs(expr(ir_unop_dFdy, p)))));
5265
5266 return sig;
5267 }
5268
5269 ir_function_signature *
5270 builtin_builder::_fwidthCoarse(const glsl_type *type)
5271 {
5272 ir_variable *p = in_var(type, "p");
5273 MAKE_SIG(type, fs_derivative_control, 1, p);
5274
5275 body.emit(ret(add(abs(expr(ir_unop_dFdx_coarse, p)),
5276 abs(expr(ir_unop_dFdy_coarse, p)))));
5277
5278 return sig;
5279 }
5280
5281 ir_function_signature *
5282 builtin_builder::_fwidthFine(const glsl_type *type)
5283 {
5284 ir_variable *p = in_var(type, "p");
5285 MAKE_SIG(type, fs_derivative_control, 1, p);
5286
5287 body.emit(ret(add(abs(expr(ir_unop_dFdx_fine, p)),
5288 abs(expr(ir_unop_dFdy_fine, p)))));
5289
5290 return sig;
5291 }
5292
5293 ir_function_signature *
5294 builtin_builder::_noise1(const glsl_type *type)
5295 {
5296 return unop(v110, ir_unop_noise, glsl_type::float_type, type);
5297 }
5298
5299 ir_function_signature *
5300 builtin_builder::_noise2(const glsl_type *type)
5301 {
5302 ir_variable *p = in_var(type, "p");
5303 MAKE_SIG(glsl_type::vec2_type, v110, 1, p);
5304
5305 ir_constant_data b_offset;
5306 b_offset.f[0] = 601.0f;
5307 b_offset.f[1] = 313.0f;
5308 b_offset.f[2] = 29.0f;
5309 b_offset.f[3] = 277.0f;
5310
5311 ir_variable *a = body.make_temp(glsl_type::float_type, "a");
5312 ir_variable *b = body.make_temp(glsl_type::float_type, "b");
5313 ir_variable *t = body.make_temp(glsl_type::vec2_type, "t");
5314 body.emit(assign(a, expr(ir_unop_noise, p)));
5315 body.emit(assign(b, expr(ir_unop_noise, add(p, imm(type, b_offset)))));
5316 body.emit(assign(t, a, WRITEMASK_X));
5317 body.emit(assign(t, b, WRITEMASK_Y));
5318 body.emit(ret(t));
5319
5320 return sig;
5321 }
5322
5323 ir_function_signature *
5324 builtin_builder::_noise3(const glsl_type *type)
5325 {
5326 ir_variable *p = in_var(type, "p");
5327 MAKE_SIG(glsl_type::vec3_type, v110, 1, p);
5328
5329 ir_constant_data b_offset;
5330 b_offset.f[0] = 601.0f;
5331 b_offset.f[1] = 313.0f;
5332 b_offset.f[2] = 29.0f;
5333 b_offset.f[3] = 277.0f;
5334
5335 ir_constant_data c_offset;
5336 c_offset.f[0] = 1559.0f;
5337 c_offset.f[1] = 113.0f;
5338 c_offset.f[2] = 1861.0f;
5339 c_offset.f[3] = 797.0f;
5340
5341 ir_variable *a = body.make_temp(glsl_type::float_type, "a");
5342 ir_variable *b = body.make_temp(glsl_type::float_type, "b");
5343 ir_variable *c = body.make_temp(glsl_type::float_type, "c");
5344 ir_variable *t = body.make_temp(glsl_type::vec3_type, "t");
5345 body.emit(assign(a, expr(ir_unop_noise, p)));
5346 body.emit(assign(b, expr(ir_unop_noise, add(p, imm(type, b_offset)))));
5347 body.emit(assign(c, expr(ir_unop_noise, add(p, imm(type, c_offset)))));
5348 body.emit(assign(t, a, WRITEMASK_X));
5349 body.emit(assign(t, b, WRITEMASK_Y));
5350 body.emit(assign(t, c, WRITEMASK_Z));
5351 body.emit(ret(t));
5352
5353 return sig;
5354 }
5355
5356 ir_function_signature *
5357 builtin_builder::_noise4(const glsl_type *type)
5358 {
5359 ir_variable *p = in_var(type, "p");
5360 MAKE_SIG(glsl_type::vec4_type, v110, 1, p);
5361
5362 ir_variable *_p = body.make_temp(type, "_p");
5363
5364 ir_constant_data p_offset;
5365 p_offset.f[0] = 1559.0f;
5366 p_offset.f[1] = 113.0f;
5367 p_offset.f[2] = 1861.0f;
5368 p_offset.f[3] = 797.0f;
5369
5370 body.emit(assign(_p, add(p, imm(type, p_offset))));
5371
5372 ir_constant_data offset;
5373 offset.f[0] = 601.0f;
5374 offset.f[1] = 313.0f;
5375 offset.f[2] = 29.0f;
5376 offset.f[3] = 277.0f;
5377
5378 ir_variable *a = body.make_temp(glsl_type::float_type, "a");
5379 ir_variable *b = body.make_temp(glsl_type::float_type, "b");
5380 ir_variable *c = body.make_temp(glsl_type::float_type, "c");
5381 ir_variable *d = body.make_temp(glsl_type::float_type, "d");
5382 ir_variable *t = body.make_temp(glsl_type::vec4_type, "t");
5383 body.emit(assign(a, expr(ir_unop_noise, p)));
5384 body.emit(assign(b, expr(ir_unop_noise, add(p, imm(type, offset)))));
5385 body.emit(assign(c, expr(ir_unop_noise, _p)));
5386 body.emit(assign(d, expr(ir_unop_noise, add(_p, imm(type, offset)))));
5387 body.emit(assign(t, a, WRITEMASK_X));
5388 body.emit(assign(t, b, WRITEMASK_Y));
5389 body.emit(assign(t, c, WRITEMASK_Z));
5390 body.emit(assign(t, d, WRITEMASK_W));
5391 body.emit(ret(t));
5392
5393 return sig;
5394 }
5395
5396 ir_function_signature *
5397 builtin_builder::_bitfieldExtract(const glsl_type *type)
5398 {
5399 bool is_uint = type->base_type == GLSL_TYPE_UINT;
5400 ir_variable *value = in_var(type, "value");
5401 ir_variable *offset = in_var(glsl_type::int_type, "offset");
5402 ir_variable *bits = in_var(glsl_type::int_type, "bits");
5403 MAKE_SIG(type, gpu_shader5_or_es31_or_integer_functions, 3, value, offset,
5404 bits);
5405
5406 operand cast_offset = is_uint ? i2u(offset) : operand(offset);
5407 operand cast_bits = is_uint ? i2u(bits) : operand(bits);
5408
5409 body.emit(ret(expr(ir_triop_bitfield_extract, value,
5410 swizzle(cast_offset, SWIZZLE_XXXX, type->vector_elements),
5411 swizzle(cast_bits, SWIZZLE_XXXX, type->vector_elements))));
5412
5413 return sig;
5414 }
5415
5416 ir_function_signature *
5417 builtin_builder::_bitfieldInsert(const glsl_type *type)
5418 {
5419 bool is_uint = type->base_type == GLSL_TYPE_UINT;
5420 ir_variable *base = in_var(type, "base");
5421 ir_variable *insert = in_var(type, "insert");
5422 ir_variable *offset = in_var(glsl_type::int_type, "offset");
5423 ir_variable *bits = in_var(glsl_type::int_type, "bits");
5424 MAKE_SIG(type, gpu_shader5_or_es31_or_integer_functions, 4, base, insert,
5425 offset, bits);
5426
5427 operand cast_offset = is_uint ? i2u(offset) : operand(offset);
5428 operand cast_bits = is_uint ? i2u(bits) : operand(bits);
5429
5430 body.emit(ret(bitfield_insert(base, insert,
5431 swizzle(cast_offset, SWIZZLE_XXXX, type->vector_elements),
5432 swizzle(cast_bits, SWIZZLE_XXXX, type->vector_elements))));
5433
5434 return sig;
5435 }
5436
5437 UNOP(bitfieldReverse, ir_unop_bitfield_reverse, gpu_shader5_or_es31_or_integer_functions)
5438
5439 ir_function_signature *
5440 builtin_builder::_bitCount(const glsl_type *type)
5441 {
5442 return unop(gpu_shader5_or_es31_or_integer_functions, ir_unop_bit_count,
5443 glsl_type::ivec(type->vector_elements), type);
5444 }
5445
5446 ir_function_signature *
5447 builtin_builder::_findLSB(const glsl_type *type)
5448 {
5449 return unop(gpu_shader5_or_es31_or_integer_functions, ir_unop_find_lsb,
5450 glsl_type::ivec(type->vector_elements), type);
5451 }
5452
5453 ir_function_signature *
5454 builtin_builder::_findMSB(const glsl_type *type)
5455 {
5456 return unop(gpu_shader5_or_es31_or_integer_functions, ir_unop_find_msb,
5457 glsl_type::ivec(type->vector_elements), type);
5458 }
5459
5460 ir_function_signature *
5461 builtin_builder::_fma(builtin_available_predicate avail, const glsl_type *type)
5462 {
5463 ir_variable *a = in_var(type, "a");
5464 ir_variable *b = in_var(type, "b");
5465 ir_variable *c = in_var(type, "c");
5466 MAKE_SIG(type, avail, 3, a, b, c);
5467
5468 body.emit(ret(ir_builder::fma(a, b, c)));
5469
5470 return sig;
5471 }
5472
5473 ir_function_signature *
5474 builtin_builder::_ldexp(const glsl_type *x_type, const glsl_type *exp_type)
5475 {
5476 return binop(x_type->base_type == GLSL_TYPE_DOUBLE ? fp64 : gpu_shader5_or_es31_or_integer_functions,
5477 ir_binop_ldexp, x_type, x_type, exp_type);
5478 }
5479
5480 ir_function_signature *
5481 builtin_builder::_dfrexp(const glsl_type *x_type, const glsl_type *exp_type)
5482 {
5483 ir_variable *x = in_var(x_type, "x");
5484 ir_variable *exponent = out_var(exp_type, "exp");
5485 MAKE_SIG(x_type, fp64, 2, x, exponent);
5486
5487 body.emit(assign(exponent, expr(ir_unop_frexp_exp, x)));
5488
5489 body.emit(ret(expr(ir_unop_frexp_sig, x)));
5490 return sig;
5491 }
5492
5493 ir_function_signature *
5494 builtin_builder::_frexp(const glsl_type *x_type, const glsl_type *exp_type)
5495 {
5496 ir_variable *x = in_var(x_type, "x");
5497 ir_variable *exponent = out_var(exp_type, "exp");
5498 MAKE_SIG(x_type, gpu_shader5_or_es31_or_integer_functions, 2, x, exponent);
5499
5500 const unsigned vec_elem = x_type->vector_elements;
5501 const glsl_type *bvec = glsl_type::get_instance(GLSL_TYPE_BOOL, vec_elem, 1);
5502 const glsl_type *uvec = glsl_type::get_instance(GLSL_TYPE_UINT, vec_elem, 1);
5503
5504 /* Single-precision floating-point values are stored as
5505 * 1 sign bit;
5506 * 8 exponent bits;
5507 * 23 mantissa bits.
5508 *
5509 * An exponent shift of 23 will shift the mantissa out, leaving only the
5510 * exponent and sign bit (which itself may be zero, if the absolute value
5511 * was taken before the bitcast and shift.
5512 */
5513 ir_constant *exponent_shift = imm(23);
5514 ir_constant *exponent_bias = imm(-126, vec_elem);
5515
5516 ir_constant *sign_mantissa_mask = imm(0x807fffffu, vec_elem);
5517
5518 /* Exponent of floating-point values in the range [0.5, 1.0). */
5519 ir_constant *exponent_value = imm(0x3f000000u, vec_elem);
5520
5521 ir_variable *is_not_zero = body.make_temp(bvec, "is_not_zero");
5522 body.emit(assign(is_not_zero, nequal(abs(x), imm(0.0f, vec_elem))));
5523
5524 /* Since abs(x) ensures that the sign bit is zero, we don't need to bitcast
5525 * to unsigned integers to ensure that 1 bits aren't shifted in.
5526 */
5527 body.emit(assign(exponent, rshift(bitcast_f2i(abs(x)), exponent_shift)));
5528 body.emit(assign(exponent, add(exponent, csel(is_not_zero, exponent_bias,
5529 imm(0, vec_elem)))));
5530
5531 ir_variable *bits = body.make_temp(uvec, "bits");
5532 body.emit(assign(bits, bitcast_f2u(x)));
5533 body.emit(assign(bits, bit_and(bits, sign_mantissa_mask)));
5534 body.emit(assign(bits, bit_or(bits, csel(is_not_zero, exponent_value,
5535 imm(0u, vec_elem)))));
5536 body.emit(ret(bitcast_u2f(bits)));
5537
5538 return sig;
5539 }
5540
5541 ir_function_signature *
5542 builtin_builder::_uaddCarry(const glsl_type *type)
5543 {
5544 ir_variable *x = in_var(type, "x");
5545 ir_variable *y = in_var(type, "y");
5546 ir_variable *carry = out_var(type, "carry");
5547 MAKE_SIG(type, gpu_shader5_or_es31_or_integer_functions, 3, x, y, carry);
5548
5549 body.emit(assign(carry, ir_builder::carry(x, y)));
5550 body.emit(ret(add(x, y)));
5551
5552 return sig;
5553 }
5554
5555 ir_function_signature *
5556 builtin_builder::_usubBorrow(const glsl_type *type)
5557 {
5558 ir_variable *x = in_var(type, "x");
5559 ir_variable *y = in_var(type, "y");
5560 ir_variable *borrow = out_var(type, "borrow");
5561 MAKE_SIG(type, gpu_shader5_or_es31_or_integer_functions, 3, x, y, borrow);
5562
5563 body.emit(assign(borrow, ir_builder::borrow(x, y)));
5564 body.emit(ret(sub(x, y)));
5565
5566 return sig;
5567 }
5568
5569 /**
5570 * For both imulExtended() and umulExtended() built-ins.
5571 */
5572 ir_function_signature *
5573 builtin_builder::_mulExtended(const glsl_type *type)
5574 {
5575 ir_variable *x = in_var(type, "x");
5576 ir_variable *y = in_var(type, "y");
5577 ir_variable *msb = out_var(type, "msb");
5578 ir_variable *lsb = out_var(type, "lsb");
5579 MAKE_SIG(glsl_type::void_type, gpu_shader5_or_es31_or_integer_functions, 4, x, y, msb, lsb);
5580
5581 body.emit(assign(msb, imul_high(x, y)));
5582 body.emit(assign(lsb, mul(x, y)));
5583
5584 return sig;
5585 }
5586
5587 ir_function_signature *
5588 builtin_builder::_interpolateAtCentroid(const glsl_type *type)
5589 {
5590 ir_variable *interpolant = in_var(type, "interpolant");
5591 interpolant->data.must_be_shader_input = 1;
5592 MAKE_SIG(type, fs_interpolate_at, 1, interpolant);
5593
5594 body.emit(ret(interpolate_at_centroid(interpolant)));
5595
5596 return sig;
5597 }
5598
5599 ir_function_signature *
5600 builtin_builder::_interpolateAtOffset(const glsl_type *type)
5601 {
5602 ir_variable *interpolant = in_var(type, "interpolant");
5603 interpolant->data.must_be_shader_input = 1;
5604 ir_variable *offset = in_var(glsl_type::vec2_type, "offset");
5605 MAKE_SIG(type, fs_interpolate_at, 2, interpolant, offset);
5606
5607 body.emit(ret(interpolate_at_offset(interpolant, offset)));
5608
5609 return sig;
5610 }
5611
5612 ir_function_signature *
5613 builtin_builder::_interpolateAtSample(const glsl_type *type)
5614 {
5615 ir_variable *interpolant = in_var(type, "interpolant");
5616 interpolant->data.must_be_shader_input = 1;
5617 ir_variable *sample_num = in_var(glsl_type::int_type, "sample_num");
5618 MAKE_SIG(type, fs_interpolate_at, 2, interpolant, sample_num);
5619
5620 body.emit(ret(interpolate_at_sample(interpolant, sample_num)));
5621
5622 return sig;
5623 }
5624
5625 ir_function_signature *
5626 builtin_builder::_atomic_counter_intrinsic(builtin_available_predicate avail,
5627 enum ir_intrinsic_id id)
5628 {
5629 ir_variable *counter = in_var(glsl_type::atomic_uint_type, "counter");
5630 MAKE_INTRINSIC(glsl_type::uint_type, id, avail, 1, counter);
5631 return sig;
5632 }
5633
5634 ir_function_signature *
5635 builtin_builder::_atomic_counter_intrinsic1(builtin_available_predicate avail,
5636 enum ir_intrinsic_id id)
5637 {
5638 ir_variable *counter = in_var(glsl_type::atomic_uint_type, "counter");
5639 ir_variable *data = in_var(glsl_type::uint_type, "data");
5640 MAKE_INTRINSIC(glsl_type::uint_type, id, avail, 2, counter, data);
5641 return sig;
5642 }
5643
5644 ir_function_signature *
5645 builtin_builder::_atomic_counter_intrinsic2(builtin_available_predicate avail,
5646 enum ir_intrinsic_id id)
5647 {
5648 ir_variable *counter = in_var(glsl_type::atomic_uint_type, "counter");
5649 ir_variable *compare = in_var(glsl_type::uint_type, "compare");
5650 ir_variable *data = in_var(glsl_type::uint_type, "data");
5651 MAKE_INTRINSIC(glsl_type::uint_type, id, avail, 3, counter, compare, data);
5652 return sig;
5653 }
5654
5655 ir_function_signature *
5656 builtin_builder::_atomic_intrinsic2(builtin_available_predicate avail,
5657 const glsl_type *type,
5658 enum ir_intrinsic_id id)
5659 {
5660 ir_variable *atomic = in_var(type, "atomic");
5661 ir_variable *data = in_var(type, "data");
5662 MAKE_INTRINSIC(type, id, avail, 2, atomic, data);
5663 return sig;
5664 }
5665
5666 ir_function_signature *
5667 builtin_builder::_atomic_intrinsic3(builtin_available_predicate avail,
5668 const glsl_type *type,
5669 enum ir_intrinsic_id id)
5670 {
5671 ir_variable *atomic = in_var(type, "atomic");
5672 ir_variable *data1 = in_var(type, "data1");
5673 ir_variable *data2 = in_var(type, "data2");
5674 MAKE_INTRINSIC(type, id, avail, 3, atomic, data1, data2);
5675 return sig;
5676 }
5677
5678 ir_function_signature *
5679 builtin_builder::_atomic_counter_op(const char *intrinsic,
5680 builtin_available_predicate avail)
5681 {
5682 ir_variable *counter = in_var(glsl_type::atomic_uint_type, "atomic_counter");
5683 MAKE_SIG(glsl_type::uint_type, avail, 1, counter);
5684
5685 ir_variable *retval = body.make_temp(glsl_type::uint_type, "atomic_retval");
5686 body.emit(call(shader->symbols->get_function(intrinsic), retval,
5687 sig->parameters));
5688 body.emit(ret(retval));
5689 return sig;
5690 }
5691
5692 ir_function_signature *
5693 builtin_builder::_atomic_counter_op1(const char *intrinsic,
5694 builtin_available_predicate avail)
5695 {
5696 ir_variable *counter = in_var(glsl_type::atomic_uint_type, "atomic_counter");
5697 ir_variable *data = in_var(glsl_type::uint_type, "data");
5698 MAKE_SIG(glsl_type::uint_type, avail, 2, counter, data);
5699
5700 ir_variable *retval = body.make_temp(glsl_type::uint_type, "atomic_retval");
5701
5702 /* Instead of generating an __intrinsic_atomic_sub, generate an
5703 * __intrinsic_atomic_add with the data parameter negated.
5704 */
5705 if (strcmp("__intrinsic_atomic_sub", intrinsic) == 0) {
5706 ir_variable *const neg_data =
5707 body.make_temp(glsl_type::uint_type, "neg_data");
5708
5709 body.emit(assign(neg_data, neg(data)));
5710
5711 exec_list parameters;
5712
5713 parameters.push_tail(new(mem_ctx) ir_dereference_variable(counter));
5714 parameters.push_tail(new(mem_ctx) ir_dereference_variable(neg_data));
5715
5716 ir_function *const func =
5717 shader->symbols->get_function("__intrinsic_atomic_add");
5718 ir_instruction *const c = call(func, retval, parameters);
5719
5720 assert(c != NULL);
5721 assert(parameters.is_empty());
5722
5723 body.emit(c);
5724 } else {
5725 body.emit(call(shader->symbols->get_function(intrinsic), retval,
5726 sig->parameters));
5727 }
5728
5729 body.emit(ret(retval));
5730 return sig;
5731 }
5732
5733 ir_function_signature *
5734 builtin_builder::_atomic_counter_op2(const char *intrinsic,
5735 builtin_available_predicate avail)
5736 {
5737 ir_variable *counter = in_var(glsl_type::atomic_uint_type, "atomic_counter");
5738 ir_variable *compare = in_var(glsl_type::uint_type, "compare");
5739 ir_variable *data = in_var(glsl_type::uint_type, "data");
5740 MAKE_SIG(glsl_type::uint_type, avail, 3, counter, compare, data);
5741
5742 ir_variable *retval = body.make_temp(glsl_type::uint_type, "atomic_retval");
5743 body.emit(call(shader->symbols->get_function(intrinsic), retval,
5744 sig->parameters));
5745 body.emit(ret(retval));
5746 return sig;
5747 }
5748
5749 ir_function_signature *
5750 builtin_builder::_atomic_op2(const char *intrinsic,
5751 builtin_available_predicate avail,
5752 const glsl_type *type)
5753 {
5754 ir_variable *atomic = in_var(type, "atomic_var");
5755 ir_variable *data = in_var(type, "atomic_data");
5756 MAKE_SIG(type, avail, 2, atomic, data);
5757
5758 ir_variable *retval = body.make_temp(type, "atomic_retval");
5759 body.emit(call(shader->symbols->get_function(intrinsic), retval,
5760 sig->parameters));
5761 body.emit(ret(retval));
5762 return sig;
5763 }
5764
5765 ir_function_signature *
5766 builtin_builder::_atomic_op3(const char *intrinsic,
5767 builtin_available_predicate avail,
5768 const glsl_type *type)
5769 {
5770 ir_variable *atomic = in_var(type, "atomic_var");
5771 ir_variable *data1 = in_var(type, "atomic_data1");
5772 ir_variable *data2 = in_var(type, "atomic_data2");
5773 MAKE_SIG(type, avail, 3, atomic, data1, data2);
5774
5775 ir_variable *retval = body.make_temp(type, "atomic_retval");
5776 body.emit(call(shader->symbols->get_function(intrinsic), retval,
5777 sig->parameters));
5778 body.emit(ret(retval));
5779 return sig;
5780 }
5781
5782 ir_function_signature *
5783 builtin_builder::_min3(const glsl_type *type)
5784 {
5785 ir_variable *x = in_var(type, "x");
5786 ir_variable *y = in_var(type, "y");
5787 ir_variable *z = in_var(type, "z");
5788 MAKE_SIG(type, shader_trinary_minmax, 3, x, y, z);
5789
5790 ir_expression *min3 = min2(x, min2(y,z));
5791 body.emit(ret(min3));
5792
5793 return sig;
5794 }
5795
5796 ir_function_signature *
5797 builtin_builder::_max3(const glsl_type *type)
5798 {
5799 ir_variable *x = in_var(type, "x");
5800 ir_variable *y = in_var(type, "y");
5801 ir_variable *z = in_var(type, "z");
5802 MAKE_SIG(type, shader_trinary_minmax, 3, x, y, z);
5803
5804 ir_expression *max3 = max2(x, max2(y,z));
5805 body.emit(ret(max3));
5806
5807 return sig;
5808 }
5809
5810 ir_function_signature *
5811 builtin_builder::_mid3(const glsl_type *type)
5812 {
5813 ir_variable *x = in_var(type, "x");
5814 ir_variable *y = in_var(type, "y");
5815 ir_variable *z = in_var(type, "z");
5816 MAKE_SIG(type, shader_trinary_minmax, 3, x, y, z);
5817
5818 ir_expression *mid3 = max2(min2(x, y), max2(min2(x, z), min2(y, z)));
5819 body.emit(ret(mid3));
5820
5821 return sig;
5822 }
5823
5824 static builtin_available_predicate
5825 get_image_available_predicate(const glsl_type *type, unsigned flags)
5826 {
5827 if ((flags & IMAGE_FUNCTION_AVAIL_ATOMIC_EXCHANGE) &&
5828 type->sampled_type == GLSL_TYPE_FLOAT)
5829 return shader_image_atomic_exchange_float;
5830
5831 else if (flags & (IMAGE_FUNCTION_AVAIL_ATOMIC_EXCHANGE |
5832 IMAGE_FUNCTION_AVAIL_ATOMIC))
5833 return shader_image_atomic;
5834
5835 else
5836 return shader_image_load_store;
5837 }
5838
5839 ir_function_signature *
5840 builtin_builder::_image_prototype(const glsl_type *image_type,
5841 unsigned num_arguments,
5842 unsigned flags)
5843 {
5844 const glsl_type *data_type = glsl_type::get_instance(
5845 image_type->sampled_type,
5846 (flags & IMAGE_FUNCTION_HAS_VECTOR_DATA_TYPE ? 4 : 1),
5847 1);
5848 const glsl_type *ret_type = (flags & IMAGE_FUNCTION_RETURNS_VOID ?
5849 glsl_type::void_type : data_type);
5850
5851 /* Addressing arguments that are always present. */
5852 ir_variable *image = in_var(image_type, "image");
5853 ir_variable *coord = in_var(
5854 glsl_type::ivec(image_type->coordinate_components()), "coord");
5855
5856 ir_function_signature *sig = new_sig(
5857 ret_type, get_image_available_predicate(image_type, flags),
5858 2, image, coord);
5859
5860 /* Sample index for multisample images. */
5861 if (image_type->sampler_dimensionality == GLSL_SAMPLER_DIM_MS)
5862 sig->parameters.push_tail(in_var(glsl_type::int_type, "sample"));
5863
5864 /* Data arguments. */
5865 for (unsigned i = 0; i < num_arguments; ++i) {
5866 char *arg_name = ralloc_asprintf(NULL, "arg%d", i);
5867 sig->parameters.push_tail(in_var(data_type, arg_name));
5868 ralloc_free(arg_name);
5869 }
5870
5871 /* Set the maximal set of qualifiers allowed for this image
5872 * built-in. Function calls with arguments having fewer
5873 * qualifiers than present in the prototype are allowed by the
5874 * spec, but not with more, i.e. this will make the compiler
5875 * accept everything that needs to be accepted, and reject cases
5876 * like loads from write-only or stores to read-only images.
5877 */
5878 image->data.image_read_only = (flags & IMAGE_FUNCTION_READ_ONLY) != 0;
5879 image->data.image_write_only = (flags & IMAGE_FUNCTION_WRITE_ONLY) != 0;
5880 image->data.image_coherent = true;
5881 image->data.image_volatile = true;
5882 image->data.image_restrict = true;
5883
5884 return sig;
5885 }
5886
5887 ir_function_signature *
5888 builtin_builder::_image_size_prototype(const glsl_type *image_type,
5889 unsigned /* num_arguments */,
5890 unsigned /* flags */)
5891 {
5892 const glsl_type *ret_type;
5893 unsigned num_components = image_type->coordinate_components();
5894
5895 /* From the ARB_shader_image_size extension:
5896 * "Cube images return the dimensions of one face."
5897 */
5898 if (image_type->sampler_dimensionality == GLSL_SAMPLER_DIM_CUBE &&
5899 !image_type->sampler_array) {
5900 num_components = 2;
5901 }
5902
5903 /* FIXME: Add the highp precision qualifier for GLES 3.10 when it is
5904 * supported by mesa.
5905 */
5906 ret_type = glsl_type::get_instance(GLSL_TYPE_INT, num_components, 1);
5907
5908 ir_variable *image = in_var(image_type, "image");
5909 ir_function_signature *sig = new_sig(ret_type, shader_image_size, 1, image);
5910
5911 /* Set the maximal set of qualifiers allowed for this image
5912 * built-in. Function calls with arguments having fewer
5913 * qualifiers than present in the prototype are allowed by the
5914 * spec, but not with more, i.e. this will make the compiler
5915 * accept everything that needs to be accepted, and reject cases
5916 * like loads from write-only or stores to read-only images.
5917 */
5918 image->data.image_read_only = true;
5919 image->data.image_write_only = true;
5920 image->data.image_coherent = true;
5921 image->data.image_volatile = true;
5922 image->data.image_restrict = true;
5923
5924 return sig;
5925 }
5926
5927 ir_function_signature *
5928 builtin_builder::_image_samples_prototype(const glsl_type *image_type,
5929 unsigned /* num_arguments */,
5930 unsigned /* flags */)
5931 {
5932 ir_variable *image = in_var(image_type, "image");
5933 ir_function_signature *sig =
5934 new_sig(glsl_type::int_type, shader_samples, 1, image);
5935
5936 /* Set the maximal set of qualifiers allowed for this image
5937 * built-in. Function calls with arguments having fewer
5938 * qualifiers than present in the prototype are allowed by the
5939 * spec, but not with more, i.e. this will make the compiler
5940 * accept everything that needs to be accepted, and reject cases
5941 * like loads from write-only or stores to read-only images.
5942 */
5943 image->data.image_read_only = true;
5944 image->data.image_write_only = true;
5945 image->data.image_coherent = true;
5946 image->data.image_volatile = true;
5947 image->data.image_restrict = true;
5948
5949 return sig;
5950 }
5951
5952 ir_function_signature *
5953 builtin_builder::_image(image_prototype_ctr prototype,
5954 const glsl_type *image_type,
5955 const char *intrinsic_name,
5956 unsigned num_arguments,
5957 unsigned flags,
5958 enum ir_intrinsic_id id)
5959 {
5960 ir_function_signature *sig = (this->*prototype)(image_type,
5961 num_arguments, flags);
5962
5963 if (flags & IMAGE_FUNCTION_EMIT_STUB) {
5964 ir_factory body(&sig->body, mem_ctx);
5965 ir_function *f = shader->symbols->get_function(intrinsic_name);
5966
5967 if (flags & IMAGE_FUNCTION_RETURNS_VOID) {
5968 body.emit(call(f, NULL, sig->parameters));
5969 } else {
5970 ir_variable *ret_val =
5971 body.make_temp(sig->return_type, "_ret_val");
5972 body.emit(call(f, ret_val, sig->parameters));
5973 body.emit(ret(ret_val));
5974 }
5975
5976 sig->is_defined = true;
5977
5978 } else {
5979 sig->intrinsic_id = id;
5980 }
5981
5982 return sig;
5983 }
5984
5985 ir_function_signature *
5986 builtin_builder::_memory_barrier_intrinsic(builtin_available_predicate avail,
5987 enum ir_intrinsic_id id)
5988 {
5989 MAKE_INTRINSIC(glsl_type::void_type, id, avail, 0);
5990 return sig;
5991 }
5992
5993 ir_function_signature *
5994 builtin_builder::_memory_barrier(const char *intrinsic_name,
5995 builtin_available_predicate avail)
5996 {
5997 MAKE_SIG(glsl_type::void_type, avail, 0);
5998 body.emit(call(shader->symbols->get_function(intrinsic_name),
5999 NULL, sig->parameters));
6000 return sig;
6001 }
6002
6003 ir_function_signature *
6004 builtin_builder::_ballot()
6005 {
6006 ir_variable *value = in_var(glsl_type::bool_type, "value");
6007
6008 MAKE_SIG(glsl_type::uint64_t_type, shader_ballot, 1, value);
6009 body.emit(ret(expr(ir_unop_ballot, value)));
6010 return sig;
6011 }
6012
6013 ir_function_signature *
6014 builtin_builder::_read_first_invocation(const glsl_type *type)
6015 {
6016 ir_variable *value = in_var(type, "value");
6017
6018 MAKE_SIG(type, shader_ballot, 1, value);
6019 body.emit(ret(expr(ir_unop_read_first_invocation, value)));
6020 return sig;
6021 }
6022
6023 ir_function_signature *
6024 builtin_builder::_read_invocation(const glsl_type *type)
6025 {
6026 ir_variable *value = in_var(type, "value");
6027 ir_variable *invocation = in_var(glsl_type::uint_type, "invocation");
6028
6029 MAKE_SIG(type, shader_ballot, 2, value, invocation);
6030 body.emit(ret(expr(ir_binop_read_invocation, value, invocation)));
6031 return sig;
6032 }
6033
6034 ir_function_signature *
6035 builtin_builder::_shader_clock_intrinsic(builtin_available_predicate avail,
6036 const glsl_type *type)
6037 {
6038 MAKE_INTRINSIC(type, ir_intrinsic_shader_clock, avail, 0);
6039 return sig;
6040 }
6041
6042 ir_function_signature *
6043 builtin_builder::_shader_clock(builtin_available_predicate avail,
6044 const glsl_type *type)
6045 {
6046 MAKE_SIG(type, avail, 0);
6047
6048 ir_variable *retval = body.make_temp(glsl_type::uvec2_type, "clock_retval");
6049
6050 body.emit(call(shader->symbols->get_function("__intrinsic_shader_clock"),
6051 retval, sig->parameters));
6052
6053 if (type == glsl_type::uint64_t_type) {
6054 body.emit(ret(expr(ir_unop_pack_uint_2x32, retval)));
6055 } else {
6056 body.emit(ret(retval));
6057 }
6058
6059 return sig;
6060 }
6061
6062 ir_function_signature *
6063 builtin_builder::_vote(enum ir_expression_operation opcode)
6064 {
6065 ir_variable *value = in_var(glsl_type::bool_type, "value");
6066
6067 MAKE_SIG(glsl_type::bool_type, vote, 1, value);
6068 body.emit(ret(expr(opcode, value)));
6069 return sig;
6070 }
6071
6072 /** @} */
6073
6074 /******************************************************************************/
6075
6076 /* The singleton instance of builtin_builder. */
6077 static builtin_builder builtins;
6078 static mtx_t builtins_lock = _MTX_INITIALIZER_NP;
6079
6080 /**
6081 * External API (exposing the built-in module to the rest of the compiler):
6082 * @{
6083 */
6084 void
6085 _mesa_glsl_initialize_builtin_functions()
6086 {
6087 mtx_lock(&builtins_lock);
6088 builtins.initialize();
6089 mtx_unlock(&builtins_lock);
6090 }
6091
6092 void
6093 _mesa_glsl_release_builtin_functions()
6094 {
6095 mtx_lock(&builtins_lock);
6096 builtins.release();
6097 mtx_unlock(&builtins_lock);
6098 }
6099
6100 ir_function_signature *
6101 _mesa_glsl_find_builtin_function(_mesa_glsl_parse_state *state,
6102 const char *name, exec_list *actual_parameters)
6103 {
6104 ir_function_signature *s;
6105 mtx_lock(&builtins_lock);
6106 s = builtins.find(state, name, actual_parameters);
6107 mtx_unlock(&builtins_lock);
6108
6109 if (s == NULL)
6110 return NULL;
6111
6112 struct hash_table *ht =
6113 _mesa_hash_table_create(NULL, _mesa_hash_pointer, _mesa_key_pointer_equal);
6114 void *mem_ctx = state;
6115 ir_function *f = s->function()->clone(mem_ctx, ht);
6116 _mesa_hash_table_destroy(ht, NULL);
6117
6118 return f->matching_signature(state, actual_parameters, true);
6119 }
6120
6121 bool
6122 _mesa_glsl_has_builtin_function(const char *name)
6123 {
6124 ir_function *f;
6125 mtx_lock(&builtins_lock);
6126 f = builtins.shader->symbols->get_function(name);
6127 mtx_unlock(&builtins_lock);
6128
6129 return f != NULL;
6130 }
6131
6132 gl_shader *
6133 _mesa_glsl_get_builtin_function_shader()
6134 {
6135 return builtins.shader;
6136 }
6137
6138
6139 /**
6140 * Get the function signature for main from a shader
6141 */
6142 ir_function_signature *
6143 _mesa_get_main_function_signature(glsl_symbol_table *symbols)
6144 {
6145 ir_function *const f = symbols->get_function("main");
6146 if (f != NULL) {
6147 exec_list void_parameters;
6148
6149 /* Look for the 'void main()' signature and ensure that it's defined.
6150 * This keeps the linker from accidentally pick a shader that just
6151 * contains a prototype for main.
6152 *
6153 * We don't have to check for multiple definitions of main (in multiple
6154 * shaders) because that would have already been caught above.
6155 */
6156 ir_function_signature *sig =
6157 f->matching_signature(NULL, &void_parameters, false);
6158 if ((sig != NULL) && sig->is_defined) {
6159 return sig;
6160 }
6161 }
6162
6163 return NULL;
6164 }
6165
6166 /** @} */