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