src/compiler/glsl/ir.h

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright © 2010 Intel Corporation
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #ifndef IR_H
  26 #define IR_H
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30
  31 #include "util/ralloc.h"
  32 #include "compiler/glsl_types.h"
  33 #include "list.h"
  34 #include "ir_visitor.h"
  35 #include "ir_hierarchical_visitor.h"
  36
  37 #ifdef __cplusplus
  38
  39 /**
  40  * \defgroup IR Intermediate representation nodes
  41  *
  42  * @{
  43  */
  44
  45 /**
  46  * Class tags
  47  *
  48  * Each concrete class derived from \c ir_instruction has a value in this
  49  * enumerant.  The value for the type is stored in \c ir_instruction::ir_type
  50  * by the constructor.  While using type tags is not very C++, it is extremely
  51  * convenient.  For example, during debugging you can simply inspect
  52  * \c ir_instruction::ir_type to find out the actual type of the object.
  53  *
  54  * In addition, it is possible to use a switch-statement based on \c
  55  * \c ir_instruction::ir_type to select different behavior for different object
  56  * types.  For functions that have only slight differences for several object
  57  * types, this allows writing very straightforward, readable code.
  58  */
  59 enum ir_node_type {
  60    ir_type_dereference_array,
  61    ir_type_dereference_record,
  62    ir_type_dereference_variable,
  63    ir_type_constant,
  64    ir_type_expression,
  65    ir_type_swizzle,
  66    ir_type_texture,
  67    ir_type_variable,
  68    ir_type_assignment,
  69    ir_type_call,
  70    ir_type_function,
  71    ir_type_function_signature,
  72    ir_type_if,
  73    ir_type_loop,
  74    ir_type_loop_jump,
  75    ir_type_return,
  76    ir_type_discard,
  77    ir_type_emit_vertex,
  78    ir_type_end_primitive,
  79    ir_type_barrier,
  80    ir_type_max, /**< maximum ir_type enum number, for validation */
  81    ir_type_unset = ir_type_max
  82 };
  83
  84
  85 /**
  86  * Base class of all IR instructions
  87  */
  88 class ir_instruction : public exec_node {
  89 public:
  90    enum ir_node_type ir_type;
  91
  92    /**
  93     * GCC 4.7+ and clang warn when deleting an ir_instruction unless
  94     * there's a virtual destructor present.  Because we almost
  95     * universally use ralloc for our memory management of
  96     * ir_instructions, the destructor doesn't need to do any work.
  97     */
  98    virtual ~ir_instruction()
  99    {
 100    }
 101
 102    /** ir_print_visitor helper for debugging. */
 103    void print(void) const;
 104    void fprint(FILE *f) const;
 105
 106    virtual void accept(ir_visitor *) = 0;
 107    virtual ir_visitor_status accept(ir_hierarchical_visitor *) = 0;
 108    virtual ir_instruction *clone(void *mem_ctx,
 109                                  struct hash_table *ht) const = 0;
 110
 111    bool is_rvalue() const
 112    {
 113       return ir_type == ir_type_dereference_array ||
 114              ir_type == ir_type_dereference_record ||
 115              ir_type == ir_type_dereference_variable ||
 116              ir_type == ir_type_constant ||
 117              ir_type == ir_type_expression ||
 118              ir_type == ir_type_swizzle ||
 119              ir_type == ir_type_texture;
 120    }
 121
 122    bool is_dereference() const
 123    {
 124       return ir_type == ir_type_dereference_array ||
 125              ir_type == ir_type_dereference_record ||
 126              ir_type == ir_type_dereference_variable;
 127    }
 128
 129    bool is_jump() const
 130    {
 131       return ir_type == ir_type_loop_jump ||
 132              ir_type == ir_type_return ||
 133              ir_type == ir_type_discard;
 134    }
 135
 136    /**
 137     * \name IR instruction downcast functions
 138     *
 139     * These functions either cast the object to a derived class or return
 140     * \c NULL if the object's type does not match the specified derived class.
 141     * Additional downcast functions will be added as needed.
 142     */
 143    /*@{*/
 144    #define AS_BASE(TYPE)                                \
 145    class ir_##TYPE *as_##TYPE()                         \
 146    {                                                    \
 147       assume(this != NULL);                             \
 148       return is_##TYPE() ? (ir_##TYPE *) this : NULL;   \
 149    }                                                    \
 150    const class ir_##TYPE *as_##TYPE() const             \
 151    {                                                    \
 152       assume(this != NULL);                             \
 153       return is_##TYPE() ? (ir_##TYPE *) this : NULL;   \
 154    }
 155
 156    AS_BASE(rvalue)
 157    AS_BASE(dereference)
 158    AS_BASE(jump)
 159    #undef AS_BASE
 160
 161    #define AS_CHILD(TYPE) \
 162    class ir_##TYPE * as_##TYPE() \
 163    { \
 164       assume(this != NULL);                                         \
 165       return ir_type == ir_type_##TYPE ? (ir_##TYPE *) this : NULL; \
 166    }                                                                      \
 167    const class ir_##TYPE * as_##TYPE() const                              \
 168    {                                                                      \
 169       assume(this != NULL);                                               \
 170       return ir_type == ir_type_##TYPE ? (const ir_##TYPE *) this : NULL; \
 171    }
 172    AS_CHILD(variable)
 173    AS_CHILD(function)
 174    AS_CHILD(dereference_array)
 175    AS_CHILD(dereference_variable)
 176    AS_CHILD(dereference_record)
 177    AS_CHILD(expression)
 178    AS_CHILD(loop)
 179    AS_CHILD(assignment)
 180    AS_CHILD(call)
 181    AS_CHILD(return)
 182    AS_CHILD(if)
 183    AS_CHILD(swizzle)
 184    AS_CHILD(texture)
 185    AS_CHILD(constant)
 186    AS_CHILD(discard)
 187    #undef AS_CHILD
 188    /*@}*/
 189
 190    /**
 191     * IR equality method: Return true if the referenced instruction would
 192     * return the same value as this one.
 193     *
 194     * This intended to be used for CSE and algebraic optimizations, on rvalues
 195     * in particular.  No support for other instruction types (assignments,
 196     * jumps, calls, etc.) is planned.
 197     */
 198    virtual bool equals(const ir_instruction *ir,
 199                        enum ir_node_type ignore = ir_type_unset) const;
 200
 201 protected:
 202    ir_instruction(enum ir_node_type t)
 203       : ir_type(t)
 204    {
 205    }
 206
 207 private:
 208    ir_instruction()
 209    {
 210       assert(!"Should not get here.");
 211    }
 212 };
 213
 214
 215 /**
 216  * The base class for all "values"/expression trees.
 217  */
 218 class ir_rvalue : public ir_instruction {
 219 public:
 220    const struct glsl_type *type;
 221
 222    virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const;
 223
 224    virtual void accept(ir_visitor *v)
 225    {
 226       v->visit(this);
 227    }
 228
 229    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 230
 231    virtual ir_constant *constant_expression_value(void *mem_ctx,
 232                                                   struct hash_table *variable_context = NULL);
 233
 234    ir_rvalue *as_rvalue_to_saturate();
 235
 236    virtual bool is_lvalue(const struct _mesa_glsl_parse_state *state = NULL) const
 237    {
 238       return false;
 239    }
 240
 241    /**
 242     * Get the variable that is ultimately referenced by an r-value
 243     */
 244    virtual ir_variable *variable_referenced() const
 245    {
 246       return NULL;
 247    }
 248
 249
 250    /**
 251     * If an r-value is a reference to a whole variable, get that variable
 252     *
 253     * \return
 254     * Pointer to a variable that is completely dereferenced by the r-value.  If
 255     * the r-value is not a dereference or the dereference does not access the
 256     * entire variable (i.e., it's just one array element, struct field), \c NULL
 257     * is returned.
 258     */
 259    virtual ir_variable *whole_variable_referenced()
 260    {
 261       return NULL;
 262    }
 263
 264    /**
 265     * Determine if an r-value has the value zero
 266     *
 267     * The base implementation of this function always returns \c false.  The
 268     * \c ir_constant class over-rides this function to return \c true \b only
 269     * for vector and scalar types that have all elements set to the value
 270     * zero (or \c false for booleans).
 271     *
 272     * \sa ir_constant::has_value, ir_rvalue::is_one, ir_rvalue::is_negative_one
 273     */
 274    virtual bool is_zero() const;
 275
 276    /**
 277     * Determine if an r-value has the value one
 278     *
 279     * The base implementation of this function always returns \c false.  The
 280     * \c ir_constant class over-rides this function to return \c true \b only
 281     * for vector and scalar types that have all elements set to the value
 282     * one (or \c true for booleans).
 283     *
 284     * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_negative_one
 285     */
 286    virtual bool is_one() const;
 287
 288    /**
 289     * Determine if an r-value has the value negative one
 290     *
 291     * The base implementation of this function always returns \c false.  The
 292     * \c ir_constant class over-rides this function to return \c true \b only
 293     * for vector and scalar types that have all elements set to the value
 294     * negative one.  For boolean types, the result is always \c false.
 295     *
 296     * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_one
 297     */
 298    virtual bool is_negative_one() const;
 299
 300    /**
 301     * Determine if an r-value is an unsigned integer constant which can be
 302     * stored in 16 bits.
 303     *
 304     * \sa ir_constant::is_uint16_constant.
 305     */
 306    virtual bool is_uint16_constant() const { return false; }
 307
 308    /**
 309     * Return a generic value of error_type.
 310     *
 311     * Allocation will be performed with 'mem_ctx' as ralloc owner.
 312     */
 313    static ir_rvalue *error_value(void *mem_ctx);
 314
 315 protected:
 316    ir_rvalue(enum ir_node_type t);
 317 };
 318
 319
 320 /**
 321  * Variable storage classes
 322  */
 323 enum ir_variable_mode {
 324    ir_var_auto = 0,             /**< Function local variables and globals. */
 325    ir_var_uniform,              /**< Variable declared as a uniform. */
 326    ir_var_shader_storage,       /**< Variable declared as an ssbo. */
 327    ir_var_shader_shared,        /**< Variable declared as shared. */
 328    ir_var_shader_in,
 329    ir_var_shader_out,
 330    ir_var_function_in,
 331    ir_var_function_out,
 332    ir_var_function_inout,
 333    ir_var_const_in,             /**< "in" param that must be a constant expression */
 334    ir_var_system_value,         /**< Ex: front-face, instance-id, etc. */
 335    ir_var_temporary,            /**< Temporary variable generated during compilation. */
 336    ir_var_mode_count            /**< Number of variable modes */
 337 };
 338
 339 /**
 340  * Enum keeping track of how a variable was declared.  For error checking of
 341  * the gl_PerVertex redeclaration rules.
 342  */
 343 enum ir_var_declaration_type {
 344    /**
 345     * Normal declaration (for most variables, this means an explicit
 346     * declaration.  Exception: temporaries are always implicitly declared, but
 347     * they still use ir_var_declared_normally).
 348     *
 349     * Note: an ir_variable that represents a named interface block uses
 350     * ir_var_declared_normally.
 351     */
 352    ir_var_declared_normally = 0,
 353
 354    /**
 355     * Variable was explicitly declared (or re-declared) in an unnamed
 356     * interface block.
 357     */
 358    ir_var_declared_in_block,
 359
 360    /**
 361     * Variable is an implicitly declared built-in that has not been explicitly
 362     * re-declared by the shader.
 363     */
 364    ir_var_declared_implicitly,
 365
 366    /**
 367     * Variable is implicitly generated by the compiler and should not be
 368     * visible via the API.
 369     */
 370    ir_var_hidden,
 371 };
 372
 373 /**
 374  * \brief Layout qualifiers for gl_FragDepth.
 375  *
 376  * The AMD/ARB_conservative_depth extensions allow gl_FragDepth to be redeclared
 377  * with a layout qualifier.
 378  */
 379 enum ir_depth_layout {
 380     ir_depth_layout_none, /**< No depth layout is specified. */
 381     ir_depth_layout_any,
 382     ir_depth_layout_greater,
 383     ir_depth_layout_less,
 384     ir_depth_layout_unchanged
 385 };
 386
 387 /**
 388  * \brief Convert depth layout qualifier to string.
 389  */
 390 const char*
 391 depth_layout_string(ir_depth_layout layout);
 392
 393 /**
 394  * Description of built-in state associated with a uniform
 395  *
 396  * \sa ir_variable::state_slots
 397  */
 398 struct ir_state_slot {
 399    gl_state_index16 tokens[STATE_LENGTH];
 400    int swizzle;
 401 };
 402
 403
 404 /**
 405  * Get the string value for an interpolation qualifier
 406  *
 407  * \return The string that would be used in a shader to specify \c
 408  * mode will be returned.
 409  *
 410  * This function is used to generate error messages of the form "shader
 411  * uses %s interpolation qualifier", so in the case where there is no
 412  * interpolation qualifier, it returns "no".
 413  *
 414  * This function should only be used on a shader input or output variable.
 415  */
 416 const char *interpolation_string(unsigned interpolation);
 417
 418
 419 class ir_variable : public ir_instruction {
 420 public:
 421    ir_variable(const struct glsl_type *, const char *, ir_variable_mode);
 422
 423    virtual ir_variable *clone(void *mem_ctx, struct hash_table *ht) const;
 424
 425    virtual void accept(ir_visitor *v)
 426    {
 427       v->visit(this);
 428    }
 429
 430    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 431
 432
 433    /**
 434     * Determine whether or not a variable is part of a uniform or
 435     * shader storage block.
 436     */
 437    inline bool is_in_buffer_block() const
 438    {
 439       return (this->data.mode == ir_var_uniform ||
 440               this->data.mode == ir_var_shader_storage) &&
 441              this->interface_type != NULL;
 442    }
 443
 444    /**
 445     * Determine whether or not a variable is part of a shader storage block.
 446     */
 447    inline bool is_in_shader_storage_block() const
 448    {
 449       return this->data.mode == ir_var_shader_storage &&
 450              this->interface_type != NULL;
 451    }
 452
 453    /**
 454     * Determine whether or not a variable is the declaration of an interface
 455     * block
 456     *
 457     * For the first declaration below, there will be an \c ir_variable named
 458     * "instance" whose type and whose instance_type will be the same
 459     * \c glsl_type.  For the second declaration, there will be an \c ir_variable
 460     * named "f" whose type is float and whose instance_type is B2.
 461     *
 462     * "instance" is an interface instance variable, but "f" is not.
 463     *
 464     * uniform B1 {
 465     *     float f;
 466     * } instance;
 467     *
 468     * uniform B2 {
 469     *     float f;
 470     * };
 471     */
 472    inline bool is_interface_instance() const
 473    {
 474       return this->type->without_array() == this->interface_type;
 475    }
 476
 477    /**
 478     * Return whether this variable contains a bindless sampler/image.
 479     */
 480    inline bool contains_bindless() const
 481    {
 482       if (!this->type->contains_sampler() && !this->type->contains_image())
 483          return false;
 484
 485       return this->data.bindless || this->data.mode != ir_var_uniform;
 486    }
 487
 488    /**
 489     * Set this->interface_type on a newly created variable.
 490     */
 491    void init_interface_type(const struct glsl_type *type)
 492    {
 493       assert(this->interface_type == NULL);
 494       this->interface_type = type;
 495       if (this->is_interface_instance()) {
 496          this->u.max_ifc_array_access =
 497             ralloc_array(this, int, type->length);
 498          for (unsigned i = 0; i < type->length; i++) {
 499             this->u.max_ifc_array_access[i] = -1;
 500          }
 501       }
 502    }
 503
 504    /**
 505     * Change this->interface_type on a variable that previously had a
 506     * different, but compatible, interface_type.  This is used during linking
 507     * to set the size of arrays in interface blocks.
 508     */
 509    void change_interface_type(const struct glsl_type *type)
 510    {
 511       if (this->u.max_ifc_array_access != NULL) {
 512          /* max_ifc_array_access has already been allocated, so make sure the
 513           * new interface has the same number of fields as the old one.
 514           */
 515          assert(this->interface_type->length == type->length);
 516       }
 517       this->interface_type = type;
 518    }
 519
 520    /**
 521     * Change this->interface_type on a variable that previously had a
 522     * different, and incompatible, interface_type. This is used during
 523     * compilation to handle redeclaration of the built-in gl_PerVertex
 524     * interface block.
 525     */
 526    void reinit_interface_type(const struct glsl_type *type)
 527    {
 528       if (this->u.max_ifc_array_access != NULL) {
 529 #ifndef NDEBUG
 530          /* Redeclaring gl_PerVertex is only allowed if none of the built-ins
 531           * it defines have been accessed yet; so it's safe to throw away the
 532           * old max_ifc_array_access pointer, since all of its values are
 533           * zero.
 534           */
 535          for (unsigned i = 0; i < this->interface_type->length; i++)
 536             assert(this->u.max_ifc_array_access[i] == -1);
 537 #endif
 538          ralloc_free(this->u.max_ifc_array_access);
 539          this->u.max_ifc_array_access = NULL;
 540       }
 541       this->interface_type = NULL;
 542       init_interface_type(type);
 543    }
 544
 545    const glsl_type *get_interface_type() const
 546    {
 547       return this->interface_type;
 548    }
 549
 550    enum glsl_interface_packing get_interface_type_packing() const
 551    {
 552      return this->interface_type->get_interface_packing();
 553    }
 554    /**
 555     * Get the max_ifc_array_access pointer
 556     *
 557     * A "set" function is not needed because the array is dynmically allocated
 558     * as necessary.
 559     */
 560    inline int *get_max_ifc_array_access()
 561    {
 562       assert(this->data._num_state_slots == 0);
 563       return this->u.max_ifc_array_access;
 564    }
 565
 566    inline unsigned get_num_state_slots() const
 567    {
 568       assert(!this->is_interface_instance()
 569              || this->data._num_state_slots == 0);
 570       return this->data._num_state_slots;
 571    }
 572
 573    inline void set_num_state_slots(unsigned n)
 574    {
 575       assert(!this->is_interface_instance()
 576              || n == 0);
 577       this->data._num_state_slots = n;
 578    }
 579
 580    inline ir_state_slot *get_state_slots()
 581    {
 582       return this->is_interface_instance() ? NULL : this->u.state_slots;
 583    }
 584
 585    inline const ir_state_slot *get_state_slots() const
 586    {
 587       return this->is_interface_instance() ? NULL : this->u.state_slots;
 588    }
 589
 590    inline ir_state_slot *allocate_state_slots(unsigned n)
 591    {
 592       assert(!this->is_interface_instance());
 593
 594       this->u.state_slots = ralloc_array(this, ir_state_slot, n);
 595       this->data._num_state_slots = 0;
 596
 597       if (this->u.state_slots != NULL)
 598          this->data._num_state_slots = n;
 599
 600       return this->u.state_slots;
 601    }
 602
 603    inline bool is_interpolation_flat() const
 604    {
 605       return this->data.interpolation == INTERP_MODE_FLAT ||
 606              this->type->contains_integer() ||
 607              this->type->contains_double();
 608    }
 609
 610    inline bool is_name_ralloced() const
 611    {
 612       return this->name != ir_variable::tmp_name &&
 613              this->name != this->name_storage;
 614    }
 615
 616    /**
 617     * Enable emitting extension warnings for this variable
 618     */
 619    void enable_extension_warning(const char *extension);
 620
 621    /**
 622     * Get the extension warning string for this variable
 623     *
 624     * If warnings are not enabled, \c NULL is returned.
 625     */
 626    const char *get_extension_warning() const;
 627
 628    /**
 629     * Declared type of the variable
 630     */
 631    const struct glsl_type *type;
 632
 633    /**
 634     * Declared name of the variable
 635     */
 636    const char *name;
 637
 638 private:
 639    /**
 640     * If the name length fits into name_storage, it's used, otherwise
 641     * the name is ralloc'd. shader-db mining showed that 70% of variables
 642     * fit here. This is a win over ralloc where only ralloc_header has
 643     * 20 bytes on 64-bit (28 bytes with DEBUG), and we can also skip malloc.
 644     */
 645    char name_storage[16];
 646
 647 public:
 648    struct ir_variable_data {
 649
 650       /**
 651        * Is the variable read-only?
 652        *
 653        * This is set for variables declared as \c const, shader inputs,
 654        * and uniforms.
 655        */
 656       unsigned read_only:1;
 657       unsigned centroid:1;
 658       unsigned sample:1;
 659       unsigned patch:1;
 660       unsigned invariant:1;
 661       unsigned precise:1;
 662
 663       /**
 664        * Has this variable been used for reading or writing?
 665        *
 666        * Several GLSL semantic checks require knowledge of whether or not a
 667        * variable has been used.  For example, it is an error to redeclare a
 668        * variable as invariant after it has been used.
 669        *
 670        * This is only maintained in the ast_to_hir.cpp path, not in
 671        * Mesa's fixed function or ARB program paths.
 672        */
 673       unsigned used:1;
 674
 675       /**
 676        * Has this variable been statically assigned?
 677        *
 678        * This answers whether the variable was assigned in any path of
 679        * the shader during ast_to_hir.  This doesn't answer whether it is
 680        * still written after dead code removal, nor is it maintained in
 681        * non-ast_to_hir.cpp (GLSL parsing) paths.
 682        */
 683       unsigned assigned:1;
 684
 685       /**
 686        * When separate shader programs are enabled, only input/outputs between
 687        * the stages of a multi-stage separate program can be safely removed
 688        * from the shader interface. Other input/outputs must remains active.
 689        */
 690       unsigned always_active_io:1;
 691
 692       /**
 693        * Enum indicating how the variable was declared.  See
 694        * ir_var_declaration_type.
 695        *
 696        * This is used to detect certain kinds of illegal variable redeclarations.
 697        */
 698       unsigned how_declared:2;
 699
 700       /**
 701        * Storage class of the variable.
 702        *
 703        * \sa ir_variable_mode
 704        */
 705       unsigned mode:4;
 706
 707       /**
 708        * Interpolation mode for shader inputs / outputs
 709        *
 710        * \sa glsl_interp_mode
 711        */
 712       unsigned interpolation:2;
 713
 714       /**
 715        * \name ARB_fragment_coord_conventions
 716        * @{
 717        */
 718       unsigned origin_upper_left:1;
 719       unsigned pixel_center_integer:1;
 720       /*@}*/
 721
 722       /**
 723        * Was the location explicitly set in the shader?
 724        *
 725        * If the location is explicitly set in the shader, it \b cannot be changed
 726        * by the linker or by the API (e.g., calls to \c glBindAttribLocation have
 727        * no effect).
 728        */
 729       unsigned explicit_location:1;
 730       unsigned explicit_index:1;
 731
 732       /**
 733        * Was an initial binding explicitly set in the shader?
 734        *
 735        * If so, constant_value contains an integer ir_constant representing the
 736        * initial binding point.
 737        */
 738       unsigned explicit_binding:1;
 739
 740       /**
 741        * Was an initial component explicitly set in the shader?
 742        */
 743       unsigned explicit_component:1;
 744
 745       /**
 746        * Does this variable have an initializer?
 747        *
 748        * This is used by the linker to cross-validiate initializers of global
 749        * variables.
 750        */
 751       unsigned has_initializer:1;
 752
 753       /**
 754        * Is this variable a generic output or input that has not yet been matched
 755        * up to a variable in another stage of the pipeline?
 756        *
 757        * This is used by the linker as scratch storage while assigning locations
 758        * to generic inputs and outputs.
 759        */
 760       unsigned is_unmatched_generic_inout:1;
 761
 762       /**
 763        * Is this varying used only by transform feedback?
 764        *
 765        * This is used by the linker to decide if its safe to pack the varying.
 766        */
 767       unsigned is_xfb_only:1;
 768
 769       /**
 770        * Was a transfor feedback buffer set in the shader?
 771        */
 772       unsigned explicit_xfb_buffer:1;
 773
 774       /**
 775        * Was a transfor feedback offset set in the shader?
 776        */
 777       unsigned explicit_xfb_offset:1;
 778
 779       /**
 780        * Was a transfor feedback stride set in the shader?
 781        */
 782       unsigned explicit_xfb_stride:1;
 783
 784       /**
 785        * If non-zero, then this variable may be packed along with other variables
 786        * into a single varying slot, so this offset should be applied when
 787        * accessing components.  For example, an offset of 1 means that the x
 788        * component of this variable is actually stored in component y of the
 789        * location specified by \c location.
 790        */
 791       unsigned location_frac:2;
 792
 793       /**
 794        * Layout of the matrix.  Uses glsl_matrix_layout values.
 795        */
 796       unsigned matrix_layout:2;
 797
 798       /**
 799        * Non-zero if this variable was created by lowering a named interface
 800        * block.
 801        */
 802       unsigned from_named_ifc_block:1;
 803
 804       /**
 805        * Non-zero if the variable must be a shader input. This is useful for
 806        * constraints on function parameters.
 807        */
 808       unsigned must_be_shader_input:1;
 809
 810       /**
 811        * Output index for dual source blending.
 812        *
 813        * \note
 814        * The GLSL spec only allows the values 0 or 1 for the index in \b dual
 815        * source blending.
 816        */
 817       unsigned index:1;
 818
 819       /**
 820        * Precision qualifier.
 821        *
 822        * In desktop GLSL we do not care about precision qualifiers at all, in
 823        * fact, the spec says that precision qualifiers are ignored.
 824        *
 825        * To make things easy, we make it so that this field is always
 826        * GLSL_PRECISION_NONE on desktop shaders. This way all the variables
 827        * have the same precision value and the checks we add in the compiler
 828        * for this field will never break a desktop shader compile.
 829        */
 830       unsigned precision:2;
 831
 832       /**
 833        * \brief Layout qualifier for gl_FragDepth.
 834        *
 835        * This is not equal to \c ir_depth_layout_none if and only if this
 836        * variable is \c gl_FragDepth and a layout qualifier is specified.
 837        */
 838       ir_depth_layout depth_layout:3;
 839
 840       /**
 841        * Memory qualifiers.
 842        */
 843       unsigned memory_read_only:1; /**< "readonly" qualifier. */
 844       unsigned memory_write_only:1; /**< "writeonly" qualifier. */
 845       unsigned memory_coherent:1;
 846       unsigned memory_volatile:1;
 847       unsigned memory_restrict:1;
 848
 849       /**
 850        * ARB_shader_storage_buffer_object
 851        */
 852       unsigned from_ssbo_unsized_array:1; /**< unsized array buffer variable. */
 853
 854       unsigned implicit_sized_array:1;
 855
 856       /**
 857        * Whether this is a fragment shader output implicitly initialized with
 858        * the previous contents of the specified render target at the
 859        * framebuffer location corresponding to this shader invocation.
 860        */
 861       unsigned fb_fetch_output:1;
 862
 863       /**
 864        * Non-zero if this variable is considered bindless as defined by
 865        * ARB_bindless_texture.
 866        */
 867       unsigned bindless:1;
 868
 869       /**
 870        * Non-zero if this variable is considered bound as defined by
 871        * ARB_bindless_texture.
 872        */
 873       unsigned bound:1;
 874
 875       /**
 876        * Emit a warning if this variable is accessed.
 877        */
 878    private:
 879       uint8_t warn_extension_index;
 880
 881    public:
 882       /** Image internal format if specified explicitly, otherwise GL_NONE. */
 883       uint16_t image_format;
 884
 885    private:
 886       /**
 887        * Number of state slots used
 888        *
 889        * \note
 890        * This could be stored in as few as 7-bits, if necessary.  If it is made
 891        * smaller, add an assertion to \c ir_variable::allocate_state_slots to
 892        * be safe.
 893        */
 894       uint16_t _num_state_slots;
 895
 896    public:
 897       /**
 898        * Initial binding point for a sampler, atomic, or UBO.
 899        *
 900        * For array types, this represents the binding point for the first element.
 901        */
 902       int16_t binding;
 903
 904       /**
 905        * Storage location of the base of this variable
 906        *
 907        * The precise meaning of this field depends on the nature of the variable.
 908        *
 909        *   - Vertex shader input: one of the values from \c gl_vert_attrib.
 910        *   - Vertex shader output: one of the values from \c gl_varying_slot.
 911        *   - Geometry shader input: one of the values from \c gl_varying_slot.
 912        *   - Geometry shader output: one of the values from \c gl_varying_slot.
 913        *   - Fragment shader input: one of the values from \c gl_varying_slot.
 914        *   - Fragment shader output: one of the values from \c gl_frag_result.
 915        *   - Uniforms: Per-stage uniform slot number for default uniform block.
 916        *   - Uniforms: Index within the uniform block definition for UBO members.
 917        *   - Non-UBO Uniforms: explicit location until linking then reused to
 918        *     store uniform slot number.
 919        *   - Other: This field is not currently used.
 920        *
 921        * If the variable is a uniform, shader input, or shader output, and the
 922        * slot has not been assigned, the value will be -1.
 923        */
 924       int location;
 925
 926       /**
 927        * for glsl->tgsi/mesa IR we need to store the index into the
 928        * parameters for uniforms, initially the code overloaded location
 929        * but this causes problems with indirect samplers and AoA.
 930        * This is assigned in _mesa_generate_parameters_list_for_uniforms.
 931        */
 932       int param_index;
 933
 934       /**
 935        * Vertex stream output identifier.
 936        *
 937        * For packed outputs, bit 31 is set and bits [2*i+1,2*i] indicate the
 938        * stream of the i-th component.
 939        */
 940       unsigned stream;
 941
 942       /**
 943        * Atomic, transform feedback or block member offset.
 944        */
 945       unsigned offset;
 946
 947       /**
 948        * Highest element accessed with a constant expression array index
 949        *
 950        * Not used for non-array variables. -1 is never accessed.
 951        */
 952       int max_array_access;
 953
 954       /**
 955        * Transform feedback buffer.
 956        */
 957       unsigned xfb_buffer;
 958
 959       /**
 960        * Transform feedback stride.
 961        */
 962       unsigned xfb_stride;
 963
 964       /**
 965        * Allow (only) ir_variable direct access private members.
 966        */
 967       friend class ir_variable;
 968    } data;
 969
 970    /**
 971     * Value assigned in the initializer of a variable declared "const"
 972     */
 973    ir_constant *constant_value;
 974
 975    /**
 976     * Constant expression assigned in the initializer of the variable
 977     *
 978     * \warning
 979     * This field and \c ::constant_value are distinct.  Even if the two fields
 980     * refer to constants with the same value, they must point to separate
 981     * objects.
 982     */
 983    ir_constant *constant_initializer;
 984
 985 private:
 986    static const char *const warn_extension_table[];
 987
 988    union {
 989       /**
 990        * For variables which satisfy the is_interface_instance() predicate,
 991        * this points to an array of integers such that if the ith member of
 992        * the interface block is an array, max_ifc_array_access[i] is the
 993        * maximum array element of that member that has been accessed.  If the
 994        * ith member of the interface block is not an array,
 995        * max_ifc_array_access[i] is unused.
 996        *
 997        * For variables whose type is not an interface block, this pointer is
 998        * NULL.
 999        */
1000       int *max_ifc_array_access;
1001
1002       /**
1003        * Built-in state that backs this uniform
1004        *
1005        * Once set at variable creation, \c state_slots must remain invariant.
1006        *
1007        * If the variable is not a uniform, \c _num_state_slots will be zero
1008        * and \c state_slots will be \c NULL.
1009        */
1010       ir_state_slot *state_slots;
1011    } u;
1012
1013    /**
1014     * For variables that are in an interface block or are an instance of an
1015     * interface block, this is the \c GLSL_TYPE_INTERFACE type for that block.
1016     *
1017     * \sa ir_variable::location
1018     */
1019    const glsl_type *interface_type;
1020
1021    /**
1022     * Name used for anonymous compiler temporaries
1023     */
1024    static const char tmp_name[];
1025
1026 public:
1027    /**
1028     * Should the construct keep names for ir_var_temporary variables?
1029     *
1030     * When this global is false, names passed to the constructor for
1031     * \c ir_var_temporary variables will be dropped.  Instead, the variable will
1032     * be named "compiler_temp".  This name will be in static storage.
1033     *
1034     * \warning
1035     * \b NEVER change the mode of an \c ir_var_temporary.
1036     *
1037     * \warning
1038     * This variable is \b not thread-safe.  It is global, \b not
1039     * per-context. It begins life false.  A context can, at some point, make
1040     * it true.  From that point on, it will be true forever.  This should be
1041     * okay since it will only be set true while debugging.
1042     */
1043    static bool temporaries_allocate_names;
1044 };
1045
1046 /**
1047  * A function that returns whether a built-in function is available in the
1048  * current shading language (based on version, ES or desktop, and extensions).
1049  */
1050 typedef bool (*builtin_available_predicate)(const _mesa_glsl_parse_state *);
1051
1052 #define MAKE_INTRINSIC_FOR_TYPE(op, t) \
1053    ir_intrinsic_generic_ ## op - ir_intrinsic_generic_load + ir_intrinsic_ ## t ## _ ## load
1054
1055 #define MAP_INTRINSIC_TO_TYPE(i, t) \
1056    ir_intrinsic_id(int(i) - int(ir_intrinsic_generic_load) + int(ir_intrinsic_ ## t ## _ ## load))
1057
1058 enum ir_intrinsic_id {
1059    ir_intrinsic_invalid = 0,
1060
1061    /**
1062     * \name Generic intrinsics
1063     *
1064     * Each of these intrinsics has a specific version for shared variables and
1065     * SSBOs.
1066     */
1067    /*@{*/
1068    ir_intrinsic_generic_load,
1069    ir_intrinsic_generic_store,
1070    ir_intrinsic_generic_atomic_add,
1071    ir_intrinsic_generic_atomic_and,
1072    ir_intrinsic_generic_atomic_or,
1073    ir_intrinsic_generic_atomic_xor,
1074    ir_intrinsic_generic_atomic_min,
1075    ir_intrinsic_generic_atomic_max,
1076    ir_intrinsic_generic_atomic_exchange,
1077    ir_intrinsic_generic_atomic_comp_swap,
1078    /*@}*/
1079
1080    ir_intrinsic_atomic_counter_read,
1081    ir_intrinsic_atomic_counter_increment,
1082    ir_intrinsic_atomic_counter_predecrement,
1083    ir_intrinsic_atomic_counter_add,
1084    ir_intrinsic_atomic_counter_and,
1085    ir_intrinsic_atomic_counter_or,
1086    ir_intrinsic_atomic_counter_xor,
1087    ir_intrinsic_atomic_counter_min,
1088    ir_intrinsic_atomic_counter_max,
1089    ir_intrinsic_atomic_counter_exchange,
1090    ir_intrinsic_atomic_counter_comp_swap,
1091
1092    ir_intrinsic_image_load,
1093    ir_intrinsic_image_store,
1094    ir_intrinsic_image_atomic_add,
1095    ir_intrinsic_image_atomic_and,
1096    ir_intrinsic_image_atomic_or,
1097    ir_intrinsic_image_atomic_xor,
1098    ir_intrinsic_image_atomic_min,
1099    ir_intrinsic_image_atomic_max,
1100    ir_intrinsic_image_atomic_exchange,
1101    ir_intrinsic_image_atomic_comp_swap,
1102    ir_intrinsic_image_size,
1103    ir_intrinsic_image_samples,
1104
1105    ir_intrinsic_ssbo_load,
1106    ir_intrinsic_ssbo_store = MAKE_INTRINSIC_FOR_TYPE(store, ssbo),
1107    ir_intrinsic_ssbo_atomic_add = MAKE_INTRINSIC_FOR_TYPE(atomic_add, ssbo),
1108    ir_intrinsic_ssbo_atomic_and = MAKE_INTRINSIC_FOR_TYPE(atomic_and, ssbo),
1109    ir_intrinsic_ssbo_atomic_or = MAKE_INTRINSIC_FOR_TYPE(atomic_or, ssbo),
1110    ir_intrinsic_ssbo_atomic_xor = MAKE_INTRINSIC_FOR_TYPE(atomic_xor, ssbo),
1111    ir_intrinsic_ssbo_atomic_min = MAKE_INTRINSIC_FOR_TYPE(atomic_min, ssbo),
1112    ir_intrinsic_ssbo_atomic_max = MAKE_INTRINSIC_FOR_TYPE(atomic_max, ssbo),
1113    ir_intrinsic_ssbo_atomic_exchange = MAKE_INTRINSIC_FOR_TYPE(atomic_exchange, ssbo),
1114    ir_intrinsic_ssbo_atomic_comp_swap = MAKE_INTRINSIC_FOR_TYPE(atomic_comp_swap, ssbo),
1115
1116    ir_intrinsic_memory_barrier,
1117    ir_intrinsic_shader_clock,
1118    ir_intrinsic_group_memory_barrier,
1119    ir_intrinsic_memory_barrier_atomic_counter,
1120    ir_intrinsic_memory_barrier_buffer,
1121    ir_intrinsic_memory_barrier_image,
1122    ir_intrinsic_memory_barrier_shared,
1123
1124    ir_intrinsic_vote_all,
1125    ir_intrinsic_vote_any,
1126    ir_intrinsic_vote_eq,
1127    ir_intrinsic_ballot,
1128    ir_intrinsic_read_invocation,
1129    ir_intrinsic_read_first_invocation,
1130
1131    ir_intrinsic_shared_load,
1132    ir_intrinsic_shared_store = MAKE_INTRINSIC_FOR_TYPE(store, shared),
1133    ir_intrinsic_shared_atomic_add = MAKE_INTRINSIC_FOR_TYPE(atomic_add, shared),
1134    ir_intrinsic_shared_atomic_and = MAKE_INTRINSIC_FOR_TYPE(atomic_and, shared),
1135    ir_intrinsic_shared_atomic_or = MAKE_INTRINSIC_FOR_TYPE(atomic_or, shared),
1136    ir_intrinsic_shared_atomic_xor = MAKE_INTRINSIC_FOR_TYPE(atomic_xor, shared),
1137    ir_intrinsic_shared_atomic_min = MAKE_INTRINSIC_FOR_TYPE(atomic_min, shared),
1138    ir_intrinsic_shared_atomic_max = MAKE_INTRINSIC_FOR_TYPE(atomic_max, shared),
1139    ir_intrinsic_shared_atomic_exchange = MAKE_INTRINSIC_FOR_TYPE(atomic_exchange, shared),
1140    ir_intrinsic_shared_atomic_comp_swap = MAKE_INTRINSIC_FOR_TYPE(atomic_comp_swap, shared),
1141 };
1142
1143 /*@{*/
1144 /**
1145  * The representation of a function instance; may be the full definition or
1146  * simply a prototype.
1147  */
1148 class ir_function_signature : public ir_instruction {
1149    /* An ir_function_signature will be part of the list of signatures in
1150     * an ir_function.
1151     */
1152 public:
1153    ir_function_signature(const glsl_type *return_type,
1154                          builtin_available_predicate builtin_avail = NULL);
1155
1156    virtual ir_function_signature *clone(void *mem_ctx,
1157                                         struct hash_table *ht) const;
1158    ir_function_signature *clone_prototype(void *mem_ctx,
1159                                           struct hash_table *ht) const;
1160
1161    virtual void accept(ir_visitor *v)
1162    {
1163       v->visit(this);
1164    }
1165
1166    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1167
1168    /**
1169     * Attempt to evaluate this function as a constant expression,
1170     * given a list of the actual parameters and the variable context.
1171     * Returns NULL for non-built-ins.
1172     */
1173    ir_constant *constant_expression_value(void *mem_ctx,
1174                                           exec_list *actual_parameters,
1175                                           struct hash_table *variable_context);
1176
1177    /**
1178     * Get the name of the function for which this is a signature
1179     */
1180    const char *function_name() const;
1181
1182    /**
1183     * Get a handle to the function for which this is a signature
1184     *
1185     * There is no setter function, this function returns a \c const pointer,
1186     * and \c ir_function_signature::_function is private for a reason.  The
1187     * only way to make a connection between a function and function signature
1188     * is via \c ir_function::add_signature.  This helps ensure that certain
1189     * invariants (i.e., a function signature is in the list of signatures for
1190     * its \c _function) are met.
1191     *
1192     * \sa ir_function::add_signature
1193     */
1194    inline const class ir_function *function() const
1195    {
1196       return this->_function;
1197    }
1198
1199    /**
1200     * Check whether the qualifiers match between this signature's parameters
1201     * and the supplied parameter list.  If not, returns the name of the first
1202     * parameter with mismatched qualifiers (for use in error messages).
1203     */
1204    const char *qualifiers_match(exec_list *params);
1205
1206    /**
1207     * Replace the current parameter list with the given one.  This is useful
1208     * if the current information came from a prototype, and either has invalid
1209     * or missing parameter names.
1210     */
1211    void replace_parameters(exec_list *new_params);
1212
1213    /**
1214     * Function return type.
1215     *
1216     * \note This discards the optional precision qualifier.
1217     */
1218    const struct glsl_type *return_type;
1219
1220    /**
1221     * List of ir_variable of function parameters.
1222     *
1223     * This represents the storage.  The paramaters passed in a particular
1224     * call will be in ir_call::actual_paramaters.
1225     */
1226    struct exec_list parameters;
1227
1228    /** Whether or not this function has a body (which may be empty). */
1229    unsigned is_defined:1;
1230
1231    /** Whether or not this function signature is a built-in. */
1232    bool is_builtin() const;
1233
1234    /**
1235     * Whether or not this function is an intrinsic to be implemented
1236     * by the driver.
1237     */
1238    inline bool is_intrinsic() const
1239    {
1240       return intrinsic_id != ir_intrinsic_invalid;
1241    }
1242
1243    /** Indentifier for this intrinsic. */
1244    enum ir_intrinsic_id intrinsic_id;
1245
1246    /** Whether or not a built-in is available for this shader. */
1247    bool is_builtin_available(const _mesa_glsl_parse_state *state) const;
1248
1249    /** Body of instructions in the function. */
1250    struct exec_list body;
1251
1252 private:
1253    /**
1254     * A function pointer to a predicate that answers whether a built-in
1255     * function is available in the current shader.  NULL if not a built-in.
1256     */
1257    builtin_available_predicate builtin_avail;
1258
1259    /** Function of which this signature is one overload. */
1260    class ir_function *_function;
1261
1262    /** Function signature of which this one is a prototype clone */
1263    const ir_function_signature *origin;
1264
1265    friend class ir_function;
1266
1267    /**
1268     * Helper function to run a list of instructions for constant
1269     * expression evaluation.
1270     *
1271     * The hash table represents the values of the visible variables.
1272     * There are no scoping issues because the table is indexed on
1273     * ir_variable pointers, not variable names.
1274     *
1275     * Returns false if the expression is not constant, true otherwise,
1276     * and the value in *result if result is non-NULL.
1277     */
1278    bool constant_expression_evaluate_expression_list(void *mem_ctx,
1279                                                      const struct exec_list &body,
1280                                                      struct hash_table *variable_context,
1281                                                      ir_constant **result);
1282 };
1283
1284
1285 /**
1286  * Header for tracking multiple overloaded functions with the same name.
1287  * Contains a list of ir_function_signatures representing each of the
1288  * actual functions.
1289  */
1290 class ir_function : public ir_instruction {
1291 public:
1292    ir_function(const char *name);
1293
1294    virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const;
1295
1296    virtual void accept(ir_visitor *v)
1297    {
1298       v->visit(this);
1299    }
1300
1301    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1302
1303    void add_signature(ir_function_signature *sig)
1304    {
1305       sig->_function = this;
1306       this->signatures.push_tail(sig);
1307    }
1308
1309    /**
1310     * Find a signature that matches a set of actual parameters, taking implicit
1311     * conversions into account.  Also flags whether the match was exact.
1312     */
1313    ir_function_signature *matching_signature(_mesa_glsl_parse_state *state,
1314                                              const exec_list *actual_param,
1315                                              bool allow_builtins,
1316                                              bool *match_is_exact);
1317
1318    /**
1319     * Find a signature that matches a set of actual parameters, taking implicit
1320     * conversions into account.
1321     */
1322    ir_function_signature *matching_signature(_mesa_glsl_parse_state *state,
1323                                              const exec_list *actual_param,
1324                                              bool allow_builtins);
1325
1326    /**
1327     * Find a signature that exactly matches a set of actual parameters without
1328     * any implicit type conversions.
1329     */
1330    ir_function_signature *exact_matching_signature(_mesa_glsl_parse_state *state,
1331                                                    const exec_list *actual_ps);
1332
1333    /**
1334     * Name of the function.
1335     */
1336    const char *name;
1337
1338    /** Whether or not this function has a signature that isn't a built-in. */
1339    bool has_user_signature();
1340
1341    /**
1342     * List of ir_function_signature for each overloaded function with this name.
1343     */
1344    struct exec_list signatures;
1345
1346    /**
1347     * is this function a subroutine type declaration
1348     * e.g. subroutine void type1(float arg1);
1349     */
1350    bool is_subroutine;
1351
1352    /**
1353     * is this function associated to a subroutine type
1354     * e.g. subroutine (type1, type2) function_name { function_body };
1355     * would have num_subroutine_types 2,
1356     * and pointers to the type1 and type2 types.
1357     */
1358    int num_subroutine_types;
1359    const struct glsl_type **subroutine_types;
1360
1361    int subroutine_index;
1362 };
1363
1364 inline const char *ir_function_signature::function_name() const
1365 {
1366    return this->_function->name;
1367 }
1368 /*@}*/
1369
1370
1371 /**
1372  * IR instruction representing high-level if-statements
1373  */
1374 class ir_if : public ir_instruction {
1375 public:
1376    ir_if(ir_rvalue *condition)
1377       : ir_instruction(ir_type_if), condition(condition)
1378    {
1379    }
1380
1381    virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const;
1382
1383    virtual void accept(ir_visitor *v)
1384    {
1385       v->visit(this);
1386    }
1387
1388    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1389
1390    ir_rvalue *condition;
1391    /** List of ir_instruction for the body of the then branch */
1392    exec_list  then_instructions;
1393    /** List of ir_instruction for the body of the else branch */
1394    exec_list  else_instructions;
1395 };
1396
1397
1398 /**
1399  * IR instruction representing a high-level loop structure.
1400  */
1401 class ir_loop : public ir_instruction {
1402 public:
1403    ir_loop();
1404
1405    virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const;
1406
1407    virtual void accept(ir_visitor *v)
1408    {
1409       v->visit(this);
1410    }
1411
1412    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1413
1414    /** List of ir_instruction that make up the body of the loop. */
1415    exec_list body_instructions;
1416 };
1417
1418
1419 class ir_assignment : public ir_instruction {
1420 public:
1421    ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition = NULL);
1422
1423    /**
1424     * Construct an assignment with an explicit write mask
1425     *
1426     * \note
1427     * Since a write mask is supplied, the LHS must already be a bare
1428     * \c ir_dereference.  The cannot be any swizzles in the LHS.
1429     */
1430    ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, ir_rvalue *condition,
1431                  unsigned write_mask);
1432
1433    virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const;
1434
1435    virtual ir_constant *constant_expression_value(void *mem_ctx,
1436                                                   struct hash_table *variable_context = NULL);
1437
1438    virtual void accept(ir_visitor *v)
1439    {
1440       v->visit(this);
1441    }
1442
1443    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1444
1445    /**
1446     * Get a whole variable written by an assignment
1447     *
1448     * If the LHS of the assignment writes a whole variable, the variable is
1449     * returned.  Otherwise \c NULL is returned.  Examples of whole-variable
1450     * assignment are:
1451     *
1452     *  - Assigning to a scalar
1453     *  - Assigning to all components of a vector
1454     *  - Whole array (or matrix) assignment
1455     *  - Whole structure assignment
1456     */
1457    ir_variable *whole_variable_written();
1458
1459    /**
1460     * Set the LHS of an assignment
1461     */
1462    void set_lhs(ir_rvalue *lhs);
1463
1464    /**
1465     * Left-hand side of the assignment.
1466     *
1467     * This should be treated as read only.  If you need to set the LHS of an
1468     * assignment, use \c ir_assignment::set_lhs.
1469     */
1470    ir_dereference *lhs;
1471
1472    /**
1473     * Value being assigned
1474     */
1475    ir_rvalue *rhs;
1476
1477    /**
1478     * Optional condition for the assignment.
1479     */
1480    ir_rvalue *condition;
1481
1482
1483    /**
1484     * Component mask written
1485     *
1486     * For non-vector types in the LHS, this field will be zero.  For vector
1487     * types, a bit will be set for each component that is written.  Note that
1488     * for \c vec2 and \c vec3 types only the lower bits will ever be set.
1489     *
1490     * A partially-set write mask means that each enabled channel gets
1491     * the value from a consecutive channel of the rhs.  For example,
1492     * to write just .xyw of gl_FrontColor with color:
1493     *
1494     * (assign (constant bool (1)) (xyw)
1495     *     (var_ref gl_FragColor)
1496     *     (swiz xyw (var_ref color)))
1497     */
1498    unsigned write_mask:4;
1499 };
1500
1501 #include "ir_expression_operation.h"
1502
1503 extern const char *const ir_expression_operation_strings[ir_last_opcode + 1];
1504 extern const char *const ir_expression_operation_enum_strings[ir_last_opcode + 1];
1505
1506 class ir_expression : public ir_rvalue {
1507 public:
1508    ir_expression(int op, const struct glsl_type *type,
1509                  ir_rvalue *op0, ir_rvalue *op1 = NULL,
1510                  ir_rvalue *op2 = NULL, ir_rvalue *op3 = NULL);
1511
1512    /**
1513     * Constructor for unary operation expressions
1514     */
1515    ir_expression(int op, ir_rvalue *);
1516
1517    /**
1518     * Constructor for binary operation expressions
1519     */
1520    ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1);
1521
1522    /**
1523     * Constructor for ternary operation expressions
1524     */
1525    ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1, ir_rvalue *op2);
1526
1527    virtual bool equals(const ir_instruction *ir,
1528                        enum ir_node_type ignore = ir_type_unset) const;
1529
1530    virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const;
1531
1532    /**
1533     * Attempt to constant-fold the expression
1534     *
1535     * The "variable_context" hash table links ir_variable * to ir_constant *
1536     * that represent the variables' values.  \c NULL represents an empty
1537     * context.
1538     *
1539     * If the expression cannot be constant folded, this method will return
1540     * \c NULL.
1541     */
1542    virtual ir_constant *constant_expression_value(void *mem_ctx,
1543                                                   struct hash_table *variable_context = NULL);
1544
1545    /**
1546     * This is only here for ir_reader to used for testing purposes please use
1547     * the precomputed num_operands field if you need the number of operands.
1548     */
1549    static unsigned get_num_operands(ir_expression_operation);
1550
1551    /**
1552     * Return whether the expression operates on vectors horizontally.
1553     */
1554    bool is_horizontal() const
1555    {
1556       return operation == ir_binop_all_equal ||
1557              operation == ir_binop_any_nequal ||
1558              operation == ir_binop_dot ||
1559              operation == ir_binop_vector_extract ||
1560              operation == ir_triop_vector_insert ||
1561              operation == ir_binop_ubo_load ||
1562              operation == ir_quadop_vector;
1563    }
1564
1565    /**
1566     * Do a reverse-lookup to translate the given string into an operator.
1567     */
1568    static ir_expression_operation get_operator(const char *);
1569
1570    virtual void accept(ir_visitor *v)
1571    {
1572       v->visit(this);
1573    }
1574
1575    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1576
1577    virtual ir_variable *variable_referenced() const;
1578
1579    /**
1580     * Determine the number of operands used by an expression
1581     */
1582    void init_num_operands()
1583    {
1584       if (operation == ir_quadop_vector) {
1585          num_operands = this->type->vector_elements;
1586       } else {
1587          num_operands = get_num_operands(operation);
1588       }
1589    }
1590
1591    ir_expression_operation operation;
1592    ir_rvalue *operands[4];
1593    uint8_t num_operands;
1594 };
1595
1596
1597 /**
1598  * HIR instruction representing a high-level function call, containing a list
1599  * of parameters and returning a value in the supplied temporary.
1600  */
1601 class ir_call : public ir_instruction {
1602 public:
1603    ir_call(ir_function_signature *callee,
1604            ir_dereference_variable *return_deref,
1605            exec_list *actual_parameters)
1606       : ir_instruction(ir_type_call), return_deref(return_deref), callee(callee), sub_var(NULL), array_idx(NULL)
1607    {
1608       assert(callee->return_type != NULL);
1609       actual_parameters->move_nodes_to(& this->actual_parameters);
1610    }
1611
1612    ir_call(ir_function_signature *callee,
1613            ir_dereference_variable *return_deref,
1614            exec_list *actual_parameters,
1615            ir_variable *var, ir_rvalue *array_idx)
1616       : ir_instruction(ir_type_call), return_deref(return_deref), callee(callee), sub_var(var), array_idx(array_idx)
1617    {
1618       assert(callee->return_type != NULL);
1619       actual_parameters->move_nodes_to(& this->actual_parameters);
1620    }
1621
1622    virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const;
1623
1624    virtual ir_constant *constant_expression_value(void *mem_ctx,
1625                                                   struct hash_table *variable_context = NULL);
1626
1627    virtual void accept(ir_visitor *v)
1628    {
1629       v->visit(this);
1630    }
1631
1632    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1633
1634    /**
1635     * Get the name of the function being called.
1636     */
1637    const char *callee_name() const
1638    {
1639       return callee->function_name();
1640    }
1641
1642    /**
1643     * Generates an inline version of the function before @ir,
1644     * storing the return value in return_deref.
1645     */
1646    void generate_inline(ir_instruction *ir);
1647
1648    /**
1649     * Storage for the function's return value.
1650     * This must be NULL if the return type is void.
1651     */
1652    ir_dereference_variable *return_deref;
1653
1654    /**
1655     * The specific function signature being called.
1656     */
1657    ir_function_signature *callee;
1658
1659    /* List of ir_rvalue of paramaters passed in this call. */
1660    exec_list actual_parameters;
1661
1662    /*
1663     * ARB_shader_subroutine support -
1664     * the subroutine uniform variable and array index
1665     * rvalue to be used in the lowering pass later.
1666     */
1667    ir_variable *sub_var;
1668    ir_rvalue *array_idx;
1669 };
1670
1671
1672 /**
1673  * \name Jump-like IR instructions.
1674  *
1675  * These include \c break, \c continue, \c return, and \c discard.
1676  */
1677 /*@{*/
1678 class ir_jump : public ir_instruction {
1679 protected:
1680    ir_jump(enum ir_node_type t)
1681       : ir_instruction(t)
1682    {
1683    }
1684 };
1685
1686 class ir_return : public ir_jump {
1687 public:
1688    ir_return()
1689       : ir_jump(ir_type_return), value(NULL)
1690    {
1691    }
1692
1693    ir_return(ir_rvalue *value)
1694       : ir_jump(ir_type_return), value(value)
1695    {
1696    }
1697
1698    virtual ir_return *clone(void *mem_ctx, struct hash_table *) const;
1699
1700    ir_rvalue *get_value() const
1701    {
1702       return value;
1703    }
1704
1705    virtual void accept(ir_visitor *v)
1706    {
1707       v->visit(this);
1708    }
1709
1710    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1711
1712    ir_rvalue *value;
1713 };
1714
1715
1716 /**
1717  * Jump instructions used inside loops
1718  *
1719  * These include \c break and \c continue.  The \c break within a loop is
1720  * different from the \c break within a switch-statement.
1721  *
1722  * \sa ir_switch_jump
1723  */
1724 class ir_loop_jump : public ir_jump {
1725 public:
1726    enum jump_mode {
1727       jump_break,
1728       jump_continue
1729    };
1730
1731    ir_loop_jump(jump_mode mode)
1732       : ir_jump(ir_type_loop_jump)
1733    {
1734       this->mode = mode;
1735    }
1736
1737    virtual ir_loop_jump *clone(void *mem_ctx, struct hash_table *) const;
1738
1739    virtual void accept(ir_visitor *v)
1740    {
1741       v->visit(this);
1742    }
1743
1744    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1745
1746    bool is_break() const
1747    {
1748       return mode == jump_break;
1749    }
1750
1751    bool is_continue() const
1752    {
1753       return mode == jump_continue;
1754    }
1755
1756    /** Mode selector for the jump instruction. */
1757    enum jump_mode mode;
1758 };
1759
1760 /**
1761  * IR instruction representing discard statements.
1762  */
1763 class ir_discard : public ir_jump {
1764 public:
1765    ir_discard()
1766       : ir_jump(ir_type_discard)
1767    {
1768       this->condition = NULL;
1769    }
1770
1771    ir_discard(ir_rvalue *cond)
1772       : ir_jump(ir_type_discard)
1773    {
1774       this->condition = cond;
1775    }
1776
1777    virtual ir_discard *clone(void *mem_ctx, struct hash_table *ht) const;
1778
1779    virtual void accept(ir_visitor *v)
1780    {
1781       v->visit(this);
1782    }
1783
1784    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1785
1786    ir_rvalue *condition;
1787 };
1788 /*@}*/
1789
1790
1791 /**
1792  * Texture sampling opcodes used in ir_texture
1793  */
1794 enum ir_texture_opcode {
1795    ir_tex,              /**< Regular texture look-up */
1796    ir_txb,              /**< Texture look-up with LOD bias */
1797    ir_txl,              /**< Texture look-up with explicit LOD */
1798    ir_txd,              /**< Texture look-up with partial derivatvies */
1799    ir_txf,              /**< Texel fetch with explicit LOD */
1800    ir_txf_ms,           /**< Multisample texture fetch */
1801    ir_txs,              /**< Texture size */
1802    ir_lod,              /**< Texture lod query */
1803    ir_tg4,              /**< Texture gather */
1804    ir_query_levels,     /**< Texture levels query */
1805    ir_texture_samples,  /**< Texture samples query */
1806    ir_samples_identical, /**< Query whether all samples are definitely identical. */
1807 };
1808
1809
1810 /**
1811  * IR instruction to sample a texture
1812  *
1813  * The specific form of the IR instruction depends on the \c mode value
1814  * selected from \c ir_texture_opcodes.  In the printed IR, these will
1815  * appear as:
1816  *
1817  *                                    Texel offset (0 or an expression)
1818  *                                    | Projection divisor
1819  *                                    | |  Shadow comparator
1820  *                                    | |  |
1821  *                                    v v  v
1822  * (tex <type> <sampler> <coordinate> 0 1 ( ))
1823  * (txb <type> <sampler> <coordinate> 0 1 ( ) <bias>)
1824  * (txl <type> <sampler> <coordinate> 0 1 ( ) <lod>)
1825  * (txd <type> <sampler> <coordinate> 0 1 ( ) (dPdx dPdy))
1826  * (txf <type> <sampler> <coordinate> 0       <lod>)
1827  * (txf_ms
1828  *      <type> <sampler> <coordinate>         <sample_index>)
1829  * (txs <type> <sampler> <lod>)
1830  * (lod <type> <sampler> <coordinate>)
1831  * (tg4 <type> <sampler> <coordinate> <offset> <component>)
1832  * (query_levels <type> <sampler>)
1833  * (samples_identical <sampler> <coordinate>)
1834  */
1835 class ir_texture : public ir_rvalue {
1836 public:
1837    ir_texture(enum ir_texture_opcode op)
1838       : ir_rvalue(ir_type_texture),
1839         op(op), sampler(NULL), coordinate(NULL), projector(NULL),
1840         shadow_comparator(NULL), offset(NULL)
1841    {
1842       memset(&lod_info, 0, sizeof(lod_info));
1843    }
1844
1845    virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const;
1846
1847    virtual ir_constant *constant_expression_value(void *mem_ctx,
1848                                                   struct hash_table *variable_context = NULL);
1849
1850    virtual void accept(ir_visitor *v)
1851    {
1852       v->visit(this);
1853    }
1854
1855    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1856
1857    virtual bool equals(const ir_instruction *ir,
1858                        enum ir_node_type ignore = ir_type_unset) const;
1859
1860    /**
1861     * Return a string representing the ir_texture_opcode.
1862     */
1863    const char *opcode_string();
1864
1865    /** Set the sampler and type. */
1866    void set_sampler(ir_dereference *sampler, const glsl_type *type);
1867
1868    /**
1869     * Do a reverse-lookup to translate a string into an ir_texture_opcode.
1870     */
1871    static ir_texture_opcode get_opcode(const char *);
1872
1873    enum ir_texture_opcode op;
1874
1875    /** Sampler to use for the texture access. */
1876    ir_dereference *sampler;
1877
1878    /** Texture coordinate to sample */
1879    ir_rvalue *coordinate;
1880
1881    /**
1882     * Value used for projective divide.
1883     *
1884     * If there is no projective divide (the common case), this will be
1885     * \c NULL.  Optimization passes should check for this to point to a constant
1886     * of 1.0 and replace that with \c NULL.
1887     */
1888    ir_rvalue *projector;
1889
1890    /**
1891     * Coordinate used for comparison on shadow look-ups.
1892     *
1893     * If there is no shadow comparison, this will be \c NULL.  For the
1894     * \c ir_txf opcode, this *must* be \c NULL.
1895     */
1896    ir_rvalue *shadow_comparator;
1897
1898    /** Texel offset. */
1899    ir_rvalue *offset;
1900
1901    union {
1902       ir_rvalue *lod;           /**< Floating point LOD */
1903       ir_rvalue *bias;          /**< Floating point LOD bias */
1904       ir_rvalue *sample_index;  /**< MSAA sample index */
1905       ir_rvalue *component;     /**< Gather component selector */
1906       struct {
1907          ir_rvalue *dPdx;       /**< Partial derivative of coordinate wrt X */
1908          ir_rvalue *dPdy;       /**< Partial derivative of coordinate wrt Y */
1909       } grad;
1910    } lod_info;
1911 };
1912
1913
1914 struct ir_swizzle_mask {
1915    unsigned x:2;
1916    unsigned y:2;
1917    unsigned z:2;
1918    unsigned w:2;
1919
1920    /**
1921     * Number of components in the swizzle.
1922     */
1923    unsigned num_components:3;
1924
1925    /**
1926     * Does the swizzle contain duplicate components?
1927     *
1928     * L-value swizzles cannot contain duplicate components.
1929     */
1930    unsigned has_duplicates:1;
1931 };
1932
1933
1934 class ir_swizzle : public ir_rvalue {
1935 public:
1936    ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w,
1937               unsigned count);
1938
1939    ir_swizzle(ir_rvalue *val, const unsigned *components, unsigned count);
1940
1941    ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask);
1942
1943    virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const;
1944
1945    virtual ir_constant *constant_expression_value(void *mem_ctx,
1946                                                   struct hash_table *variable_context = NULL);
1947
1948    /**
1949     * Construct an ir_swizzle from the textual representation.  Can fail.
1950     */
1951    static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length);
1952
1953    virtual void accept(ir_visitor *v)
1954    {
1955       v->visit(this);
1956    }
1957
1958    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1959
1960    virtual bool equals(const ir_instruction *ir,
1961                        enum ir_node_type ignore = ir_type_unset) const;
1962
1963    bool is_lvalue(const struct _mesa_glsl_parse_state *state) const
1964    {
1965       return val->is_lvalue(state) && !mask.has_duplicates;
1966    }
1967
1968    /**
1969     * Get the variable that is ultimately referenced by an r-value
1970     */
1971    virtual ir_variable *variable_referenced() const;
1972
1973    ir_rvalue *val;
1974    ir_swizzle_mask mask;
1975
1976 private:
1977    /**
1978     * Initialize the mask component of a swizzle
1979     *
1980     * This is used by the \c ir_swizzle constructors.
1981     */
1982    void init_mask(const unsigned *components, unsigned count);
1983 };
1984
1985
1986 class ir_dereference : public ir_rvalue {
1987 public:
1988    virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0;
1989
1990    bool is_lvalue(const struct _mesa_glsl_parse_state *state) const;
1991
1992    /**
1993     * Get the variable that is ultimately referenced by an r-value
1994     */
1995    virtual ir_variable *variable_referenced() const = 0;
1996
1997 protected:
1998    ir_dereference(enum ir_node_type t)
1999       : ir_rvalue(t)
2000    {
2001    }
2002 };
2003
2004
2005 class ir_dereference_variable : public ir_dereference {
2006 public:
2007    ir_dereference_variable(ir_variable *var);
2008
2009    virtual ir_dereference_variable *clone(void *mem_ctx,
2010                                           struct hash_table *) const;
2011
2012    virtual ir_constant *constant_expression_value(void *mem_ctx,
2013                                                   struct hash_table *variable_context = NULL);
2014
2015    virtual bool equals(const ir_instruction *ir,
2016                        enum ir_node_type ignore = ir_type_unset) const;
2017
2018    /**
2019     * Get the variable that is ultimately referenced by an r-value
2020     */
2021    virtual ir_variable *variable_referenced() const
2022    {
2023       return this->var;
2024    }
2025
2026    virtual ir_variable *whole_variable_referenced()
2027    {
2028       /* ir_dereference_variable objects always dereference the entire
2029        * variable.  However, if this dereference is dereferenced by anything
2030        * else, the complete deferefernce chain is not a whole-variable
2031        * dereference.  This method should only be called on the top most
2032        * ir_rvalue in a dereference chain.
2033        */
2034       return this->var;
2035    }
2036
2037    virtual void accept(ir_visitor *v)
2038    {
2039       v->visit(this);
2040    }
2041
2042    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2043
2044    /**
2045     * Object being dereferenced.
2046     */
2047    ir_variable *var;
2048 };
2049
2050
2051 class ir_dereference_array : public ir_dereference {
2052 public:
2053    ir_dereference_array(ir_rvalue *value, ir_rvalue *array_index);
2054
2055    ir_dereference_array(ir_variable *var, ir_rvalue *array_index);
2056
2057    virtual ir_dereference_array *clone(void *mem_ctx,
2058                                        struct hash_table *) const;
2059
2060    virtual ir_constant *constant_expression_value(void *mem_ctx,
2061                                                   struct hash_table *variable_context = NULL);
2062
2063    virtual bool equals(const ir_instruction *ir,
2064                        enum ir_node_type ignore = ir_type_unset) const;
2065
2066    /**
2067     * Get the variable that is ultimately referenced by an r-value
2068     */
2069    virtual ir_variable *variable_referenced() const
2070    {
2071       return this->array->variable_referenced();
2072    }
2073
2074    virtual void accept(ir_visitor *v)
2075    {
2076       v->visit(this);
2077    }
2078
2079    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2080
2081    ir_rvalue *array;
2082    ir_rvalue *array_index;
2083
2084 private:
2085    void set_array(ir_rvalue *value);
2086 };
2087
2088
2089 class ir_dereference_record : public ir_dereference {
2090 public:
2091    ir_dereference_record(ir_rvalue *value, const char *field);
2092
2093    ir_dereference_record(ir_variable *var, const char *field);
2094
2095    virtual ir_dereference_record *clone(void *mem_ctx,
2096                                         struct hash_table *) const;
2097
2098    virtual ir_constant *constant_expression_value(void *mem_ctx,
2099                                                   struct hash_table *variable_context = NULL);
2100
2101    /**
2102     * Get the variable that is ultimately referenced by an r-value
2103     */
2104    virtual ir_variable *variable_referenced() const
2105    {
2106       return this->record->variable_referenced();
2107    }
2108
2109    virtual void accept(ir_visitor *v)
2110    {
2111       v->visit(this);
2112    }
2113
2114    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2115
2116    ir_rvalue *record;
2117    int field_idx;
2118 };
2119
2120
2121 /**
2122  * Data stored in an ir_constant
2123  */
2124 union ir_constant_data {
2125       unsigned u[16];
2126       int i[16];
2127       float f[16];
2128       bool b[16];
2129       double d[16];
2130       uint64_t u64[16];
2131       int64_t i64[16];
2132 };
2133
2134
2135 class ir_constant : public ir_rvalue {
2136 public:
2137    ir_constant(const struct glsl_type *type, const ir_constant_data *data);
2138    ir_constant(bool b, unsigned vector_elements=1);
2139    ir_constant(unsigned int u, unsigned vector_elements=1);
2140    ir_constant(int i, unsigned vector_elements=1);
2141    ir_constant(float f, unsigned vector_elements=1);
2142    ir_constant(double d, unsigned vector_elements=1);
2143    ir_constant(uint64_t u64, unsigned vector_elements=1);
2144    ir_constant(int64_t i64, unsigned vector_elements=1);
2145
2146    /**
2147     * Construct an ir_constant from a list of ir_constant values
2148     */
2149    ir_constant(const struct glsl_type *type, exec_list *values);
2150
2151    /**
2152     * Construct an ir_constant from a scalar component of another ir_constant
2153     *
2154     * The new \c ir_constant inherits the type of the component from the
2155     * source constant.
2156     *
2157     * \note
2158     * In the case of a matrix constant, the new constant is a scalar, \b not
2159     * a vector.
2160     */
2161    ir_constant(const ir_constant *c, unsigned i);
2162
2163    /**
2164     * Return a new ir_constant of the specified type containing all zeros.
2165     */
2166    static ir_constant *zero(void *mem_ctx, const glsl_type *type);
2167
2168    virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const;
2169
2170    virtual ir_constant *constant_expression_value(void *mem_ctx,
2171                                                   struct hash_table *variable_context = NULL);
2172
2173    virtual void accept(ir_visitor *v)
2174    {
2175       v->visit(this);
2176    }
2177
2178    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2179
2180    virtual bool equals(const ir_instruction *ir,
2181                        enum ir_node_type ignore = ir_type_unset) const;
2182
2183    /**
2184     * Get a particular component of a constant as a specific type
2185     *
2186     * This is useful, for example, to get a value from an integer constant
2187     * as a float or bool.  This appears frequently when constructors are
2188     * called with all constant parameters.
2189     */
2190    /*@{*/
2191    bool get_bool_component(unsigned i) const;
2192    float get_float_component(unsigned i) const;
2193    double get_double_component(unsigned i) const;
2194    int get_int_component(unsigned i) const;
2195    unsigned get_uint_component(unsigned i) const;
2196    int64_t get_int64_component(unsigned i) const;
2197    uint64_t get_uint64_component(unsigned i) const;
2198    /*@}*/
2199
2200    ir_constant *get_array_element(unsigned i) const;
2201
2202    ir_constant *get_record_field(int idx);
2203
2204    /**
2205     * Copy the values on another constant at a given offset.
2206     *
2207     * The offset is ignored for array or struct copies, it's only for
2208     * scalars or vectors into vectors or matrices.
2209     *
2210     * With identical types on both sides and zero offset it's clone()
2211     * without creating a new object.
2212     */
2213
2214    void copy_offset(ir_constant *src, int offset);
2215
2216    /**
2217     * Copy the values on another constant at a given offset and
2218     * following an assign-like mask.
2219     *
2220     * The mask is ignored for scalars.
2221     *
2222     * Note that this function only handles what assign can handle,
2223     * i.e. at most a vector as source and a column of a matrix as
2224     * destination.
2225     */
2226
2227    void copy_masked_offset(ir_constant *src, int offset, unsigned int mask);
2228
2229    /**
2230     * Determine whether a constant has the same value as another constant
2231     *
2232     * \sa ir_constant::is_zero, ir_constant::is_one,
2233     * ir_constant::is_negative_one
2234     */
2235    bool has_value(const ir_constant *) const;
2236
2237    /**
2238     * Return true if this ir_constant represents the given value.
2239     *
2240     * For vectors, this checks that each component is the given value.
2241     */
2242    virtual bool is_value(float f, int i) const;
2243    virtual bool is_zero() const;
2244    virtual bool is_one() const;
2245    virtual bool is_negative_one() const;
2246
2247    /**
2248     * Return true for constants that could be stored as 16-bit unsigned values.
2249     *
2250     * Note that this will return true even for signed integer ir_constants, as
2251     * long as the value is non-negative and fits in 16-bits.
2252     */
2253    virtual bool is_uint16_constant() const;
2254
2255    /**
2256     * Value of the constant.
2257     *
2258     * The field used to back the values supplied by the constant is determined
2259     * by the type associated with the \c ir_instruction.  Constants may be
2260     * scalars, vectors, or matrices.
2261     */
2262    union ir_constant_data value;
2263
2264    /* Array elements and structure fields */
2265    ir_constant **const_elements;
2266
2267 private:
2268    /**
2269     * Parameterless constructor only used by the clone method
2270     */
2271    ir_constant(void);
2272 };
2273
2274 /**
2275  * IR instruction to emit a vertex in a geometry shader.
2276  */
2277 class ir_emit_vertex : public ir_instruction {
2278 public:
2279    ir_emit_vertex(ir_rvalue *stream)
2280       : ir_instruction(ir_type_emit_vertex),
2281         stream(stream)
2282    {
2283       assert(stream);
2284    }
2285
2286    virtual void accept(ir_visitor *v)
2287    {
2288       v->visit(this);
2289    }
2290
2291    virtual ir_emit_vertex *clone(void *mem_ctx, struct hash_table *ht) const
2292    {
2293       return new(mem_ctx) ir_emit_vertex(this->stream->clone(mem_ctx, ht));
2294    }
2295
2296    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2297
2298    int stream_id() const
2299    {
2300       return stream->as_constant()->value.i[0];
2301    }
2302
2303    ir_rvalue *stream;
2304 };
2305
2306 /**
2307  * IR instruction to complete the current primitive and start a new one in a
2308  * geometry shader.
2309  */
2310 class ir_end_primitive : public ir_instruction {
2311 public:
2312    ir_end_primitive(ir_rvalue *stream)
2313       : ir_instruction(ir_type_end_primitive),
2314         stream(stream)
2315    {
2316       assert(stream);
2317    }
2318
2319    virtual void accept(ir_visitor *v)
2320    {
2321       v->visit(this);
2322    }
2323
2324    virtual ir_end_primitive *clone(void *mem_ctx, struct hash_table *ht) const
2325    {
2326       return new(mem_ctx) ir_end_primitive(this->stream->clone(mem_ctx, ht));
2327    }
2328
2329    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2330
2331    int stream_id() const
2332    {
2333       return stream->as_constant()->value.i[0];
2334    }
2335
2336    ir_rvalue *stream;
2337 };
2338
2339 /**
2340  * IR instruction for tessellation control and compute shader barrier.
2341  */
2342 class ir_barrier : public ir_instruction {
2343 public:
2344    ir_barrier()
2345       : ir_instruction(ir_type_barrier)
2346    {
2347    }
2348
2349    virtual void accept(ir_visitor *v)
2350    {
2351       v->visit(this);
2352    }
2353
2354    virtual ir_barrier *clone(void *mem_ctx, struct hash_table *) const
2355    {
2356       return new(mem_ctx) ir_barrier();
2357    }
2358
2359    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2360 };
2361
2362 /*@}*/
2363
2364 /**
2365  * Apply a visitor to each IR node in a list
2366  */
2367 void
2368 visit_exec_list(exec_list *list, ir_visitor *visitor);
2369
2370 /**
2371  * Validate invariants on each IR node in a list
2372  */
2373 void validate_ir_tree(exec_list *instructions);
2374
2375 struct _mesa_glsl_parse_state;
2376 struct gl_shader_program;
2377
2378 /**
2379  * Detect whether an unlinked shader contains static recursion
2380  *
2381  * If the list of instructions is determined to contain static recursion,
2382  * \c _mesa_glsl_error will be called to emit error messages for each function
2383  * that is in the recursion cycle.
2384  */
2385 void
2386 detect_recursion_unlinked(struct _mesa_glsl_parse_state *state,
2387                           exec_list *instructions);
2388
2389 /**
2390  * Detect whether a linked shader contains static recursion
2391  *
2392  * If the list of instructions is determined to contain static recursion,
2393  * \c link_error_printf will be called to emit error messages for each function
2394  * that is in the recursion cycle.  In addition,
2395  * \c gl_shader_program::LinkStatus will be set to false.
2396  */
2397 void
2398 detect_recursion_linked(struct gl_shader_program *prog,
2399                         exec_list *instructions);
2400
2401 /**
2402  * Make a clone of each IR instruction in a list
2403  *
2404  * \param in   List of IR instructions that are to be cloned
2405  * \param out  List to hold the cloned instructions
2406  */
2407 void
2408 clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in);
2409
2410 extern void
2411 _mesa_glsl_initialize_variables(exec_list *instructions,
2412                                 struct _mesa_glsl_parse_state *state);
2413
2414 extern void
2415 reparent_ir(exec_list *list, void *mem_ctx);
2416
2417 extern void
2418 do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
2419                       gl_shader_stage shader_stage);
2420
2421 extern char *
2422 prototype_string(const glsl_type *return_type, const char *name,
2423                  exec_list *parameters);
2424
2425 const char *
2426 mode_string(const ir_variable *var);
2427
2428 /**
2429  * Built-in / reserved GL variables names start with "gl_"
2430  */
2431 static inline bool
2432 is_gl_identifier(const char *s)
2433 {
2434    return s && s[0] == 'g' && s[1] == 'l' && s[2] == '_';
2435 }
2436
2437 extern "C" {
2438 #endif /* __cplusplus */
2439
2440 extern void _mesa_print_ir(FILE *f, struct exec_list *instructions,
2441                            struct _mesa_glsl_parse_state *state);
2442
2443 extern void
2444 fprint_ir(FILE *f, const void *instruction);
2445
2446 extern const struct gl_builtin_uniform_desc *
2447 _mesa_glsl_get_builtin_uniform_desc(const char *name);
2448
2449 #ifdef __cplusplus
2450 } /* extern "C" */
2451 #endif
2452
2453 unsigned
2454 vertices_per_prim(GLenum prim);
2455
2456 #endif /* IR_H */