"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/compiler/glsl/ir_builder.cpp" (16 Sep 2020, 11482 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "ir_builder.cpp" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * Copyright © 2012 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 DEALINGS
   21  * IN THE SOFTWARE.
   22  */
   23 
   24 #include "ir_builder.h"
   25 #include "program/prog_instruction.h"
   26 
   27 using namespace ir_builder;
   28 
   29 namespace ir_builder {
   30 
   31 void
   32 ir_factory::emit(ir_instruction *ir)
   33 {
   34    instructions->push_tail(ir);
   35 }
   36 
   37 ir_variable *
   38 ir_factory::make_temp(const glsl_type *type, const char *name)
   39 {
   40    ir_variable *var;
   41 
   42    var = new(mem_ctx) ir_variable(type, name, ir_var_temporary);
   43    emit(var);
   44 
   45    return var;
   46 }
   47 
   48 ir_assignment *
   49 assign(deref lhs, operand rhs, operand condition, int writemask)
   50 {
   51    void *mem_ctx = ralloc_parent(lhs.val);
   52 
   53    ir_assignment *assign = new(mem_ctx) ir_assignment(lhs.val,
   54                                                       rhs.val,
   55                                                       condition.val,
   56                                                       writemask);
   57 
   58    return assign;
   59 }
   60 
   61 ir_assignment *
   62 assign(deref lhs, operand rhs)
   63 {
   64    return assign(lhs, rhs, (1 << lhs.val->type->vector_elements) - 1);
   65 }
   66 
   67 ir_assignment *
   68 assign(deref lhs, operand rhs, int writemask)
   69 {
   70    return assign(lhs, rhs, (ir_rvalue *) NULL, writemask);
   71 }
   72 
   73 ir_assignment *
   74 assign(deref lhs, operand rhs, operand condition)
   75 {
   76    return assign(lhs, rhs, condition, (1 << lhs.val->type->vector_elements) - 1);
   77 }
   78 
   79 ir_return *
   80 ret(operand retval)
   81 {
   82    void *mem_ctx = ralloc_parent(retval.val);
   83    return new(mem_ctx) ir_return(retval.val);
   84 }
   85 
   86 ir_swizzle *
   87 swizzle(operand a, int swizzle, int components)
   88 {
   89    void *mem_ctx = ralloc_parent(a.val);
   90 
   91    return new(mem_ctx) ir_swizzle(a.val,
   92                                   GET_SWZ(swizzle, 0),
   93                                   GET_SWZ(swizzle, 1),
   94                                   GET_SWZ(swizzle, 2),
   95                                   GET_SWZ(swizzle, 3),
   96                                   components);
   97 }
   98 
   99 ir_swizzle *
  100 swizzle_for_size(operand a, unsigned components)
  101 {
  102    void *mem_ctx = ralloc_parent(a.val);
  103 
  104    if (a.val->type->vector_elements < components)
  105       components = a.val->type->vector_elements;
  106 
  107    unsigned s[4] = { 0, 1, 2, 3 };
  108    for (int i = components; i < 4; i++)
  109       s[i] = components - 1;
  110 
  111    return new(mem_ctx) ir_swizzle(a.val, s, components);
  112 }
  113 
  114 ir_swizzle *
  115 swizzle_xxxx(operand a)
  116 {
  117    return swizzle(a, SWIZZLE_XXXX, 4);
  118 }
  119 
  120 ir_swizzle *
  121 swizzle_yyyy(operand a)
  122 {
  123    return swizzle(a, SWIZZLE_YYYY, 4);
  124 }
  125 
  126 ir_swizzle *
  127 swizzle_zzzz(operand a)
  128 {
  129    return swizzle(a, SWIZZLE_ZZZZ, 4);
  130 }
  131 
  132 ir_swizzle *
  133 swizzle_wwww(operand a)
  134 {
  135    return swizzle(a, SWIZZLE_WWWW, 4);
  136 }
  137 
  138 ir_swizzle *
  139 swizzle_x(operand a)
  140 {
  141    return swizzle(a, SWIZZLE_XXXX, 1);
  142 }
  143 
  144 ir_swizzle *
  145 swizzle_y(operand a)
  146 {
  147    return swizzle(a, SWIZZLE_YYYY, 1);
  148 }
  149 
  150 ir_swizzle *
  151 swizzle_z(operand a)
  152 {
  153    return swizzle(a, SWIZZLE_ZZZZ, 1);
  154 }
  155 
  156 ir_swizzle *
  157 swizzle_w(operand a)
  158 {
  159    return swizzle(a, SWIZZLE_WWWW, 1);
  160 }
  161 
  162 ir_swizzle *
  163 swizzle_xy(operand a)
  164 {
  165    return swizzle(a, SWIZZLE_XYZW, 2);
  166 }
  167 
  168 ir_swizzle *
  169 swizzle_xyz(operand a)
  170 {
  171    return swizzle(a, SWIZZLE_XYZW, 3);
  172 }
  173 
  174 ir_swizzle *
  175 swizzle_xyzw(operand a)
  176 {
  177    return swizzle(a, SWIZZLE_XYZW, 4);
  178 }
  179 
  180 ir_expression *
  181 expr(ir_expression_operation op, operand a)
  182 {
  183    void *mem_ctx = ralloc_parent(a.val);
  184 
  185    return new(mem_ctx) ir_expression(op, a.val);
  186 }
  187 
  188 ir_expression *
  189 expr(ir_expression_operation op, operand a, operand b)
  190 {
  191    void *mem_ctx = ralloc_parent(a.val);
  192 
  193    return new(mem_ctx) ir_expression(op, a.val, b.val);
  194 }
  195 
  196 ir_expression *
  197 expr(ir_expression_operation op, operand a, operand b, operand c)
  198 {
  199    void *mem_ctx = ralloc_parent(a.val);
  200 
  201    return new(mem_ctx) ir_expression(op, a.val, b.val, c.val);
  202 }
  203 
  204 ir_expression *add(operand a, operand b)
  205 {
  206    return expr(ir_binop_add, a, b);
  207 }
  208 
  209 ir_expression *sub(operand a, operand b)
  210 {
  211    return expr(ir_binop_sub, a, b);
  212 }
  213 
  214 ir_expression *min2(operand a, operand b)
  215 {
  216    return expr(ir_binop_min, a, b);
  217 }
  218 
  219 ir_expression *max2(operand a, operand b)
  220 {
  221    return expr(ir_binop_max, a, b);
  222 }
  223 
  224 ir_expression *mul(operand a, operand b)
  225 {
  226    return expr(ir_binop_mul, a, b);
  227 }
  228 
  229 ir_expression *imul_high(operand a, operand b)
  230 {
  231    return expr(ir_binop_imul_high, a, b);
  232 }
  233 
  234 ir_expression *div(operand a, operand b)
  235 {
  236    return expr(ir_binop_div, a, b);
  237 }
  238 
  239 ir_expression *carry(operand a, operand b)
  240 {
  241    return expr(ir_binop_carry, a, b);
  242 }
  243 
  244 ir_expression *borrow(operand a, operand b)
  245 {
  246    return expr(ir_binop_borrow, a, b);
  247 }
  248 
  249 ir_expression *trunc(operand a)
  250 {
  251    return expr(ir_unop_trunc, a);
  252 }
  253 
  254 ir_expression *round_even(operand a)
  255 {
  256    return expr(ir_unop_round_even, a);
  257 }
  258 
  259 ir_expression *fract(operand a)
  260 {
  261    return expr(ir_unop_fract, a);
  262 }
  263 
  264 /* dot for vectors, mul for scalars */
  265 ir_expression *dot(operand a, operand b)
  266 {
  267    assert(a.val->type == b.val->type);
  268 
  269    if (a.val->type->vector_elements == 1)
  270       return expr(ir_binop_mul, a, b);
  271 
  272    return expr(ir_binop_dot, a, b);
  273 }
  274 
  275 ir_expression*
  276 clamp(operand a, operand b, operand c)
  277 {
  278    return expr(ir_binop_min, expr(ir_binop_max, a, b), c);
  279 }
  280 
  281 ir_expression *
  282 saturate(operand a)
  283 {
  284    return expr(ir_unop_saturate, a);
  285 }
  286 
  287 ir_expression *
  288 abs(operand a)
  289 {
  290    return expr(ir_unop_abs, a);
  291 }
  292 
  293 ir_expression *
  294 neg(operand a)
  295 {
  296    return expr(ir_unop_neg, a);
  297 }
  298 
  299 ir_expression *
  300 sin(operand a)
  301 {
  302    return expr(ir_unop_sin, a);
  303 }
  304 
  305 ir_expression *
  306 cos(operand a)
  307 {
  308    return expr(ir_unop_cos, a);
  309 }
  310 
  311 ir_expression *
  312 exp(operand a)
  313 {
  314    return expr(ir_unop_exp, a);
  315 }
  316 
  317 ir_expression *
  318 rcp(operand a)
  319 {
  320    return expr(ir_unop_rcp, a);
  321 }
  322 
  323 ir_expression *
  324 rsq(operand a)
  325 {
  326    return expr(ir_unop_rsq, a);
  327 }
  328 
  329 ir_expression *
  330 sqrt(operand a)
  331 {
  332    return expr(ir_unop_sqrt, a);
  333 }
  334 
  335 ir_expression *
  336 log(operand a)
  337 {
  338    return expr(ir_unop_log, a);
  339 }
  340 
  341 ir_expression *
  342 sign(operand a)
  343 {
  344    return expr(ir_unop_sign, a);
  345 }
  346 
  347 ir_expression *
  348 subr_to_int(operand a)
  349 {
  350    return expr(ir_unop_subroutine_to_int, a);
  351 }
  352 
  353 ir_expression*
  354 equal(operand a, operand b)
  355 {
  356    return expr(ir_binop_equal, a, b);
  357 }
  358 
  359 ir_expression*
  360 nequal(operand a, operand b)
  361 {
  362    return expr(ir_binop_nequal, a, b);
  363 }
  364 
  365 ir_expression*
  366 less(operand a, operand b)
  367 {
  368    return expr(ir_binop_less, a, b);
  369 }
  370 
  371 ir_expression*
  372 greater(operand a, operand b)
  373 {
  374    return expr(ir_binop_less, b, a);
  375 }
  376 
  377 ir_expression*
  378 lequal(operand a, operand b)
  379 {
  380    return expr(ir_binop_gequal, b, a);
  381 }
  382 
  383 ir_expression*
  384 gequal(operand a, operand b)
  385 {
  386    return expr(ir_binop_gequal, a, b);
  387 }
  388 
  389 ir_expression*
  390 logic_not(operand a)
  391 {
  392    return expr(ir_unop_logic_not, a);
  393 }
  394 
  395 ir_expression*
  396 logic_and(operand a, operand b)
  397 {
  398    return expr(ir_binop_logic_and, a, b);
  399 }
  400 
  401 ir_expression*
  402 logic_or(operand a, operand b)
  403 {
  404    return expr(ir_binop_logic_or, a, b);
  405 }
  406 
  407 ir_expression*
  408 bit_not(operand a)
  409 {
  410    return expr(ir_unop_bit_not, a);
  411 }
  412 
  413 ir_expression*
  414 bit_and(operand a, operand b)
  415 {
  416    return expr(ir_binop_bit_and, a, b);
  417 }
  418 
  419 ir_expression*
  420 bit_or(operand a, operand b)
  421 {
  422    return expr(ir_binop_bit_or, a, b);
  423 }
  424 
  425 ir_expression*
  426 bit_xor(operand a, operand b)
  427 {
  428    return expr(ir_binop_bit_xor, a, b);
  429 }
  430 
  431 ir_expression*
  432 lshift(operand a, operand b)
  433 {
  434    return expr(ir_binop_lshift, a, b);
  435 }
  436 
  437 ir_expression*
  438 rshift(operand a, operand b)
  439 {
  440    return expr(ir_binop_rshift, a, b);
  441 }
  442 
  443 ir_expression*
  444 f2i(operand a)
  445 {
  446    return expr(ir_unop_f2i, a);
  447 }
  448 
  449 ir_expression*
  450 bitcast_f2i(operand a)
  451 {
  452    return expr(ir_unop_bitcast_f2i, a);
  453 }
  454 
  455 ir_expression*
  456 i2f(operand a)
  457 {
  458    return expr(ir_unop_i2f, a);
  459 }
  460 
  461 ir_expression*
  462 bitcast_i2f(operand a)
  463 {
  464    return expr(ir_unop_bitcast_i2f, a);
  465 }
  466 
  467 ir_expression*
  468 i2u(operand a)
  469 {
  470    return expr(ir_unop_i2u, a);
  471 }
  472 
  473 ir_expression*
  474 u2i(operand a)
  475 {
  476    return expr(ir_unop_u2i, a);
  477 }
  478 
  479 ir_expression*
  480 f2u(operand a)
  481 {
  482    return expr(ir_unop_f2u, a);
  483 }
  484 
  485 ir_expression*
  486 bitcast_f2u(operand a)
  487 {
  488    return expr(ir_unop_bitcast_f2u, a);
  489 }
  490 
  491 ir_expression*
  492 u2f(operand a)
  493 {
  494    return expr(ir_unop_u2f, a);
  495 }
  496 
  497 ir_expression*
  498 bitcast_u2f(operand a)
  499 {
  500    return expr(ir_unop_bitcast_u2f, a);
  501 }
  502 
  503 ir_expression*
  504 i2b(operand a)
  505 {
  506    return expr(ir_unop_i2b, a);
  507 }
  508 
  509 ir_expression*
  510 b2i(operand a)
  511 {
  512    return expr(ir_unop_b2i, a);
  513 }
  514 
  515 ir_expression *
  516 f2b(operand a)
  517 {
  518    return expr(ir_unop_f2b, a);
  519 }
  520 
  521 ir_expression *
  522 b2f(operand a)
  523 {
  524    return expr(ir_unop_b2f, a);
  525 }
  526 
  527 ir_expression*
  528 bitcast_d2i64(operand a)
  529 {
  530    return expr(ir_unop_bitcast_d2i64, a);
  531 }
  532 
  533 ir_expression*
  534 bitcast_d2u64(operand a)
  535 {
  536    return expr(ir_unop_bitcast_d2u64, a);
  537 }
  538 
  539 ir_expression*
  540 bitcast_i642d(operand a)
  541 {
  542    return expr(ir_unop_bitcast_i642d, a);
  543 }
  544 
  545 ir_expression*
  546 bitcast_u642d(operand a)
  547 {
  548    return expr(ir_unop_bitcast_u642d, a);
  549 }
  550 
  551 ir_expression *
  552 interpolate_at_centroid(operand a)
  553 {
  554    return expr(ir_unop_interpolate_at_centroid, a);
  555 }
  556 
  557 ir_expression *
  558 interpolate_at_offset(operand a, operand b)
  559 {
  560    return expr(ir_binop_interpolate_at_offset, a, b);
  561 }
  562 
  563 ir_expression *
  564 interpolate_at_sample(operand a, operand b)
  565 {
  566    return expr(ir_binop_interpolate_at_sample, a, b);
  567 }
  568 
  569 ir_expression *
  570 f2d(operand a)
  571 {
  572    return expr(ir_unop_f2d, a);
  573 }
  574 
  575 ir_expression *
  576 i2d(operand a)
  577 {
  578    return expr(ir_unop_i2d, a);
  579 }
  580 
  581 ir_expression *
  582 u2d(operand a)
  583 {
  584    return expr(ir_unop_u2d, a);
  585 }
  586 
  587 ir_expression *
  588 fma(operand a, operand b, operand c)
  589 {
  590    return expr(ir_triop_fma, a, b, c);
  591 }
  592 
  593 ir_expression *
  594 lrp(operand x, operand y, operand a)
  595 {
  596    return expr(ir_triop_lrp, x, y, a);
  597 }
  598 
  599 ir_expression *
  600 csel(operand a, operand b, operand c)
  601 {
  602    return expr(ir_triop_csel, a, b, c);
  603 }
  604 
  605 ir_expression *
  606 bitfield_extract(operand a, operand b, operand c)
  607 {
  608    return expr(ir_triop_bitfield_extract, a, b, c);
  609 }
  610 
  611 ir_expression *
  612 bitfield_insert(operand a, operand b, operand c, operand d)
  613 {
  614    void *mem_ctx = ralloc_parent(a.val);
  615    return new(mem_ctx) ir_expression(ir_quadop_bitfield_insert,
  616                                      a.val->type, a.val, b.val, c.val, d.val);
  617 }
  618 
  619 ir_if*
  620 if_tree(operand condition,
  621         ir_instruction *then_branch)
  622 {
  623    assert(then_branch != NULL);
  624 
  625    void *mem_ctx = ralloc_parent(condition.val);
  626 
  627    ir_if *result = new(mem_ctx) ir_if(condition.val);
  628    result->then_instructions.push_tail(then_branch);
  629    return result;
  630 }
  631 
  632 ir_if*
  633 if_tree(operand condition,
  634         ir_instruction *then_branch,
  635         ir_instruction *else_branch)
  636 {
  637    assert(then_branch != NULL);
  638    assert(else_branch != NULL);
  639 
  640    void *mem_ctx = ralloc_parent(condition.val);
  641 
  642    ir_if *result = new(mem_ctx) ir_if(condition.val);
  643    result->then_instructions.push_tail(then_branch);
  644    result->else_instructions.push_tail(else_branch);
  645    return result;
  646 }
  647 
  648 } /* namespace ir_builder */