ir.cpp

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23 #include <string.h>
  24 #include "main/imports.h"
  25 #include "main/simple_list.h"
  26 #include "ir.h"
  27 #include "ir_visitor.h"
  28 #include "glsl_types.h"
  29
  30 ir_assignment::ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs,
  31                              ir_rvalue *condition)
  32 {
  33    this->lhs = lhs;
  34    this->rhs = rhs;
  35    this->condition = condition;
  36 }
  37
  38
  39 ir_expression::ir_expression(int op, const struct glsl_type *type,
  40                              ir_rvalue *op0, ir_rvalue *op1)
  41 {
  42    this->type = type;
  43    this->operation = ir_expression_operation(op);
  44    this->operands[0] = op0;
  45    this->operands[1] = op1;
  46 }
  47
  48 unsigned int
  49 ir_expression::get_num_operands(void)
  50 {
  51 /* Update ir_print_visitor.cpp when updating this list. */
  52    const int num_operands[] = {
  53       1, /* ir_unop_bit_not */
  54       1, /* ir_unop_logic_not */
  55       1, /* ir_unop_neg */
  56       1, /* ir_unop_abs */
  57       1, /* ir_unop_rcp */
  58       1, /* ir_unop_rsq */
  59       1, /* ir_unop_sqrt */
  60       1, /* ir_unop_exp */
  61       1, /* ir_unop_log */
  62       1, /* ir_unop_exp2 */
  63       1, /* ir_unop_log2 */
  64       1, /* ir_unop_f2i */
  65       1, /* ir_unop_i2f */
  66       1, /* ir_unop_f2b */
  67       1, /* ir_unop_b2f */
  68       1, /* ir_unop_i2b */
  69       1, /* ir_unop_b2i */
  70       1, /* ir_unop_u2f */
  71
  72       1, /* ir_unop_trunc */
  73       1, /* ir_unop_ceil */
  74       1, /* ir_unop_floor */
  75
  76       2, /* ir_binop_add */
  77       2, /* ir_binop_sub */
  78       2, /* ir_binop_mul */
  79       2, /* ir_binop_div */
  80       2, /* ir_binop_mod */
  81
  82       2, /* ir_binop_less */
  83       2, /* ir_binop_greater */
  84       2, /* ir_binop_lequal */
  85       2, /* ir_binop_gequal */
  86       2, /* ir_binop_equal */
  87       2, /* ir_binop_nequal */
  88
  89       2, /* ir_binop_lshift */
  90       2, /* ir_binop_rshift */
  91       2, /* ir_binop_bit_and */
  92       2, /* ir_binop_bit_xor */
  93       2, /* ir_binop_bit_or */
  94
  95       2, /* ir_binop_logic_and */
  96       2, /* ir_binop_logic_xor */
  97       2, /* ir_binop_logic_or */
  98
  99       2, /* ir_binop_dot */
 100       2, /* ir_binop_min */
 101       2, /* ir_binop_max */
 102
 103       2, /* ir_binop_pow */
 104    };
 105
 106    assert(sizeof(num_operands) / sizeof(num_operands[0]) == ir_binop_pow + 1);
 107
 108    return num_operands[this->operation];
 109 }
 110
 111 ir_label::ir_label(const char *label, ir_function_signature *signature)
 112    : label(label), signature(signature)
 113 {
 114    /* empty */
 115 }
 116
 117
 118 ir_constant::ir_constant(const struct glsl_type *type, const void *data)
 119 {
 120    unsigned size = 0;
 121
 122    this->type = type;
 123    switch (type->base_type) {
 124    case GLSL_TYPE_UINT:  size = sizeof(this->value.u[0]); break;
 125    case GLSL_TYPE_INT:   size = sizeof(this->value.i[0]); break;
 126    case GLSL_TYPE_FLOAT: size = sizeof(this->value.f[0]); break;
 127    case GLSL_TYPE_BOOL:  size = sizeof(this->value.b[0]); break;
 128    default:
 129       /* FINISHME: What to do?  Exceptions are not the answer.
 130        */
 131       break;
 132    }
 133
 134    memcpy(& this->value, data, size * type->components());
 135 }
 136
 137 ir_constant::ir_constant(float f)
 138 {
 139    this->type = glsl_type::float_type;
 140    this->value.f[0] = f;
 141 }
 142
 143 ir_constant::ir_constant(unsigned int u)
 144 {
 145    this->type = glsl_type::uint_type;
 146    this->value.u[0] = u;
 147 }
 148
 149 ir_constant::ir_constant(int i)
 150 {
 151    this->type = glsl_type::int_type;
 152    this->value.i[0] = i;
 153 }
 154
 155 ir_constant::ir_constant(bool b)
 156 {
 157    this->type = glsl_type::bool_type;
 158    this->value.b[0] = b;
 159 }
 160
 161
 162 ir_dereference::ir_dereference(ir_instruction *var)
 163 {
 164    this->mode = ir_reference_variable;
 165    this->var = var;
 166    this->type = (var != NULL) ? var->type : glsl_type::error_type;
 167 }
 168
 169
 170 ir_dereference::ir_dereference(ir_instruction *var,
 171                                ir_rvalue *array_index)
 172    : mode(ir_reference_array), var(var)
 173 {
 174    type = glsl_type::error_type;
 175
 176    if (var != NULL) {
 177       const glsl_type *const vt = var->type;
 178
 179       if (vt->is_array()) {
 180          type = vt->element_type();
 181       } else if (vt->is_matrix()) {
 182          type = vt->column_type();
 183       } else if (vt->is_vector()) {
 184          type = vt->get_base_type();
 185       }
 186    }
 187
 188    this->selector.array_index = array_index;
 189 }
 190
 191 bool
 192 ir_dereference::is_lvalue()
 193 {
 194    if (var == NULL)
 195       return false;
 196
 197    if (mode == ir_reference_variable) {
 198       ir_variable *const as_var = var->as_variable();
 199       if (as_var == NULL)
 200          return false;
 201
 202       if (as_var->type->is_array() && !as_var->array_lvalue)
 203          return false;
 204
 205       return !as_var->read_only;
 206    } else if (mode == ir_reference_array) {
 207       /* FINISHME: Walk up the dereference chain and figure out if
 208        * FINISHME: the variable is read-only.
 209        */
 210    }
 211
 212    return true;
 213 }
 214
 215 ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
 216                        unsigned w, unsigned count)
 217    : val(val)
 218 {
 219    assert((count >= 1) && (count <= 4));
 220
 221    const unsigned dup_mask = 0
 222       | ((count > 1) ? ((1U << y) & ((1U << x)                        )) : 0)
 223       | ((count > 2) ? ((1U << z) & ((1U << x) | (1U << y)            )) : 0)
 224       | ((count > 3) ? ((1U << w) & ((1U << x) | (1U << y) | (1U << z))) : 0);
 225
 226    assert(x <= 3);
 227    assert(y <= 3);
 228    assert(z <= 3);
 229    assert(w <= 3);
 230
 231    mask.x = x;
 232    mask.y = y;
 233    mask.z = z;
 234    mask.w = w;
 235    mask.num_components = count;
 236    mask.has_duplicates = dup_mask != 0;
 237
 238    /* Based on the number of elements in the swizzle and the base type
 239     * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
 240     * generate the type of the resulting value.
 241     */
 242    type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
 243 }
 244
 245 #define X 1
 246 #define R 5
 247 #define S 9
 248 #define I 13
 249
 250 ir_swizzle *
 251 ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
 252 {
 253    /* For each possible swizzle character, this table encodes the value in
 254     * \c idx_map that represents the 0th element of the vector.  For invalid
 255     * swizzle characters (e.g., 'k'), a special value is used that will allow
 256     * detection of errors.
 257     */
 258    static const unsigned char base_idx[26] = {
 259    /* a  b  c  d  e  f  g  h  i  j  k  l  m */
 260       R, R, I, I, I, I, R, I, I, I, I, I, I,
 261    /* n  o  p  q  r  s  t  u  v  w  x  y  z */
 262       I, I, S, S, R, S, S, I, I, X, X, X, X
 263    };
 264
 265    /* Each valid swizzle character has an entry in the previous table.  This
 266     * table encodes the base index encoded in the previous table plus the actual
 267     * index of the swizzle character.  When processing swizzles, the first
 268     * character in the string is indexed in the previous table.  Each character
 269     * in the string is indexed in this table, and the value found there has the
 270     * value form the first table subtracted.  The result must be on the range
 271     * [0,3].
 272     *
 273     * For example, the string "wzyx" will get X from the first table.  Each of
 274     * the charcaters will get X+3, X+2, X+1, and X+0 from this table.  After
 275     * subtraction, the swizzle values are { 3, 2, 1, 0 }.
 276     *
 277     * The string "wzrg" will get X from the first table.  Each of the characters
 278     * will get X+3, X+2, R+0, and R+1 from this table.  After subtraction, the
 279     * swizzle values are { 3, 2, 4, 5 }.  Since 4 and 5 are outside the range
 280     * [0,3], the error is detected.
 281     */
 282    static const unsigned char idx_map[26] = {
 283    /* a    b    c    d    e    f    g    h    i    j    k    l    m */
 284       R+3, R+2, 0,   0,   0,   0,   R+1, 0,   0,   0,   0,   0,   0,
 285    /* n    o    p    q    r    s    t    u    v    w    x    y    z */
 286       0,   0,   S+2, S+3, R+0, S+0, S+1, 0,   0,   X+3, X+0, X+1, X+2
 287    };
 288
 289    int swiz_idx[4] = { 0, 0, 0, 0 };
 290    unsigned i;
 291
 292
 293    /* Validate the first character in the swizzle string and look up the base
 294     * index value as described above.
 295     */
 296    if ((str[0] < 'a') || (str[0] > 'z'))
 297       return NULL;
 298
 299    const unsigned base = base_idx[str[0] - 'a'];
 300
 301
 302    for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
 303       /* Validate the next character, and, as described above, convert it to a
 304        * swizzle index.
 305        */
 306       if ((str[i] < 'a') || (str[i] > 'z'))
 307          return NULL;
 308
 309       swiz_idx[i] = idx_map[str[i] - 'a'] - base;
 310       if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
 311          return NULL;
 312    }
 313
 314    if (str[i] != '\0')
 315          return NULL;
 316
 317    return new ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
 318                          swiz_idx[3], i);
 319 }
 320
 321 #undef X
 322 #undef R
 323 #undef S
 324 #undef I
 325
 326
 327 ir_variable::ir_variable(const struct glsl_type *type, const char *name)
 328    : max_array_access(0), read_only(false), centroid(false), invariant(false),
 329      mode(ir_var_auto), interpolation(ir_var_smooth)
 330 {
 331    this->type = type;
 332    this->name = name;
 333    this->constant_value = NULL;
 334
 335    if (type && type->base_type == GLSL_TYPE_SAMPLER)
 336       this->read_only = true;
 337 }
 338
 339
 340 ir_function_signature::ir_function_signature(const glsl_type *return_type)
 341    : return_type(return_type), definition(NULL)
 342 {
 343    /* empty */
 344 }
 345
 346
 347 ir_function::ir_function(const char *name)
 348    : name(name)
 349 {
 350    /* empty */
 351 }
 352
 353
 354 ir_call *
 355 ir_call::get_error_instruction()
 356 {
 357    ir_call *call = new ir_call;
 358
 359    call->type = glsl_type::error_type;
 360    return call;
 361 }
 362
 363 void
 364 visit_exec_list(exec_list *list, ir_visitor *visitor)
 365 {
 366    foreach_iter(exec_list_iterator, iter, *list) {
 367       ((ir_instruction *)iter.get())->accept(visitor);
 368    }
 369 }
 370