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