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
emit(ir_instruction * ir)32 ir_factory::emit(ir_instruction *ir)
33 {
34 instructions->push_tail(ir);
35 }
36
37 ir_variable *
make_temp(const glsl_type * type,const char * name)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 *
assign(deref lhs,operand rhs,int writemask)49 assign(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
60 ir_assignment *
assign(deref lhs,operand rhs)61 assign(deref lhs, operand rhs)
62 {
63 return assign(lhs, rhs, (1 << lhs.val->type->vector_elements) - 1);
64 }
65
66 ir_swizzle *
swizzle(operand a,int swizzle,int components)67 swizzle(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
79 ir_swizzle *
swizzle_for_size(operand a,int components)80 swizzle_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
94 ir_swizzle *
swizzle_xxxx(operand a)95 swizzle_xxxx(operand a)
96 {
97 return swizzle(a, SWIZZLE_XXXX, 4);
98 }
99
100 ir_swizzle *
swizzle_yyyy(operand a)101 swizzle_yyyy(operand a)
102 {
103 return swizzle(a, SWIZZLE_YYYY, 4);
104 }
105
106 ir_swizzle *
swizzle_zzzz(operand a)107 swizzle_zzzz(operand a)
108 {
109 return swizzle(a, SWIZZLE_ZZZZ, 4);
110 }
111
112 ir_swizzle *
swizzle_wwww(operand a)113 swizzle_wwww(operand a)
114 {
115 return swizzle(a, SWIZZLE_WWWW, 4);
116 }
117
118 ir_swizzle *
swizzle_x(operand a)119 swizzle_x(operand a)
120 {
121 return swizzle(a, SWIZZLE_XXXX, 1);
122 }
123
124 ir_swizzle *
swizzle_y(operand a)125 swizzle_y(operand a)
126 {
127 return swizzle(a, SWIZZLE_YYYY, 1);
128 }
129
130 ir_swizzle *
swizzle_z(operand a)131 swizzle_z(operand a)
132 {
133 return swizzle(a, SWIZZLE_ZZZZ, 1);
134 }
135
136 ir_swizzle *
swizzle_w(operand a)137 swizzle_w(operand a)
138 {
139 return swizzle(a, SWIZZLE_WWWW, 1);
140 }
141
142 ir_swizzle *
swizzle_xy(operand a)143 swizzle_xy(operand a)
144 {
145 return swizzle(a, SWIZZLE_XYZW, 2);
146 }
147
148 ir_swizzle *
swizzle_xyz(operand a)149 swizzle_xyz(operand a)
150 {
151 return swizzle(a, SWIZZLE_XYZW, 3);
152 }
153
154 ir_swizzle *
swizzle_xyzw(operand a)155 swizzle_xyzw(operand a)
156 {
157 return swizzle(a, SWIZZLE_XYZW, 4);
158 }
159
160 ir_expression *
expr(ir_expression_operation op,operand a)161 expr(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
168 ir_expression *
expr(ir_expression_operation op,operand a,operand b)169 expr(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
add(operand a,operand b)176 ir_expression *add(operand a, operand b)
177 {
178 return expr(ir_binop_add, a, b);
179 }
180
sub(operand a,operand b)181 ir_expression *sub(operand a, operand b)
182 {
183 return expr(ir_binop_sub, a, b);
184 }
185
mul(operand a,operand b)186 ir_expression *mul(operand a, operand b)
187 {
188 return expr(ir_binop_mul, a, b);
189 }
190
dot(operand a,operand b)191 ir_expression *dot(operand a, operand b)
192 {
193 return expr(ir_binop_dot, a, b);
194 }
195
196 ir_expression *
saturate(operand a)197 saturate(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