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 "list.h"
  30 #include "ir_visitor.h"
  31
  32 struct ir_program {
  33    void *bong_hits;
  34 };
  35
  36 /**
  37  * Base class of all IR instructions
  38  */
  39 class ir_instruction : public exec_node {
  40 public:
  41    const struct glsl_type *type;
  42
  43    virtual void accept(ir_visitor *) = 0;
  44
  45    /**
  46     * \name IR instruction downcast functions
  47     *
  48     * These functions either cast the object to a derived class or return
  49     * \c NULL if the object's type does not match the specified derived class.
  50     * Additional downcast functions will be added as needed.
  51     */
  52    /*@{*/
  53    virtual class ir_variable *          as_variable()         { return NULL; }
  54    virtual class ir_dereference *       as_dereference()      { return NULL; }
  55    virtual class ir_rvalue *            as_rvalue()           { return NULL; }
  56    /*@}*/
  57
  58 protected:
  59    ir_instruction()
  60    {
  61       /* empty */
  62    }
  63 };
  64
  65
  66 class ir_rvalue : public ir_instruction {
  67 public:
  68    virtual ir_rvalue * as_rvalue()
  69    {
  70       return this;
  71    }
  72
  73    virtual bool is_lvalue()
  74    {
  75       return false;
  76    }
  77
  78 protected:
  79    ir_rvalue() : ir_instruction() { }
  80 };
  81
  82
  83 enum ir_variable_mode {
  84    ir_var_auto = 0,
  85    ir_var_uniform,
  86    ir_var_in,
  87    ir_var_out,
  88    ir_var_inout
  89 };
  90
  91 enum ir_varaible_interpolation {
  92    ir_var_smooth = 0,
  93    ir_var_flat,
  94    ir_var_noperspective
  95 };
  96
  97
  98 class ir_variable : public ir_instruction {
  99 public:
 100    ir_variable(const struct glsl_type *, const char *);
 101
 102    virtual ir_variable *as_variable()
 103    {
 104       return this;
 105    }
 106
 107    virtual void accept(ir_visitor *v)
 108    {
 109       v->visit(this);
 110    }
 111
 112    const char *name;
 113
 114    unsigned read_only:1;
 115    unsigned centroid:1;
 116    unsigned invariant:1;
 117
 118    unsigned mode:3;
 119    unsigned interpolation:2;
 120 };
 121
 122
 123 class ir_label : public ir_instruction {
 124 public:
 125    ir_label(const char *label);
 126
 127    virtual void accept(ir_visitor *v)
 128    {
 129       v->visit(this);
 130    }
 131
 132    const char *label;
 133 };
 134
 135
 136 /*@{*/
 137 class ir_function_signature : public ir_instruction {
 138 public:
 139    ir_function_signature(const glsl_type *return_type);
 140
 141    virtual void accept(ir_visitor *v)
 142    {
 143       v->visit(this);
 144    }
 145
 146    /**
 147     * Function return type.
 148     *
 149     * \note This discards the optional precision qualifier.
 150     */
 151    const struct glsl_type *return_type;
 152
 153    /**
 154     * List of function parameters stored as ir_variable objects.
 155     */
 156    struct exec_list parameters;
 157
 158    /**
 159     * Pointer to the label that begins the function definition.
 160     */
 161    ir_label *definition;
 162 };
 163
 164
 165 /**
 166  * Header for tracking functions in the symbol table
 167  */
 168 class ir_function : public ir_instruction {
 169 public:
 170    ir_function(const char *name);
 171
 172    virtual void accept(ir_visitor *v)
 173    {
 174       v->visit(this);
 175    }
 176
 177    /**
 178     * Find a signature that matches a set of actual parameters.
 179     */
 180    const ir_function_signature *matching_signature(exec_list *actual_param);
 181
 182    /**
 183     * Name of the function.
 184     */
 185    const char *name;
 186
 187    /**
 188     * Set of overloaded functions with this name.
 189     */
 190    struct exec_list signatures;
 191 };
 192 /*@}*/
 193
 194
 195 class ir_assignment : public ir_rvalue {
 196 public:
 197    ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition);
 198
 199    virtual void accept(ir_visitor *v)
 200    {
 201       v->visit(this);
 202    }
 203
 204    /**
 205     * Left-hand side of the assignment.
 206     */
 207    ir_rvalue *lhs;
 208
 209    /**
 210     * Value being assigned
 211     */
 212    ir_rvalue *rhs;
 213
 214    /**
 215     * Optional condition for the assignment.
 216     */
 217    ir_rvalue *condition;
 218 };
 219
 220 /* Update ir_print_visitor.cpp when updating this list. */
 221 enum ir_expression_operation {
 222    ir_unop_bit_not,
 223    ir_unop_logic_not,
 224    ir_unop_neg,
 225    ir_unop_abs,
 226    ir_unop_rcp,
 227    ir_unop_rsq,
 228    ir_unop_exp,
 229    ir_unop_log,
 230    ir_unop_f2i,      /**< Float-to-integer conversion. */
 231    ir_unop_i2f,      /**< Integer-to-float conversion. */
 232    ir_unop_u2f,      /**< Unsigned-to-float conversion. */
 233
 234    /**
 235     * \name Unary floating-point rounding operations.
 236     */
 237    /*@{*/
 238    ir_unop_trunc,
 239    ir_unop_ceil,
 240    ir_unop_floor,
 241    /*@}*/
 242
 243    ir_binop_add,
 244    ir_binop_sub,
 245    ir_binop_mul,
 246    ir_binop_div,
 247    ir_binop_mod,
 248
 249    /**
 250     * \name Binary comparison operators
 251     */
 252    /*@{*/
 253    ir_binop_less,
 254    ir_binop_greater,
 255    ir_binop_lequal,
 256    ir_binop_gequal,
 257    ir_binop_equal,
 258    ir_binop_nequal,
 259    /*@}*/
 260
 261    /**
 262     * \name Bit-wise binary operations.
 263     */
 264    /*@{*/
 265    ir_binop_lshift,
 266    ir_binop_rshift,
 267    ir_binop_bit_and,
 268    ir_binop_bit_xor,
 269    ir_binop_bit_or,
 270    /*@}*/
 271
 272    ir_binop_logic_and,
 273    ir_binop_logic_xor,
 274    ir_binop_logic_or,
 275    ir_binop_logic_not,
 276
 277    ir_binop_dot,
 278    ir_binop_min,
 279    ir_binop_max,
 280
 281    ir_binop_pow
 282 };
 283
 284 class ir_expression : public ir_rvalue {
 285 public:
 286    ir_expression(int op, const struct glsl_type *type,
 287                  ir_rvalue *, ir_rvalue *);
 288
 289    virtual void accept(ir_visitor *v)
 290    {
 291       v->visit(this);
 292    }
 293
 294    ir_expression_operation operation;
 295    ir_rvalue *operands[2];
 296 };
 297
 298
 299 /**
 300  * IR instruction representing a function call
 301  */
 302 class ir_call : public ir_rvalue {
 303 public:
 304    ir_call(const ir_function_signature *callee, exec_list *actual_parameters)
 305       : ir_rvalue(), callee(callee)
 306    {
 307       assert(callee->return_type != NULL);
 308       type = callee->return_type;
 309       actual_parameters->move_nodes_to(& this->actual_parameters);
 310    }
 311
 312    virtual void accept(ir_visitor *v)
 313    {
 314       v->visit(this);
 315    }
 316
 317    /**
 318     * Get a generic ir_call object when an error occurs
 319     */
 320    static ir_call *get_error_instruction();
 321
 322    /**
 323     * Get an iterator for the set of acutal parameters
 324     */
 325    exec_list_iterator iterator()
 326    {
 327       return actual_parameters.iterator();
 328    }
 329
 330    /**
 331     * Get the name of the function being called.
 332     */
 333    const char *callee_name() const
 334    {
 335       /* FINISHME: This only works for functions that have definitions. */
 336       return callee->definition->label;
 337    }
 338
 339 private:
 340    ir_call()
 341       : ir_rvalue(), callee(NULL)
 342    {
 343       /* empty */
 344    }
 345
 346    const ir_function_signature *callee;
 347    exec_list actual_parameters;
 348 };
 349
 350
 351 /**
 352  * \name Jump-like IR instructions.
 353  *
 354  * These include \c break, \c continue, \c return, and \c discard.
 355  */
 356 /*@{*/
 357 class ir_jump : public ir_instruction {
 358 protected:
 359    ir_jump()
 360       : ir_instruction()
 361    {
 362       /* empty */
 363    }
 364 };
 365
 366 class ir_return : public ir_jump {
 367 public:
 368    ir_return()
 369       : value(NULL)
 370    {
 371       /* empty */
 372    }
 373
 374    ir_return(ir_rvalue *value)
 375       : value(value)
 376    {
 377       /* empty */
 378    }
 379
 380    ir_rvalue *get_value() const
 381    {
 382       return value;
 383    }
 384
 385    virtual void accept(ir_visitor *v)
 386    {
 387       v->visit(this);
 388    }
 389
 390 private:
 391    ir_rvalue *value;
 392 };
 393 /*@}*/
 394
 395
 396 struct ir_swizzle_mask {
 397    unsigned x:2;
 398    unsigned y:2;
 399    unsigned z:2;
 400    unsigned w:2;
 401
 402    /**
 403     * Number of components in the swizzle.
 404     */
 405    unsigned num_components:3;
 406
 407    /**
 408     * Does the swizzle contain duplicate components?
 409     *
 410     * L-value swizzles cannot contain duplicate components.
 411     */
 412    unsigned has_duplicates:1;
 413 };
 414
 415
 416 class ir_swizzle : public ir_rvalue {
 417 public:
 418    ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w,
 419               unsigned count);
 420    /**
 421     * Construct an ir_swizzle from the textual representation.  Can fail.
 422     */
 423    static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length);
 424
 425    virtual void accept(ir_visitor *v)
 426    {
 427       v->visit(this);
 428    }
 429
 430    bool is_lvalue()
 431    {
 432       return val->is_lvalue();
 433    }
 434
 435    ir_rvalue *val;
 436    ir_swizzle_mask mask;
 437 };
 438
 439
 440 class ir_dereference : public ir_rvalue {
 441 public:
 442    ir_dereference(struct ir_instruction *);
 443
 444    ir_dereference(ir_instruction *variable, ir_rvalue *array_index);
 445
 446    virtual ir_dereference *as_dereference()
 447    {
 448       return this;
 449    }
 450
 451    virtual void accept(ir_visitor *v)
 452    {
 453       v->visit(this);
 454    }
 455
 456    bool is_lvalue()
 457    {
 458       ir_variable *as_var;
 459
 460       if (var == NULL)
 461          return NULL;
 462
 463       as_var = var->as_variable();
 464
 465       if (as_var == NULL)
 466          return NULL;
 467
 468       return !as_var->read_only;
 469    }
 470
 471    enum {
 472       ir_reference_variable,
 473       ir_reference_array,
 474       ir_reference_record
 475    } mode;
 476
 477    /**
 478     * Object being dereferenced.
 479     *
 480     * Must be either an \c ir_variable or an \c ir_rvalue.
 481     */
 482    ir_instruction *var;
 483
 484    union {
 485       ir_rvalue *array_index;
 486       const char *field;
 487    } selector;
 488 };
 489
 490
 491 class ir_constant : public ir_rvalue {
 492 public:
 493    ir_constant(const struct glsl_type *type, const void *data);
 494    ir_constant(bool b);
 495    ir_constant(unsigned int u);
 496    ir_constant(int i);
 497    ir_constant(float f);
 498
 499    virtual void accept(ir_visitor *v)
 500    {
 501       v->visit(this);
 502    }
 503
 504    /**
 505     * Value of the constant.
 506     *
 507     * The field used to back the values supplied by the constant is determined
 508     * by the type associated with the \c ir_instruction.  Constants may be
 509     * scalars, vectors, or matrices.
 510     */
 511    union {
 512       unsigned u[16];
 513       int i[16];
 514       float f[16];
 515       bool b[16];
 516    } value;
 517 };
 518
 519
 520 extern void
 521 _mesa_glsl_initialize_variables(exec_list *instructions,
 522                                 struct _mesa_glsl_parse_state *state);
 523
 524 #endif /* IR_H */