src/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 #pragma once
  26 #ifndef IR_H
  27 #define IR_H
  28
  29 #include <cstdio>
  30 #include <cstdlib>
  31
  32 extern "C" {
  33 #include <talloc.h>
  34 }
  35
  36 #include "list.h"
  37 #include "ir_visitor.h"
  38 #include "ir_hierarchical_visitor.h"
  39
  40 #ifndef ARRAY_SIZE
  41 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
  42 #endif
  43
  44 enum ir_node_type {
  45    ir_type_unset,
  46    ir_type_variable,
  47    ir_type_assignment,
  48    ir_type_call,
  49    ir_type_constant,
  50    ir_type_dereference_array,
  51    ir_type_dereference_record,
  52    ir_type_dereference_variable,
  53    ir_type_discard,
  54    ir_type_expression,
  55    ir_type_function,
  56    ir_type_function_signature,
  57    ir_type_if,
  58    ir_type_loop,
  59    ir_type_loop_jump,
  60    ir_type_return,
  61    ir_type_swizzle,
  62    ir_type_texture,
  63    ir_type_max /**< maximum ir_type enum number, for validation */
  64 };
  65
  66 /**
  67  * Base class of all IR instructions
  68  */
  69 class ir_instruction : public exec_node {
  70 public:
  71    enum ir_node_type ir_type;
  72    const struct glsl_type *type;
  73
  74    /** ir_print_visitor helper for debugging. */
  75    void print(void) const;
  76
  77    virtual void accept(ir_visitor *) = 0;
  78    virtual ir_visitor_status accept(ir_hierarchical_visitor *) = 0;
  79    virtual ir_instruction *clone(void *mem_ctx,
  80                                  struct hash_table *ht) const = 0;
  81
  82    /**
  83     * \name IR instruction downcast functions
  84     *
  85     * These functions either cast the object to a derived class or return
  86     * \c NULL if the object's type does not match the specified derived class.
  87     * Additional downcast functions will be added as needed.
  88     */
  89    /*@{*/
  90    virtual class ir_variable *          as_variable()         { return NULL; }
  91    virtual class ir_function *          as_function()         { return NULL; }
  92    virtual class ir_dereference *       as_dereference()      { return NULL; }
  93    virtual class ir_dereference_array * as_dereference_array() { return NULL; }
  94    virtual class ir_dereference_variable *as_dereference_variable() { return NULL; }
  95    virtual class ir_expression *        as_expression()       { return NULL; }
  96    virtual class ir_rvalue *            as_rvalue()           { return NULL; }
  97    virtual class ir_loop *              as_loop()             { return NULL; }
  98    virtual class ir_assignment *        as_assignment()       { return NULL; }
  99    virtual class ir_call *              as_call()             { return NULL; }
 100    virtual class ir_return *            as_return()           { return NULL; }
 101    virtual class ir_if *                as_if()               { return NULL; }
 102    virtual class ir_swizzle *           as_swizzle()          { return NULL; }
 103    virtual class ir_constant *          as_constant()         { return NULL; }
 104    /*@}*/
 105
 106 protected:
 107    ir_instruction()
 108    {
 109       ir_type = ir_type_unset;
 110       type = NULL;
 111    }
 112 };
 113
 114
 115 class ir_rvalue : public ir_instruction {
 116 public:
 117    virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const = 0;
 118
 119    virtual ir_constant *constant_expression_value() = 0;
 120
 121    virtual ir_rvalue * as_rvalue()
 122    {
 123       return this;
 124    }
 125
 126    virtual bool is_lvalue()
 127    {
 128       return false;
 129    }
 130
 131    /**
 132     * Get the variable that is ultimately referenced by an r-value
 133     */
 134    virtual ir_variable *variable_referenced()
 135    {
 136       return NULL;
 137    }
 138
 139
 140    /**
 141     * If an r-value is a reference to a whole variable, get that variable
 142     *
 143     * \return
 144     * Pointer to a variable that is completely dereferenced by the r-value.  If
 145     * the r-value is not a dereference or the dereference does not access the
 146     * entire variable (i.e., it's just one array element, struct field), \c NULL
 147     * is returned.
 148     */
 149    virtual ir_variable *whole_variable_referenced()
 150    {
 151       return NULL;
 152    }
 153
 154 protected:
 155    ir_rvalue();
 156 };
 157
 158
 159 enum ir_variable_mode {
 160    ir_var_auto = 0,
 161    ir_var_uniform,
 162    ir_var_in,
 163    ir_var_out,
 164    ir_var_inout,
 165    ir_var_temporary     /**< Temporary variable generated during compilation. */
 166 };
 167
 168 enum ir_variable_interpolation {
 169    ir_var_smooth = 0,
 170    ir_var_flat,
 171    ir_var_noperspective
 172 };
 173
 174
 175 class ir_variable : public ir_instruction {
 176 public:
 177    ir_variable(const struct glsl_type *, const char *, ir_variable_mode);
 178
 179    virtual ir_variable *clone(void *mem_ctx, struct hash_table *ht) const;
 180
 181    virtual ir_variable *as_variable()
 182    {
 183       return this;
 184    }
 185
 186    virtual void accept(ir_visitor *v)
 187    {
 188       v->visit(this);
 189    }
 190
 191    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 192
 193
 194    /**
 195     * Get the string value for the interpolation qualifier
 196     *
 197     * \return The string that would be used in a shader to specify \c
 198     * mode will be returned.
 199     *
 200     * This function should only be used on a shader input or output variable.
 201     */
 202    const char *interpolation_string() const;
 203
 204    /**
 205     * Calculate the number of slots required to hold this variable
 206     *
 207     * This is used to determine how many uniform or varying locations a variable
 208     * occupies.  The count is in units of floating point components.
 209     */
 210    unsigned component_slots() const;
 211
 212    const char *name;
 213
 214    /**
 215     * Highest element accessed with a constant expression array index
 216     *
 217     * Not used for non-array variables.
 218     */
 219    unsigned max_array_access;
 220
 221    unsigned read_only:1;
 222    unsigned centroid:1;
 223    unsigned invariant:1;
 224
 225    unsigned mode:3;
 226    unsigned interpolation:2;
 227
 228    /**
 229     * Flag that the whole array is assignable
 230     *
 231     * In GLSL 1.20 and later whole arrays are assignable (and comparable for
 232     * equality).  This flag enables this behavior.
 233     */
 234    unsigned array_lvalue:1;
 235
 236    /* ARB_fragment_coord_conventions */
 237    unsigned origin_upper_left:1;
 238    unsigned pixel_center_integer:1;
 239
 240    /**
 241     * Storage location of the base of this variable
 242     *
 243     * The precise meaning of this field depends on the nature of the variable.
 244     *
 245     *   - Vertex shader input: one of the values from \c gl_vert_attrib.
 246     *   - Vertex shader output: one of the values from \c gl_vert_result.
 247     *   - Fragment shader input: one of the values from \c gl_frag_attrib.
 248     *   - Fragment shader output: one of the values from \c gl_frag_result.
 249     *   - Uniforms: Per-stage uniform slot number.
 250     *   - Other: This field is not currently used.
 251     *
 252     * If the variable is a uniform, shader input, or shader output, and the
 253     * slot has not been assigned, the value will be -1.
 254     */
 255    int location;
 256
 257    /**
 258     * Emit a warning if this variable is accessed.
 259     */
 260    const char *warn_extension;
 261
 262    /**
 263     * Value assigned in the initializer of a variable declared "const"
 264     */
 265    ir_constant *constant_value;
 266 };
 267
 268
 269 /*@{*/
 270 /**
 271  * The representation of a function instance; may be the full definition or
 272  * simply a prototype.
 273  */
 274 class ir_function_signature : public ir_instruction {
 275    /* An ir_function_signature will be part of the list of signatures in
 276     * an ir_function.
 277     */
 278 public:
 279    ir_function_signature(const glsl_type *return_type);
 280
 281    virtual ir_function_signature *clone(void *mem_ctx,
 282                                         struct hash_table *ht) const;
 283
 284    virtual void accept(ir_visitor *v)
 285    {
 286       v->visit(this);
 287    }
 288
 289    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 290
 291    /**
 292     * Get the name of the function for which this is a signature
 293     */
 294    const char *function_name() const;
 295
 296    /**
 297     * Get a handle to the function for which this is a signature
 298     *
 299     * There is no setter function, this function returns a \c const pointer,
 300     * and \c ir_function_signature::_function is private for a reason.  The
 301     * only way to make a connection between a function and function signature
 302     * is via \c ir_function::add_signature.  This helps ensure that certain
 303     * invariants (i.e., a function signature is in the list of signatures for
 304     * its \c _function) are met.
 305     *
 306     * \sa ir_function::add_signature
 307     */
 308    inline const class ir_function *function() const
 309    {
 310       return this->_function;
 311    }
 312
 313    /**
 314     * Check whether the qualifiers match between this signature's parameters
 315     * and the supplied parameter list.  If not, returns the name of the first
 316     * parameter with mismatched qualifiers (for use in error messages).
 317     */
 318    const char *qualifiers_match(exec_list *params);
 319
 320    /**
 321     * Replace the current parameter list with the given one.  This is useful
 322     * if the current information came from a prototype, and either has invalid
 323     * or missing parameter names.
 324     */
 325    void replace_parameters(exec_list *new_params);
 326
 327    /**
 328     * Function return type.
 329     *
 330     * \note This discards the optional precision qualifier.
 331     */
 332    const struct glsl_type *return_type;
 333
 334    /**
 335     * List of ir_variable of function parameters.
 336     *
 337     * This represents the storage.  The paramaters passed in a particular
 338     * call will be in ir_call::actual_paramaters.
 339     */
 340    struct exec_list parameters;
 341
 342    /** Whether or not this function has a body (which may be empty). */
 343    unsigned is_defined:1;
 344
 345    /** Whether or not this function signature is a built-in. */
 346    unsigned is_builtin:1;
 347
 348    /** Body of instructions in the function. */
 349    struct exec_list body;
 350
 351 private:
 352    /** Function of which this signature is one overload. */
 353    class ir_function *_function;
 354
 355    friend class ir_function;
 356 };
 357
 358
 359 /**
 360  * Header for tracking multiple overloaded functions with the same name.
 361  * Contains a list of ir_function_signatures representing each of the
 362  * actual functions.
 363  */
 364 class ir_function : public ir_instruction {
 365 public:
 366    ir_function(const char *name);
 367
 368    virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const;
 369
 370    virtual ir_function *as_function()
 371    {
 372       return this;
 373    }
 374
 375    virtual void accept(ir_visitor *v)
 376    {
 377       v->visit(this);
 378    }
 379
 380    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 381
 382    void add_signature(ir_function_signature *sig)
 383    {
 384       sig->_function = this;
 385       this->signatures.push_tail(sig);
 386    }
 387
 388    /**
 389     * Get an iterator for the set of function signatures
 390     */
 391    exec_list_iterator iterator()
 392    {
 393       return signatures.iterator();
 394    }
 395
 396    /**
 397     * Find a signature that matches a set of actual parameters, taking implicit
 398     * conversions into account.
 399     */
 400    ir_function_signature *matching_signature(const exec_list *actual_param);
 401
 402    /**
 403     * Find a signature that exactly matches a set of actual parameters without
 404     * any implicit type conversions.
 405     */
 406    ir_function_signature *exact_matching_signature(const exec_list *actual_ps);
 407
 408    /**
 409     * Name of the function.
 410     */
 411    const char *name;
 412
 413    /** Whether or not this function has a signature that is a built-in. */
 414    bool has_builtin_signature();
 415
 416    /**
 417     * List of ir_function_signature for each overloaded function with this name.
 418     */
 419    struct exec_list signatures;
 420 };
 421
 422 inline const char *ir_function_signature::function_name() const
 423 {
 424    return this->_function->name;
 425 }
 426 /*@}*/
 427
 428
 429 /**
 430  * IR instruction representing high-level if-statements
 431  */
 432 class ir_if : public ir_instruction {
 433 public:
 434    ir_if(ir_rvalue *condition)
 435       : condition(condition)
 436    {
 437       ir_type = ir_type_if;
 438    }
 439
 440    virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const;
 441
 442    virtual ir_if *as_if()
 443    {
 444       return this;
 445    }
 446
 447    virtual void accept(ir_visitor *v)
 448    {
 449       v->visit(this);
 450    }
 451
 452    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 453
 454    ir_rvalue *condition;
 455    /** List of ir_instruction for the body of the then branch */
 456    exec_list  then_instructions;
 457    /** List of ir_instruction for the body of the else branch */
 458    exec_list  else_instructions;
 459 };
 460
 461
 462 /**
 463  * IR instruction representing a high-level loop structure.
 464  */
 465 class ir_loop : public ir_instruction {
 466 public:
 467    ir_loop();
 468
 469    virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const;
 470
 471    virtual void accept(ir_visitor *v)
 472    {
 473       v->visit(this);
 474    }
 475
 476    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 477
 478    virtual ir_loop *as_loop()
 479    {
 480       return this;
 481    }
 482
 483    /**
 484     * Get an iterator for the instructions of the loop body
 485     */
 486    exec_list_iterator iterator()
 487    {
 488       return body_instructions.iterator();
 489    }
 490
 491    /** List of ir_instruction that make up the body of the loop. */
 492    exec_list body_instructions;
 493
 494    /**
 495     * \name Loop counter and controls
 496     *
 497     * Represents a loop like a FORTRAN \c do-loop.
 498     *
 499     * \note
 500     * If \c from and \c to are the same value, the loop will execute once.
 501     */
 502    /*@{*/
 503    ir_rvalue *from;             /** Value of the loop counter on the first
 504                                  * iteration of the loop.
 505                                  */
 506    ir_rvalue *to;               /** Value of the loop counter on the last
 507                                  * iteration of the loop.
 508                                  */
 509    ir_rvalue *increment;
 510    ir_variable *counter;
 511
 512    /**
 513     * Comparison operation in the loop terminator.
 514     *
 515     * If any of the loop control fields are non-\c NULL, this field must be
 516     * one of \c ir_binop_less, \c ir_binop_greater, \c ir_binop_lequal,
 517     * \c ir_binop_gequal, \c ir_binop_equal, or \c ir_binop_nequal.
 518     */
 519    int cmp;
 520    /*@}*/
 521 };
 522
 523
 524 class ir_assignment : public ir_instruction {
 525 public:
 526    ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition);
 527
 528    /**
 529     * Construct an assignment with an explicit write mask
 530     *
 531     * \note
 532     * Since a write mask is supplied, the LHS must already be a bare
 533     * \c ir_dereference.  The cannot be any swizzles in the LHS.
 534     */
 535    ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, ir_rvalue *condition,
 536                  unsigned write_mask);
 537
 538    virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const;
 539
 540    virtual ir_constant *constant_expression_value();
 541
 542    virtual void accept(ir_visitor *v)
 543    {
 544       v->visit(this);
 545    }
 546
 547    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 548
 549    virtual ir_assignment * as_assignment()
 550    {
 551       return this;
 552    }
 553
 554    /**
 555     * Get a whole variable written by an assignment
 556     *
 557     * If the LHS of the assignment writes a whole variable, the variable is
 558     * returned.  Otherwise \c NULL is returned.  Examples of whole-variable
 559     * assignment are:
 560     *
 561     *  - Assigning to a scalar
 562     *  - Assigning to all components of a vector
 563     *  - Whole array (or matrix) assignment
 564     *  - Whole structure assignment
 565     */
 566    ir_variable *whole_variable_written();
 567
 568    /**
 569     * Set the LHS of an assignment
 570     */
 571    void set_lhs(ir_rvalue *lhs);
 572
 573    /**
 574     * Left-hand side of the assignment.
 575     *
 576     * This should be treated as read only.  If you need to set the LHS of an
 577     * assignment, use \c ir_assignment::set_lhs.
 578     */
 579    ir_dereference *lhs;
 580
 581    /**
 582     * Value being assigned
 583     */
 584    ir_rvalue *rhs;
 585
 586    /**
 587     * Optional condition for the assignment.
 588     */
 589    ir_rvalue *condition;
 590
 591
 592    /**
 593     * Component mask written
 594     *
 595     * For non-vector types in the LHS, this field will be zero.  For vector
 596     * types, a bit will be set for each component that is written.  Note that
 597     * for \c vec2 and \c vec3 types only the lower bits will ever be set.
 598     */
 599    unsigned write_mask:4;
 600 };
 601
 602 /* Update ir_expression::num_operands() and operator_strs when
 603  * updating this list.
 604  */
 605 enum ir_expression_operation {
 606    ir_unop_bit_not,
 607    ir_unop_logic_not,
 608    ir_unop_neg,
 609    ir_unop_abs,
 610    ir_unop_sign,
 611    ir_unop_rcp,
 612    ir_unop_rsq,
 613    ir_unop_sqrt,
 614    ir_unop_exp,      /**< Log base e on gentype */
 615    ir_unop_log,      /**< Natural log on gentype */
 616    ir_unop_exp2,
 617    ir_unop_log2,
 618    ir_unop_f2i,      /**< Float-to-integer conversion. */
 619    ir_unop_i2f,      /**< Integer-to-float conversion. */
 620    ir_unop_f2b,      /**< Float-to-boolean conversion */
 621    ir_unop_b2f,      /**< Boolean-to-float conversion */
 622    ir_unop_i2b,      /**< int-to-boolean conversion */
 623    ir_unop_b2i,      /**< Boolean-to-int conversion */
 624    ir_unop_u2f,      /**< Unsigned-to-float conversion. */
 625    ir_unop_any,
 626
 627    /**
 628     * \name Unary floating-point rounding operations.
 629     */
 630    /*@{*/
 631    ir_unop_trunc,
 632    ir_unop_ceil,
 633    ir_unop_floor,
 634    ir_unop_fract,
 635    /*@}*/
 636
 637    /**
 638     * \name Trigonometric operations.
 639     */
 640    /*@{*/
 641    ir_unop_sin,
 642    ir_unop_cos,
 643    /*@}*/
 644
 645    /**
 646     * \name Partial derivatives.
 647     */
 648    /*@{*/
 649    ir_unop_dFdx,
 650    ir_unop_dFdy,
 651    /*@}*/
 652
 653    ir_binop_add,
 654    ir_binop_sub,
 655    ir_binop_mul,
 656    ir_binop_div,
 657
 658    /**
 659     * Takes one of two combinations of arguments:
 660     *
 661     * - mod(vecN, vecN)
 662     * - mod(vecN, float)
 663     *
 664     * Does not take integer types.
 665     */
 666    ir_binop_mod,
 667
 668    /**
 669     * \name Binary comparison operators
 670     */
 671    /*@{*/
 672    ir_binop_less,
 673    ir_binop_greater,
 674    ir_binop_lequal,
 675    ir_binop_gequal,
 676    /**
 677     * Returns single boolean for whether all components of operands[0]
 678     * equal the components of operands[1].
 679     */
 680    ir_binop_equal,
 681    /**
 682     * Returns single boolean for whether any component of operands[0]
 683     * is not equal to the corresponding component of operands[1].
 684     */
 685    ir_binop_nequal,
 686    /*@}*/
 687
 688    /**
 689     * \name Bit-wise binary operations.
 690     */
 691    /*@{*/
 692    ir_binop_lshift,
 693    ir_binop_rshift,
 694    ir_binop_bit_and,
 695    ir_binop_bit_xor,
 696    ir_binop_bit_or,
 697    /*@}*/
 698
 699    ir_binop_logic_and,
 700    ir_binop_logic_xor,
 701    ir_binop_logic_or,
 702
 703    ir_binop_dot,
 704    ir_binop_cross,
 705    ir_binop_min,
 706    ir_binop_max,
 707
 708    ir_binop_pow
 709 };
 710
 711 class ir_expression : public ir_rvalue {
 712 public:
 713    ir_expression(int op, const struct glsl_type *type,
 714                  ir_rvalue *, ir_rvalue *);
 715
 716    virtual ir_expression *as_expression()
 717    {
 718       return this;
 719    }
 720
 721    virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const;
 722
 723    virtual ir_constant *constant_expression_value();
 724
 725    static unsigned int get_num_operands(ir_expression_operation);
 726    unsigned int get_num_operands() const
 727    {
 728       return get_num_operands(operation);
 729    }
 730
 731    /**
 732     * Return a string representing this expression's operator.
 733     */
 734    const char *operator_string();
 735
 736    /**
 737     * Return a string representing this expression's operator.
 738     */
 739    static const char *operator_string(ir_expression_operation);
 740
 741
 742    /**
 743     * Do a reverse-lookup to translate the given string into an operator.
 744     */
 745    static ir_expression_operation get_operator(const char *);
 746
 747    virtual void accept(ir_visitor *v)
 748    {
 749       v->visit(this);
 750    }
 751
 752    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 753
 754    ir_expression_operation operation;
 755    ir_rvalue *operands[2];
 756 };
 757
 758
 759 /**
 760  * IR instruction representing a function call
 761  */
 762 class ir_call : public ir_rvalue {
 763 public:
 764    ir_call(ir_function_signature *callee, exec_list *actual_parameters)
 765       : callee(callee)
 766    {
 767       ir_type = ir_type_call;
 768       assert(callee->return_type != NULL);
 769       type = callee->return_type;
 770       actual_parameters->move_nodes_to(& this->actual_parameters);
 771    }
 772
 773    virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const;
 774
 775    virtual ir_constant *constant_expression_value();
 776
 777    virtual ir_call *as_call()
 778    {
 779       return this;
 780    }
 781
 782    virtual void accept(ir_visitor *v)
 783    {
 784       v->visit(this);
 785    }
 786
 787    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 788
 789    /**
 790     * Get a generic ir_call object when an error occurs
 791     *
 792     * Any allocation will be performed with 'ctx' as talloc owner.
 793     */
 794    static ir_call *get_error_instruction(void *ctx);
 795
 796    /**
 797     * Get an iterator for the set of acutal parameters
 798     */
 799    exec_list_iterator iterator()
 800    {
 801       return actual_parameters.iterator();
 802    }
 803
 804    /**
 805     * Get the name of the function being called.
 806     */
 807    const char *callee_name() const
 808    {
 809       return callee->function_name();
 810    }
 811
 812    ir_function_signature *get_callee()
 813    {
 814       return callee;
 815    }
 816
 817    /**
 818     * Set the function call target
 819     */
 820    void set_callee(ir_function_signature *sig);
 821
 822    /**
 823     * Generates an inline version of the function before @ir,
 824     * returning the return value of the function.
 825     */
 826    ir_rvalue *generate_inline(ir_instruction *ir);
 827
 828    /* List of ir_rvalue of paramaters passed in this call. */
 829    exec_list actual_parameters;
 830
 831 private:
 832    ir_call()
 833       : callee(NULL)
 834    {
 835       this->ir_type = ir_type_call;
 836    }
 837
 838    ir_function_signature *callee;
 839 };
 840
 841
 842 /**
 843  * \name Jump-like IR instructions.
 844  *
 845  * These include \c break, \c continue, \c return, and \c discard.
 846  */
 847 /*@{*/
 848 class ir_jump : public ir_instruction {
 849 protected:
 850    ir_jump()
 851    {
 852       ir_type = ir_type_unset;
 853    }
 854 };
 855
 856 class ir_return : public ir_jump {
 857 public:
 858    ir_return()
 859       : value(NULL)
 860    {
 861       this->ir_type = ir_type_return;
 862    }
 863
 864    ir_return(ir_rvalue *value)
 865       : value(value)
 866    {
 867       this->ir_type = ir_type_return;
 868    }
 869
 870    virtual ir_return *clone(void *mem_ctx, struct hash_table *) const;
 871
 872    virtual ir_return *as_return()
 873    {
 874       return this;
 875    }
 876
 877    ir_rvalue *get_value() const
 878    {
 879       return value;
 880    }
 881
 882    virtual void accept(ir_visitor *v)
 883    {
 884       v->visit(this);
 885    }
 886
 887    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 888
 889    ir_rvalue *value;
 890 };
 891
 892
 893 /**
 894  * Jump instructions used inside loops
 895  *
 896  * These include \c break and \c continue.  The \c break within a loop is
 897  * different from the \c break within a switch-statement.
 898  *
 899  * \sa ir_switch_jump
 900  */
 901 class ir_loop_jump : public ir_jump {
 902 public:
 903    enum jump_mode {
 904       jump_break,
 905       jump_continue
 906    };
 907
 908    ir_loop_jump(jump_mode mode)
 909    {
 910       this->ir_type = ir_type_loop_jump;
 911       this->mode = mode;
 912       this->loop = loop;
 913    }
 914
 915    virtual ir_loop_jump *clone(void *mem_ctx, struct hash_table *) const;
 916
 917    virtual void accept(ir_visitor *v)
 918    {
 919       v->visit(this);
 920    }
 921
 922    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 923
 924    bool is_break() const
 925    {
 926       return mode == jump_break;
 927    }
 928
 929    bool is_continue() const
 930    {
 931       return mode == jump_continue;
 932    }
 933
 934    /** Mode selector for the jump instruction. */
 935    enum jump_mode mode;
 936 private:
 937    /** Loop containing this break instruction. */
 938    ir_loop *loop;
 939 };
 940
 941 /**
 942  * IR instruction representing discard statements.
 943  */
 944 class ir_discard : public ir_jump {
 945 public:
 946    ir_discard()
 947    {
 948       this->ir_type = ir_type_discard;
 949       this->condition = NULL;
 950    }
 951
 952    ir_discard(ir_rvalue *cond)
 953    {
 954       this->ir_type = ir_type_discard;
 955       this->condition = cond;
 956    }
 957
 958    virtual ir_discard *clone(void *mem_ctx, struct hash_table *ht) const;
 959
 960    virtual void accept(ir_visitor *v)
 961    {
 962       v->visit(this);
 963    }
 964
 965    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 966
 967    ir_rvalue *condition;
 968 };
 969 /*@}*/
 970
 971
 972 /**
 973  * Texture sampling opcodes used in ir_texture
 974  */
 975 enum ir_texture_opcode {
 976    ir_tex,              /* Regular texture look-up */
 977    ir_txb,              /* Texture look-up with LOD bias */
 978    ir_txl,              /* Texture look-up with explicit LOD */
 979    ir_txd,              /* Texture look-up with partial derivatvies */
 980    ir_txf               /* Texel fetch with explicit LOD */
 981 };
 982
 983
 984 /**
 985  * IR instruction to sample a texture
 986  *
 987  * The specific form of the IR instruction depends on the \c mode value
 988  * selected from \c ir_texture_opcodes.  In the printed IR, these will
 989  * appear as:
 990  *
 991  *                              Texel offset
 992  *                              |       Projection divisor
 993  *                              |       |   Shadow comparitor
 994  *                              |       |   |
 995  *                              v       v   v
 996  * (tex (sampler) (coordinate) (0 0 0) (1) ( ))
 997  * (txb (sampler) (coordinate) (0 0 0) (1) ( ) (bias))
 998  * (txl (sampler) (coordinate) (0 0 0) (1) ( ) (lod))
 999  * (txd (sampler) (coordinate) (0 0 0) (1) ( ) (dPdx dPdy))
1000  * (txf (sampler) (coordinate) (0 0 0)         (lod))
1001  */
1002 class ir_texture : public ir_rvalue {
1003 public:
1004    ir_texture(enum ir_texture_opcode op)
1005       : op(op), projector(NULL), shadow_comparitor(NULL)
1006    {
1007       this->ir_type = ir_type_texture;
1008    }
1009
1010    virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const;
1011
1012    virtual ir_constant *constant_expression_value();
1013
1014    virtual void accept(ir_visitor *v)
1015    {
1016       v->visit(this);
1017    }
1018
1019    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1020
1021    /**
1022     * Return a string representing the ir_texture_opcode.
1023     */
1024    const char *opcode_string();
1025
1026    /** Set the sampler and infer the type. */
1027    void set_sampler(ir_dereference *sampler);
1028
1029    /**
1030     * Do a reverse-lookup to translate a string into an ir_texture_opcode.
1031     */
1032    static ir_texture_opcode get_opcode(const char *);
1033
1034    enum ir_texture_opcode op;
1035
1036    /** Sampler to use for the texture access. */
1037    ir_dereference *sampler;
1038
1039    /** Texture coordinate to sample */
1040    ir_rvalue *coordinate;
1041
1042    /**
1043     * Value used for projective divide.
1044     *
1045     * If there is no projective divide (the common case), this will be
1046     * \c NULL.  Optimization passes should check for this to point to a constant
1047     * of 1.0 and replace that with \c NULL.
1048     */
1049    ir_rvalue *projector;
1050
1051    /**
1052     * Coordinate used for comparison on shadow look-ups.
1053     *
1054     * If there is no shadow comparison, this will be \c NULL.  For the
1055     * \c ir_txf opcode, this *must* be \c NULL.
1056     */
1057    ir_rvalue *shadow_comparitor;
1058
1059    /** Explicit texel offsets. */
1060    signed char offsets[3];
1061
1062    union {
1063       ir_rvalue *lod;           /**< Floating point LOD */
1064       ir_rvalue *bias;          /**< Floating point LOD bias */
1065       struct {
1066          ir_rvalue *dPdx;       /**< Partial derivative of coordinate wrt X */
1067          ir_rvalue *dPdy;       /**< Partial derivative of coordinate wrt Y */
1068       } grad;
1069    } lod_info;
1070 };
1071
1072
1073 struct ir_swizzle_mask {
1074    unsigned x:2;
1075    unsigned y:2;
1076    unsigned z:2;
1077    unsigned w:2;
1078
1079    /**
1080     * Number of components in the swizzle.
1081     */
1082    unsigned num_components:3;
1083
1084    /**
1085     * Does the swizzle contain duplicate components?
1086     *
1087     * L-value swizzles cannot contain duplicate components.
1088     */
1089    unsigned has_duplicates:1;
1090 };
1091
1092
1093 class ir_swizzle : public ir_rvalue {
1094 public:
1095    ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w,
1096               unsigned count);
1097
1098    ir_swizzle(ir_rvalue *val, const unsigned *components, unsigned count);
1099
1100    ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask);
1101
1102    virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const;
1103
1104    virtual ir_constant *constant_expression_value();
1105
1106    virtual ir_swizzle *as_swizzle()
1107    {
1108       return this;
1109    }
1110
1111    /**
1112     * Construct an ir_swizzle from the textual representation.  Can fail.
1113     */
1114    static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length);
1115
1116    virtual void accept(ir_visitor *v)
1117    {
1118       v->visit(this);
1119    }
1120
1121    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1122
1123    bool is_lvalue()
1124    {
1125       return val->is_lvalue() && !mask.has_duplicates;
1126    }
1127
1128    /**
1129     * Get the variable that is ultimately referenced by an r-value
1130     */
1131    virtual ir_variable *variable_referenced();
1132
1133    ir_rvalue *val;
1134    ir_swizzle_mask mask;
1135
1136 private:
1137    /**
1138     * Initialize the mask component of a swizzle
1139     *
1140     * This is used by the \c ir_swizzle constructors.
1141     */
1142    void init_mask(const unsigned *components, unsigned count);
1143 };
1144
1145
1146 class ir_dereference : public ir_rvalue {
1147 public:
1148    virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0;
1149
1150    virtual ir_dereference *as_dereference()
1151    {
1152       return this;
1153    }
1154
1155    bool is_lvalue();
1156
1157    /**
1158     * Get the variable that is ultimately referenced by an r-value
1159     */
1160    virtual ir_variable *variable_referenced() = 0;
1161 };
1162
1163
1164 class ir_dereference_variable : public ir_dereference {
1165 public:
1166    ir_dereference_variable(ir_variable *var);
1167
1168    virtual ir_dereference_variable *clone(void *mem_ctx,
1169                                           struct hash_table *) const;
1170
1171    virtual ir_constant *constant_expression_value();
1172
1173    virtual ir_dereference_variable *as_dereference_variable()
1174    {
1175       return this;
1176    }
1177
1178    /**
1179     * Get the variable that is ultimately referenced by an r-value
1180     */
1181    virtual ir_variable *variable_referenced()
1182    {
1183       return this->var;
1184    }
1185
1186    virtual ir_variable *whole_variable_referenced()
1187    {
1188       /* ir_dereference_variable objects always dereference the entire
1189        * variable.  However, if this dereference is dereferenced by anything
1190        * else, the complete deferefernce chain is not a whole-variable
1191        * dereference.  This method should only be called on the top most
1192        * ir_rvalue in a dereference chain.
1193        */
1194       return this->var;
1195    }
1196
1197    virtual void accept(ir_visitor *v)
1198    {
1199       v->visit(this);
1200    }
1201
1202    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1203
1204    /**
1205     * Object being dereferenced.
1206     */
1207    ir_variable *var;
1208 };
1209
1210
1211 class ir_dereference_array : public ir_dereference {
1212 public:
1213    ir_dereference_array(ir_rvalue *value, ir_rvalue *array_index);
1214
1215    ir_dereference_array(ir_variable *var, ir_rvalue *array_index);
1216
1217    virtual ir_dereference_array *clone(void *mem_ctx,
1218                                        struct hash_table *) const;
1219
1220    virtual ir_constant *constant_expression_value();
1221
1222    virtual ir_dereference_array *as_dereference_array()
1223    {
1224       return this;
1225    }
1226
1227    /**
1228     * Get the variable that is ultimately referenced by an r-value
1229     */
1230    virtual ir_variable *variable_referenced()
1231    {
1232       return this->array->variable_referenced();
1233    }
1234
1235    virtual void accept(ir_visitor *v)
1236    {
1237       v->visit(this);
1238    }
1239
1240    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1241
1242    ir_rvalue *array;
1243    ir_rvalue *array_index;
1244
1245 private:
1246    void set_array(ir_rvalue *value);
1247 };
1248
1249
1250 class ir_dereference_record : public ir_dereference {
1251 public:
1252    ir_dereference_record(ir_rvalue *value, const char *field);
1253
1254    ir_dereference_record(ir_variable *var, const char *field);
1255
1256    virtual ir_dereference_record *clone(void *mem_ctx,
1257                                         struct hash_table *) const;
1258
1259    virtual ir_constant *constant_expression_value();
1260
1261    /**
1262     * Get the variable that is ultimately referenced by an r-value
1263     */
1264    virtual ir_variable *variable_referenced()
1265    {
1266       return this->record->variable_referenced();
1267    }
1268
1269    virtual void accept(ir_visitor *v)
1270    {
1271       v->visit(this);
1272    }
1273
1274    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1275
1276    ir_rvalue *record;
1277    const char *field;
1278 };
1279
1280
1281 /**
1282  * Data stored in an ir_constant
1283  */
1284 union ir_constant_data {
1285       unsigned u[16];
1286       int i[16];
1287       float f[16];
1288       bool b[16];
1289 };
1290
1291
1292 class ir_constant : public ir_rvalue {
1293 public:
1294    ir_constant(const struct glsl_type *type, const ir_constant_data *data);
1295    ir_constant(bool b);
1296    ir_constant(unsigned int u);
1297    ir_constant(int i);
1298    ir_constant(float f);
1299
1300    /**
1301     * Construct an ir_constant from a list of ir_constant values
1302     */
1303    ir_constant(const struct glsl_type *type, exec_list *values);
1304
1305    /**
1306     * Construct an ir_constant from a scalar component of another ir_constant
1307     *
1308     * The new \c ir_constant inherits the type of the component from the
1309     * source constant.
1310     *
1311     * \note
1312     * In the case of a matrix constant, the new constant is a scalar, \b not
1313     * a vector.
1314     */
1315    ir_constant(const ir_constant *c, unsigned i);
1316
1317    /**
1318     * Return a new ir_constant of the specified type containing all zeros.
1319     */
1320    static ir_constant *zero(void *mem_ctx, const glsl_type *type);
1321
1322    virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const;
1323
1324    virtual ir_constant *constant_expression_value();
1325
1326    virtual ir_constant *as_constant()
1327    {
1328       return this;
1329    }
1330
1331    virtual void accept(ir_visitor *v)
1332    {
1333       v->visit(this);
1334    }
1335
1336    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1337
1338    /**
1339     * Get a particular component of a constant as a specific type
1340     *
1341     * This is useful, for example, to get a value from an integer constant
1342     * as a float or bool.  This appears frequently when constructors are
1343     * called with all constant parameters.
1344     */
1345    /*@{*/
1346    bool get_bool_component(unsigned i) const;
1347    float get_float_component(unsigned i) const;
1348    int get_int_component(unsigned i) const;
1349    unsigned get_uint_component(unsigned i) const;
1350    /*@}*/
1351
1352    ir_constant *get_array_element(unsigned i) const;
1353
1354    ir_constant *get_record_field(const char *name);
1355
1356    /**
1357     * Determine whether a constant has the same value as another constant
1358     */
1359    bool has_value(const ir_constant *) const;
1360
1361    /**
1362     * Value of the constant.
1363     *
1364     * The field used to back the values supplied by the constant is determined
1365     * by the type associated with the \c ir_instruction.  Constants may be
1366     * scalars, vectors, or matrices.
1367     */
1368    union ir_constant_data value;
1369
1370    /* Array elements */
1371    ir_constant **array_elements;
1372
1373    /* Structure fields */
1374    exec_list components;
1375
1376 private:
1377    /**
1378     * Parameterless constructor only used by the clone method
1379     */
1380    ir_constant(void);
1381 };
1382
1383 void
1384 visit_exec_list(exec_list *list, ir_visitor *visitor);
1385
1386 void validate_ir_tree(exec_list *instructions);
1387
1388 /**
1389  * Make a clone of each IR instruction in a list
1390  *
1391  * \param in   List of IR instructions that are to be cloned
1392  * \param out  List to hold the cloned instructions
1393  */
1394 void
1395 clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in);
1396
1397 extern void
1398 _mesa_glsl_initialize_variables(exec_list *instructions,
1399                                 struct _mesa_glsl_parse_state *state);
1400
1401 extern void
1402 _mesa_glsl_initialize_functions(exec_list *instructions,
1403                                 struct _mesa_glsl_parse_state *state);
1404
1405 extern void
1406 _mesa_glsl_release_functions(void);
1407
1408 extern void
1409 reparent_ir(exec_list *list, void *mem_ctx);
1410
1411 struct glsl_symbol_table;
1412
1413 extern void
1414 import_prototypes(const exec_list *source, exec_list *dest,
1415                   struct glsl_symbol_table *symbols, void *mem_ctx);
1416
1417 extern bool
1418 ir_has_call(ir_instruction *ir);
1419
1420 extern void
1421 do_set_program_inouts(exec_list *instructions, struct gl_program *prog);
1422
1423 #endif /* IR_H */