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
 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
 233    /**
 234     * \name Unary floating-point rounding operations.
 235     */
 236    /*@{*/
 237    ir_unop_trunc,
 238    ir_unop_ceil,
 239    ir_unop_floor,
 240    /*@}*/
 241
 242    ir_binop_add,
 243    ir_binop_sub,
 244    ir_binop_mul,
 245    ir_binop_div,
 246    ir_binop_mod,
 247
 248    /**
 249     * \name Binary comparison operators
 250     */
 251    /*@{*/
 252    ir_binop_less,
 253    ir_binop_greater,
 254    ir_binop_lequal,
 255    ir_binop_gequal,
 256    ir_binop_equal,
 257    ir_binop_nequal,
 258    /*@}*/
 259
 260    /**
 261     * \name Bit-wise binary operations.
 262     */
 263    /*@{*/
 264    ir_binop_lshift,
 265    ir_binop_rshift,
 266    ir_binop_bit_and,
 267    ir_binop_bit_xor,
 268    ir_binop_bit_or,
 269    /*@}*/
 270
 271    ir_binop_logic_and,
 272    ir_binop_logic_xor,
 273    ir_binop_logic_or,
 274    ir_binop_logic_not,
 275
 276    ir_binop_dot,
 277    ir_binop_min,
 278    ir_binop_max,
 279
 280    ir_binop_pow
 281 };
 282
 283 class ir_expression : public ir_rvalue {
 284 public:
 285    ir_expression(int op, const struct glsl_type *type,
 286                  ir_rvalue *, ir_rvalue *);
 287
 288    virtual void accept(ir_visitor *v)
 289    {
 290       v->visit(this);
 291    }
 292
 293    ir_expression_operation operation;
 294    ir_rvalue *operands[2];
 295 };
 296
 297
 298 /**
 299  * IR instruction representing a function call
 300  */
 301 class ir_call : public ir_rvalue {
 302 public:
 303    ir_call(const ir_function_signature *callee, exec_list *actual_parameters)
 304       : ir_rvalue(), callee(callee)
 305    {
 306       assert(callee->return_type != NULL);
 307       type = callee->return_type;
 308       actual_parameters->move_nodes_to(& this->actual_parameters);
 309    }
 310
 311    virtual void accept(ir_visitor *v)
 312    {
 313       v->visit(this);
 314    }
 315
 316    /**
 317     * Get a generic ir_call object when an error occurs
 318     */
 319    static ir_call *get_error_instruction();
 320
 321 private:
 322    ir_call()
 323       : ir_rvalue(), callee(NULL)
 324    {
 325       /* empty */
 326    }
 327
 328    const ir_function_signature *callee;
 329    exec_list actual_parameters;
 330 };
 331
 332
 333 /**
 334  * \name Jump-like IR instructions.
 335  *
 336  * These include \c break, \c continue, \c return, and \c discard.
 337  */
 338 /*@{*/
 339 class ir_jump : public ir_instruction {
 340 protected:
 341    ir_jump()
 342       : ir_instruction()
 343    {
 344       /* empty */
 345    }
 346 };
 347
 348 class ir_return : public ir_jump {
 349 public:
 350    ir_return()
 351       : value(NULL)
 352    {
 353       /* empty */
 354    }
 355
 356    ir_return(ir_rvalue *value)
 357       : value(value)
 358    {
 359       /* empty */
 360    }
 361
 362    ir_rvalue *get_value() const
 363    {
 364       return value;
 365    }
 366
 367    virtual void accept(ir_visitor *v)
 368    {
 369       v->visit(this);
 370    }
 371
 372 private:
 373    ir_rvalue *value;
 374 };
 375 /*@}*/
 376
 377
 378 struct ir_swizzle_mask {
 379    unsigned x:2;
 380    unsigned y:2;
 381    unsigned z:2;
 382    unsigned w:2;
 383
 384    /**
 385     * Number of components in the swizzle.
 386     */
 387    unsigned num_components:3;
 388
 389    /**
 390     * Does the swizzle contain duplicate components?
 391     *
 392     * L-value swizzles cannot contain duplicate components.
 393     */
 394    unsigned has_duplicates:1;
 395 };
 396
 397 class ir_dereference : public ir_rvalue {
 398 public:
 399    ir_dereference(struct ir_instruction *);
 400
 401    ir_dereference(ir_instruction *variable, ir_rvalue *array_index);
 402
 403    virtual ir_dereference *as_dereference()
 404    {
 405       return this;
 406    }
 407
 408    virtual void accept(ir_visitor *v)
 409    {
 410       v->visit(this);
 411    }
 412
 413    bool is_lvalue()
 414    {
 415       return var != NULL;
 416    }
 417
 418    /**
 419     * Setting the swizzle of a derefernce
 420     */
 421    void set_swizzle(unsigned x, unsigned y, unsigned z, unsigned w,
 422                     unsigned count);
 423
 424
 425    enum {
 426       ir_reference_variable,
 427       ir_reference_array,
 428       ir_reference_record
 429    } mode;
 430
 431    /**
 432     * Object being dereferenced.
 433     *
 434     * Must be either an \c ir_variable or an \c ir_rvalue.
 435     */
 436    ir_instruction *var;
 437
 438    union {
 439       ir_rvalue *array_index;
 440       const char *field;
 441       struct ir_swizzle_mask swizzle;
 442    } selector;
 443 };
 444
 445
 446 class ir_constant : public ir_rvalue {
 447 public:
 448    ir_constant(const struct glsl_type *type, const void *data);
 449
 450    virtual void accept(ir_visitor *v)
 451    {
 452       v->visit(this);
 453    }
 454
 455    /**
 456     * Value of the constant.
 457     *
 458     * The field used to back the values supplied by the constant is determined
 459     * by the type associated with the \c ir_instruction.  Constants may be
 460     * scalars, vectors, or matrices.
 461     */
 462    union {
 463       unsigned u[16];
 464       int i[16];
 465       float f[16];
 466       bool b[16];
 467    } value;
 468 };
 469
 470
 471 extern void
 472 _mesa_glsl_initialize_variables(exec_list *instructions,
 473                                 struct _mesa_glsl_parse_state *state);
 474
 475 #endif /* IR_H */