nir/builder: Add support for easily building control-flow
[mesa.git] / src / compiler / nir / nir_builder.h
1 /*
2 * Copyright © 2014-2015 Broadcom
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 #ifndef NIR_BUILDER_H
25 #define NIR_BUILDER_H
26
27 #include "nir_control_flow.h"
28
29 struct exec_list;
30
31 typedef struct nir_builder {
32 nir_cursor cursor;
33
34 /* Whether new ALU instructions will be marked "exact" */
35 bool exact;
36
37 nir_shader *shader;
38 nir_function_impl *impl;
39 } nir_builder;
40
41 static inline void
42 nir_builder_init(nir_builder *build, nir_function_impl *impl)
43 {
44 memset(build, 0, sizeof(*build));
45 build->exact = false;
46 build->impl = impl;
47 build->shader = impl->function->shader;
48 }
49
50 static inline void
51 nir_builder_init_simple_shader(nir_builder *build, void *mem_ctx,
52 gl_shader_stage stage,
53 const nir_shader_compiler_options *options)
54 {
55 build->shader = nir_shader_create(mem_ctx, stage, options, NULL);
56 nir_function *func = nir_function_create(build->shader, "main");
57 build->exact = false;
58 build->impl = nir_function_impl_create(func);
59 build->cursor = nir_after_cf_list(&build->impl->body);
60 }
61
62 static inline void
63 nir_builder_instr_insert(nir_builder *build, nir_instr *instr)
64 {
65 nir_instr_insert(build->cursor, instr);
66
67 /* Move the cursor forward. */
68 build->cursor = nir_after_instr(instr);
69 }
70
71 static inline nir_instr *
72 nir_builder_last_instr(nir_builder *build)
73 {
74 assert(build->cursor.option == nir_cursor_after_instr);
75 return build->cursor.instr;
76 }
77
78 static inline void
79 nir_builder_cf_insert(nir_builder *build, nir_cf_node *cf)
80 {
81 nir_cf_node_insert(build->cursor, cf);
82 }
83
84 static inline bool
85 nir_builder_is_inside_cf(nir_builder *build, nir_cf_node *cf_node)
86 {
87 nir_block *block = nir_cursor_current_block(build->cursor);
88 for (nir_cf_node *n = &block->cf_node; n; n = n->parent) {
89 if (n == cf_node)
90 return true;
91 }
92 return false;
93 }
94
95 static inline nir_if *
96 nir_push_if(nir_builder *build, nir_ssa_def *condition)
97 {
98 nir_if *nif = nir_if_create(build->shader);
99 nif->condition = nir_src_for_ssa(condition);
100 nir_builder_cf_insert(build, &nif->cf_node);
101 build->cursor = nir_before_cf_list(&nif->then_list);
102 return nif;
103 }
104
105 static inline nir_if *
106 nir_push_else(nir_builder *build, nir_if *nif)
107 {
108 if (nif) {
109 assert(nir_builder_is_inside_cf(build, &nif->cf_node));
110 } else {
111 nir_block *block = nir_cursor_current_block(build->cursor);
112 nif = nir_cf_node_as_if(block->cf_node.parent);
113 }
114 build->cursor = nir_before_cf_list(&nif->else_list);
115 return nif;
116 }
117
118 static inline void
119 nir_pop_if(nir_builder *build, nir_if *nif)
120 {
121 if (nif) {
122 assert(nir_builder_is_inside_cf(build, &nif->cf_node));
123 } else {
124 nir_block *block = nir_cursor_current_block(build->cursor);
125 nif = nir_cf_node_as_if(block->cf_node.parent);
126 }
127 build->cursor = nir_after_cf_node(&nif->cf_node);
128 }
129
130 static inline nir_ssa_def *
131 nir_if_phi(nir_builder *build, nir_ssa_def *then_def, nir_ssa_def *else_def)
132 {
133 nir_block *block = nir_cursor_current_block(build->cursor);
134 nir_if *nif = nir_cf_node_as_if(nir_cf_node_prev(&block->cf_node));
135
136 nir_phi_instr *phi = nir_phi_instr_create(build->shader);
137
138 nir_phi_src *src = ralloc(phi, nir_phi_src);
139 src->pred = nir_if_last_then_block(nif);
140 src->src = nir_src_for_ssa(then_def);
141 exec_list_push_tail(&phi->srcs, &src->node);
142
143 src = ralloc(phi, nir_phi_src);
144 src->pred = nir_if_last_else_block(nif);
145 src->src = nir_src_for_ssa(else_def);
146 exec_list_push_tail(&phi->srcs, &src->node);
147
148 assert(then_def->num_components == else_def->num_components);
149 assert(then_def->bit_size == else_def->bit_size);
150 nir_ssa_dest_init(&phi->instr, &phi->dest,
151 then_def->num_components, then_def->bit_size, NULL);
152
153 nir_builder_instr_insert(build, &phi->instr);
154
155 return &phi->dest.ssa;
156 }
157
158 static inline nir_loop *
159 nir_push_loop(nir_builder *build)
160 {
161 nir_loop *loop = nir_loop_create(build->shader);
162 nir_builder_cf_insert(build, &loop->cf_node);
163 build->cursor = nir_before_cf_list(&loop->body);
164 return loop;
165 }
166
167 static inline void
168 nir_pop_loop(nir_builder *build, nir_loop *loop)
169 {
170 if (loop) {
171 assert(nir_builder_is_inside_cf(build, &loop->cf_node));
172 } else {
173 nir_block *block = nir_cursor_current_block(build->cursor);
174 loop = nir_cf_node_as_loop(block->cf_node.parent);
175 }
176 build->cursor = nir_after_cf_node(&loop->cf_node);
177 }
178
179 static inline nir_ssa_def *
180 nir_ssa_undef(nir_builder *build, unsigned num_components, unsigned bit_size)
181 {
182 nir_ssa_undef_instr *undef =
183 nir_ssa_undef_instr_create(build->shader, num_components, bit_size);
184 if (!undef)
185 return NULL;
186
187 nir_instr_insert(nir_before_cf_list(&build->impl->body), &undef->instr);
188
189 return &undef->def;
190 }
191
192 static inline nir_ssa_def *
193 nir_build_imm(nir_builder *build, unsigned num_components,
194 unsigned bit_size, nir_const_value value)
195 {
196 nir_load_const_instr *load_const =
197 nir_load_const_instr_create(build->shader, num_components, bit_size);
198 if (!load_const)
199 return NULL;
200
201 load_const->value = value;
202
203 nir_builder_instr_insert(build, &load_const->instr);
204
205 return &load_const->def;
206 }
207
208 static inline nir_ssa_def *
209 nir_imm_float(nir_builder *build, float x)
210 {
211 nir_const_value v;
212
213 memset(&v, 0, sizeof(v));
214 v.f32[0] = x;
215
216 return nir_build_imm(build, 1, 32, v);
217 }
218
219 static inline nir_ssa_def *
220 nir_imm_double(nir_builder *build, double x)
221 {
222 nir_const_value v;
223
224 memset(&v, 0, sizeof(v));
225 v.f64[0] = x;
226
227 return nir_build_imm(build, 1, 64, v);
228 }
229
230 static inline nir_ssa_def *
231 nir_imm_vec4(nir_builder *build, float x, float y, float z, float w)
232 {
233 nir_const_value v;
234
235 memset(&v, 0, sizeof(v));
236 v.f32[0] = x;
237 v.f32[1] = y;
238 v.f32[2] = z;
239 v.f32[3] = w;
240
241 return nir_build_imm(build, 4, 32, v);
242 }
243
244 static inline nir_ssa_def *
245 nir_imm_int(nir_builder *build, int x)
246 {
247 nir_const_value v;
248
249 memset(&v, 0, sizeof(v));
250 v.i32[0] = x;
251
252 return nir_build_imm(build, 1, 32, v);
253 }
254
255 static inline nir_ssa_def *
256 nir_imm_ivec4(nir_builder *build, int x, int y, int z, int w)
257 {
258 nir_const_value v;
259
260 memset(&v, 0, sizeof(v));
261 v.i32[0] = x;
262 v.i32[1] = y;
263 v.i32[2] = z;
264 v.i32[3] = w;
265
266 return nir_build_imm(build, 4, 32, v);
267 }
268
269 static inline nir_ssa_def *
270 nir_build_alu(nir_builder *build, nir_op op, nir_ssa_def *src0,
271 nir_ssa_def *src1, nir_ssa_def *src2, nir_ssa_def *src3)
272 {
273 const nir_op_info *op_info = &nir_op_infos[op];
274 nir_alu_instr *instr = nir_alu_instr_create(build->shader, op);
275 if (!instr)
276 return NULL;
277
278 instr->exact = build->exact;
279
280 instr->src[0].src = nir_src_for_ssa(src0);
281 if (src1)
282 instr->src[1].src = nir_src_for_ssa(src1);
283 if (src2)
284 instr->src[2].src = nir_src_for_ssa(src2);
285 if (src3)
286 instr->src[3].src = nir_src_for_ssa(src3);
287
288 /* Guess the number of components the destination temporary should have
289 * based on our input sizes, if it's not fixed for the op.
290 */
291 unsigned num_components = op_info->output_size;
292 if (num_components == 0) {
293 for (unsigned i = 0; i < op_info->num_inputs; i++) {
294 if (op_info->input_sizes[i] == 0)
295 num_components = MAX2(num_components,
296 instr->src[i].src.ssa->num_components);
297 }
298 }
299 assert(num_components != 0);
300
301 /* Figure out the bitwidth based on the source bitwidth if the instruction
302 * is variable-width.
303 */
304 unsigned bit_size = nir_alu_type_get_type_size(op_info->output_type);
305 if (bit_size == 0) {
306 for (unsigned i = 0; i < op_info->num_inputs; i++) {
307 unsigned src_bit_size = instr->src[i].src.ssa->bit_size;
308 if (nir_alu_type_get_type_size(op_info->input_types[i]) == 0) {
309 if (bit_size)
310 assert(src_bit_size == bit_size);
311 else
312 bit_size = src_bit_size;
313 } else {
314 assert(src_bit_size ==
315 nir_alu_type_get_type_size(op_info->input_types[i]));
316 }
317 }
318 }
319
320 /* Make sure we don't swizzle from outside of our source vector (like if a
321 * scalar value was passed into a multiply with a vector).
322 */
323 for (unsigned i = 0; i < op_info->num_inputs; i++) {
324 for (unsigned j = instr->src[i].src.ssa->num_components; j < 4; j++) {
325 instr->src[i].swizzle[j] = instr->src[i].src.ssa->num_components - 1;
326 }
327 }
328
329 nir_ssa_dest_init(&instr->instr, &instr->dest.dest, num_components,
330 bit_size, NULL);
331 instr->dest.write_mask = (1 << num_components) - 1;
332
333 nir_builder_instr_insert(build, &instr->instr);
334
335 return &instr->dest.dest.ssa;
336 }
337
338 #include "nir_builder_opcodes.h"
339
340 static inline nir_ssa_def *
341 nir_vec(nir_builder *build, nir_ssa_def **comp, unsigned num_components)
342 {
343 switch (num_components) {
344 case 4:
345 return nir_vec4(build, comp[0], comp[1], comp[2], comp[3]);
346 case 3:
347 return nir_vec3(build, comp[0], comp[1], comp[2]);
348 case 2:
349 return nir_vec2(build, comp[0], comp[1]);
350 case 1:
351 return comp[0];
352 default:
353 unreachable("bad component count");
354 return NULL;
355 }
356 }
357
358 /**
359 * Similar to nir_fmov, but takes a nir_alu_src instead of a nir_ssa_def.
360 */
361 static inline nir_ssa_def *
362 nir_fmov_alu(nir_builder *build, nir_alu_src src, unsigned num_components)
363 {
364 nir_alu_instr *mov = nir_alu_instr_create(build->shader, nir_op_fmov);
365 nir_ssa_dest_init(&mov->instr, &mov->dest.dest, num_components,
366 nir_src_bit_size(src.src), NULL);
367 mov->exact = build->exact;
368 mov->dest.write_mask = (1 << num_components) - 1;
369 mov->src[0] = src;
370 nir_builder_instr_insert(build, &mov->instr);
371
372 return &mov->dest.dest.ssa;
373 }
374
375 static inline nir_ssa_def *
376 nir_imov_alu(nir_builder *build, nir_alu_src src, unsigned num_components)
377 {
378 nir_alu_instr *mov = nir_alu_instr_create(build->shader, nir_op_imov);
379 nir_ssa_dest_init(&mov->instr, &mov->dest.dest, num_components,
380 nir_src_bit_size(src.src), NULL);
381 mov->exact = build->exact;
382 mov->dest.write_mask = (1 << num_components) - 1;
383 mov->src[0] = src;
384 nir_builder_instr_insert(build, &mov->instr);
385
386 return &mov->dest.dest.ssa;
387 }
388
389 /**
390 * Construct an fmov or imov that reswizzles the source's components.
391 */
392 static inline nir_ssa_def *
393 nir_swizzle(nir_builder *build, nir_ssa_def *src, const unsigned swiz[4],
394 unsigned num_components, bool use_fmov)
395 {
396 nir_alu_src alu_src = { NIR_SRC_INIT };
397 alu_src.src = nir_src_for_ssa(src);
398 for (unsigned i = 0; i < num_components; i++)
399 alu_src.swizzle[i] = swiz[i];
400
401 return use_fmov ? nir_fmov_alu(build, alu_src, num_components) :
402 nir_imov_alu(build, alu_src, num_components);
403 }
404
405 /* Selects the right fdot given the number of components in each source. */
406 static inline nir_ssa_def *
407 nir_fdot(nir_builder *build, nir_ssa_def *src0, nir_ssa_def *src1)
408 {
409 assert(src0->num_components == src1->num_components);
410 switch (src0->num_components) {
411 case 1: return nir_fmul(build, src0, src1);
412 case 2: return nir_fdot2(build, src0, src1);
413 case 3: return nir_fdot3(build, src0, src1);
414 case 4: return nir_fdot4(build, src0, src1);
415 default:
416 unreachable("bad component size");
417 }
418
419 return NULL;
420 }
421
422 static inline nir_ssa_def *
423 nir_bany_inequal(nir_builder *b, nir_ssa_def *src0, nir_ssa_def *src1)
424 {
425 switch (src0->num_components) {
426 case 1: return nir_ine(b, src0, src1);
427 case 2: return nir_bany_inequal2(b, src0, src1);
428 case 3: return nir_bany_inequal3(b, src0, src1);
429 case 4: return nir_bany_inequal4(b, src0, src1);
430 default:
431 unreachable("bad component size");
432 }
433 }
434
435 static inline nir_ssa_def *
436 nir_bany(nir_builder *b, nir_ssa_def *src)
437 {
438 return nir_bany_inequal(b, src, nir_imm_int(b, 0));
439 }
440
441 static inline nir_ssa_def *
442 nir_channel(nir_builder *b, nir_ssa_def *def, unsigned c)
443 {
444 unsigned swizzle[4] = {c, c, c, c};
445 return nir_swizzle(b, def, swizzle, 1, false);
446 }
447
448 static inline nir_ssa_def *
449 nir_channels(nir_builder *b, nir_ssa_def *def, unsigned mask)
450 {
451 unsigned num_channels = 0, swizzle[4] = { 0, 0, 0, 0 };
452
453 for (unsigned i = 0; i < 4; i++) {
454 if ((mask & (1 << i)) == 0)
455 continue;
456 swizzle[num_channels++] = i;
457 }
458
459 return nir_swizzle(b, def, swizzle, num_channels, false);
460 }
461
462 /**
463 * Turns a nir_src into a nir_ssa_def * so it can be passed to
464 * nir_build_alu()-based builder calls.
465 *
466 * See nir_ssa_for_alu_src() for alu instructions.
467 */
468 static inline nir_ssa_def *
469 nir_ssa_for_src(nir_builder *build, nir_src src, int num_components)
470 {
471 if (src.is_ssa && src.ssa->num_components == num_components)
472 return src.ssa;
473
474 nir_alu_src alu = { NIR_SRC_INIT };
475 alu.src = src;
476 for (int j = 0; j < 4; j++)
477 alu.swizzle[j] = j;
478
479 return nir_imov_alu(build, alu, num_components);
480 }
481
482 /**
483 * Similar to nir_ssa_for_src(), but for alu src's, respecting the
484 * nir_alu_src's swizzle.
485 */
486 static inline nir_ssa_def *
487 nir_ssa_for_alu_src(nir_builder *build, nir_alu_instr *instr, unsigned srcn)
488 {
489 static uint8_t trivial_swizzle[4] = { 0, 1, 2, 3 };
490 nir_alu_src *src = &instr->src[srcn];
491 unsigned num_components = nir_ssa_alu_instr_src_components(instr, srcn);
492
493 if (src->src.is_ssa && (src->src.ssa->num_components == num_components) &&
494 !src->abs && !src->negate &&
495 (memcmp(src->swizzle, trivial_swizzle, num_components) == 0))
496 return src->src.ssa;
497
498 return nir_imov_alu(build, *src, num_components);
499 }
500
501 static inline nir_ssa_def *
502 nir_load_var(nir_builder *build, nir_variable *var)
503 {
504 const unsigned num_components = glsl_get_vector_elements(var->type);
505
506 nir_intrinsic_instr *load =
507 nir_intrinsic_instr_create(build->shader, nir_intrinsic_load_var);
508 load->num_components = num_components;
509 load->variables[0] = nir_deref_var_create(load, var);
510 nir_ssa_dest_init(&load->instr, &load->dest, num_components,
511 glsl_get_bit_size(var->type), NULL);
512 nir_builder_instr_insert(build, &load->instr);
513 return &load->dest.ssa;
514 }
515
516 static inline nir_ssa_def *
517 nir_load_deref_var(nir_builder *build, nir_deref_var *deref)
518 {
519 const struct glsl_type *type = nir_deref_tail(&deref->deref)->type;
520 const unsigned num_components = glsl_get_vector_elements(type);
521
522 nir_intrinsic_instr *load =
523 nir_intrinsic_instr_create(build->shader, nir_intrinsic_load_var);
524 load->num_components = num_components;
525 load->variables[0] = nir_deref_var_clone(deref, load);
526 nir_ssa_dest_init(&load->instr, &load->dest, num_components,
527 glsl_get_bit_size(type), NULL);
528 nir_builder_instr_insert(build, &load->instr);
529 return &load->dest.ssa;
530 }
531
532 static inline void
533 nir_store_var(nir_builder *build, nir_variable *var, nir_ssa_def *value,
534 unsigned writemask)
535 {
536 const unsigned num_components = glsl_get_vector_elements(var->type);
537
538 nir_intrinsic_instr *store =
539 nir_intrinsic_instr_create(build->shader, nir_intrinsic_store_var);
540 store->num_components = num_components;
541 nir_intrinsic_set_write_mask(store, writemask);
542 store->variables[0] = nir_deref_var_create(store, var);
543 store->src[0] = nir_src_for_ssa(value);
544 nir_builder_instr_insert(build, &store->instr);
545 }
546
547 static inline void
548 nir_store_deref_var(nir_builder *build, nir_deref_var *deref,
549 nir_ssa_def *value, unsigned writemask)
550 {
551 const unsigned num_components =
552 glsl_get_vector_elements(nir_deref_tail(&deref->deref)->type);
553
554 nir_intrinsic_instr *store =
555 nir_intrinsic_instr_create(build->shader, nir_intrinsic_store_var);
556 store->num_components = num_components;
557 store->const_index[0] = writemask & ((1 << num_components) - 1);
558 store->variables[0] = nir_deref_var_clone(deref, store);
559 store->src[0] = nir_src_for_ssa(value);
560 nir_builder_instr_insert(build, &store->instr);
561 }
562
563 static inline void
564 nir_copy_deref_var(nir_builder *build, nir_deref_var *dest, nir_deref_var *src)
565 {
566 assert(nir_deref_tail(&dest->deref)->type ==
567 nir_deref_tail(&src->deref)->type);
568
569 nir_intrinsic_instr *copy =
570 nir_intrinsic_instr_create(build->shader, nir_intrinsic_copy_var);
571 copy->variables[0] = nir_deref_var_clone(dest, copy);
572 copy->variables[1] = nir_deref_var_clone(src, copy);
573 nir_builder_instr_insert(build, &copy->instr);
574 }
575
576 static inline void
577 nir_copy_var(nir_builder *build, nir_variable *dest, nir_variable *src)
578 {
579 nir_intrinsic_instr *copy =
580 nir_intrinsic_instr_create(build->shader, nir_intrinsic_copy_var);
581 copy->variables[0] = nir_deref_var_create(copy, dest);
582 copy->variables[1] = nir_deref_var_create(copy, src);
583 nir_builder_instr_insert(build, &copy->instr);
584 }
585
586 /* Generic builder for system values. */
587 static inline nir_ssa_def *
588 nir_load_system_value(nir_builder *build, nir_intrinsic_op op, int index)
589 {
590 nir_intrinsic_instr *load = nir_intrinsic_instr_create(build->shader, op);
591 load->num_components = nir_intrinsic_infos[op].dest_components;
592 load->const_index[0] = index;
593 nir_ssa_dest_init(&load->instr, &load->dest,
594 nir_intrinsic_infos[op].dest_components, 32, NULL);
595 nir_builder_instr_insert(build, &load->instr);
596 return &load->dest.ssa;
597 }
598
599 /* Generate custom builders for system values. */
600 #define INTRINSIC(name, num_srcs, src_components, has_dest, dest_components, \
601 num_variables, num_indices, idx0, idx1, idx2, flags)
602 #define LAST_INTRINSIC(name)
603
604 #define DEFINE_SYSTEM_VALUE(name) \
605 static inline nir_ssa_def * \
606 nir_load_##name(nir_builder *build) \
607 { \
608 return nir_load_system_value(build, nir_intrinsic_load_##name, 0); \
609 } \
610
611 #include "nir_intrinsics.h"
612
613 static inline nir_ssa_def *
614 nir_load_barycentric(nir_builder *build, nir_intrinsic_op op,
615 unsigned interp_mode)
616 {
617 nir_intrinsic_instr *bary = nir_intrinsic_instr_create(build->shader, op);
618 nir_ssa_dest_init(&bary->instr, &bary->dest, 2, 32, NULL);
619 nir_intrinsic_set_interp_mode(bary, interp_mode);
620 nir_builder_instr_insert(build, &bary->instr);
621 return &bary->dest.ssa;
622 }
623
624 static inline void
625 nir_jump(nir_builder *build, nir_jump_type jump_type)
626 {
627 nir_jump_instr *jump = nir_jump_instr_create(build->shader, jump_type);
628 nir_builder_instr_insert(build, &jump->instr);
629 }
630
631 #endif /* NIR_BUILDER_H */