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