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