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 27using namespace ir_builder; 28 29namespace ir_builder { 30 31void 32ir_factory::emit(ir_instruction *ir) 33{ 34 instructions->push_tail(ir); 35} 36 37ir_variable * 38ir_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 48ir_assignment * 49assign(deref lhs, operand rhs, 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 NULL, writemask); 56 57 return assign; 58} 59 60ir_assignment * 61assign(deref lhs, operand rhs) 62{ 63 return assign(lhs, rhs, (1 << lhs.val->type->vector_elements) - 1); 64} 65 66ir_swizzle * 67swizzle(operand a, int swizzle, int components) 68{ 69 void *mem_ctx = ralloc_parent(a.val); 70 71 return new(mem_ctx) ir_swizzle(a.val, 72 GET_SWZ(swizzle, 0), 73 GET_SWZ(swizzle, 1), 74 GET_SWZ(swizzle, 2), 75 GET_SWZ(swizzle, 3), 76 components); 77} 78 79ir_swizzle * 80swizzle_for_size(operand a, int components) 81{ 82 void *mem_ctx = ralloc_parent(a.val); 83 84 if (a.val->type->vector_elements < components) 85 components = a.val->type->vector_elements; 86 87 unsigned s[4] = { 0, 1, 2, 3 }; 88 for (int i = components; i < 4; i++) 89 s[i] = components - 1; 90 91 return new(mem_ctx) ir_swizzle(a.val, s, components); 92} 93 94ir_swizzle * 95swizzle_xxxx(operand a) 96{ 97 return swizzle(a, SWIZZLE_XXXX, 4); 98} 99 100ir_swizzle * 101swizzle_yyyy(operand a) 102{ 103 return swizzle(a, SWIZZLE_YYYY, 4); 104} 105 106ir_swizzle * 107swizzle_zzzz(operand a) 108{ 109 return swizzle(a, SWIZZLE_ZZZZ, 4); 110} 111 112ir_swizzle * 113swizzle_wwww(operand a) 114{ 115 return swizzle(a, SWIZZLE_WWWW, 4); 116} 117 118ir_swizzle * 119swizzle_x(operand a) 120{ 121 return swizzle(a, SWIZZLE_XXXX, 1); 122} 123 124ir_swizzle * 125swizzle_y(operand a) 126{ 127 return swizzle(a, SWIZZLE_YYYY, 1); 128} 129 130ir_swizzle * 131swizzle_z(operand a) 132{ 133 return swizzle(a, SWIZZLE_ZZZZ, 1); 134} 135 136ir_swizzle * 137swizzle_w(operand a) 138{ 139 return swizzle(a, SWIZZLE_WWWW, 1); 140} 141 142ir_swizzle * 143swizzle_xy(operand a) 144{ 145 return swizzle(a, SWIZZLE_XYZW, 2); 146} 147 148ir_swizzle * 149swizzle_xyz(operand a) 150{ 151 return swizzle(a, SWIZZLE_XYZW, 3); 152} 153 154ir_swizzle * 155swizzle_xyzw(operand a) 156{ 157 return swizzle(a, SWIZZLE_XYZW, 4); 158} 159 160ir_expression * 161expr(ir_expression_operation op, operand a) 162{ 163 void *mem_ctx = ralloc_parent(a.val); 164 165 return new(mem_ctx) ir_expression(op, a.val); 166} 167 168ir_expression * 169expr(ir_expression_operation op, operand a, operand b) 170{ 171 void *mem_ctx = ralloc_parent(a.val); 172 173 return new(mem_ctx) ir_expression(op, a.val, b.val); 174} 175 176ir_expression *add(operand a, operand b) 177{ 178 return expr(ir_binop_add, a, b); 179} 180 181ir_expression *sub(operand a, operand b) 182{ 183 return expr(ir_binop_sub, a, b); 184} 185 186ir_expression *mul(operand a, operand b) 187{ 188 return expr(ir_binop_mul, a, b); 189} 190 191ir_expression *dot(operand a, operand b) 192{ 193 return expr(ir_binop_dot, a, b); 194} 195 196ir_expression * 197saturate(operand a) 198{ 199 void *mem_ctx = ralloc_parent(a.val); 200 201 return expr(ir_binop_max, 202 expr(ir_binop_min, a, new(mem_ctx) ir_constant(1.0f)), 203 new(mem_ctx) ir_constant(0.0f)); 204} 205 206} /* namespace ir_builder */ 207