2014-11-10 19:16:30 +00:00
|
|
|
/*
|
|
|
|
* Copyright © 2014-2015 Broadcom
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
* IN THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef NIR_BUILDER_H
|
|
|
|
#define NIR_BUILDER_H
|
|
|
|
|
2015-08-06 15:16:07 +01:00
|
|
|
#include "nir_control_flow.h"
|
2018-10-22 20:08:44 +01:00
|
|
|
#include "util/half_float.h"
|
2015-08-06 15:16:07 +01:00
|
|
|
|
2014-11-10 19:16:30 +00:00
|
|
|
struct exec_list;
|
|
|
|
|
|
|
|
typedef struct nir_builder {
|
2015-08-06 15:16:07 +01:00
|
|
|
nir_cursor cursor;
|
2015-03-27 21:18:54 +00:00
|
|
|
|
2016-03-17 22:54:26 +00:00
|
|
|
/* Whether new ALU instructions will be marked "exact" */
|
|
|
|
bool exact;
|
|
|
|
|
2014-11-10 19:16:30 +00:00
|
|
|
nir_shader *shader;
|
|
|
|
nir_function_impl *impl;
|
|
|
|
} nir_builder;
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
nir_builder_init(nir_builder *build, nir_function_impl *impl)
|
|
|
|
{
|
|
|
|
memset(build, 0, sizeof(*build));
|
2016-03-17 22:54:26 +00:00
|
|
|
build->exact = false;
|
2014-11-10 19:16:30 +00:00
|
|
|
build->impl = impl;
|
2015-12-26 18:00:47 +00:00
|
|
|
build->shader = impl->function->shader;
|
2014-11-10 19:16:30 +00:00
|
|
|
}
|
|
|
|
|
2015-12-29 17:56:44 +00:00
|
|
|
static inline void
|
|
|
|
nir_builder_init_simple_shader(nir_builder *build, void *mem_ctx,
|
|
|
|
gl_shader_stage stage,
|
|
|
|
const nir_shader_compiler_options *options)
|
|
|
|
{
|
2016-10-13 01:41:23 +01:00
|
|
|
build->shader = nir_shader_create(mem_ctx, stage, options, NULL);
|
2015-12-29 17:56:44 +00:00
|
|
|
nir_function *func = nir_function_create(build->shader, "main");
|
2016-03-17 22:54:26 +00:00
|
|
|
build->exact = false;
|
2015-12-29 17:56:44 +00:00
|
|
|
build->impl = nir_function_impl_create(func);
|
|
|
|
build->cursor = nir_after_cf_list(&build->impl->body);
|
|
|
|
}
|
|
|
|
|
2014-11-10 19:16:30 +00:00
|
|
|
static inline void
|
2015-08-06 15:16:07 +01:00
|
|
|
nir_builder_instr_insert(nir_builder *build, nir_instr *instr)
|
2015-03-27 21:18:54 +00:00
|
|
|
{
|
2015-08-06 15:16:07 +01:00
|
|
|
nir_instr_insert(build->cursor, instr);
|
2015-04-15 20:49:15 +01:00
|
|
|
|
2015-08-06 15:16:07 +01:00
|
|
|
/* Move the cursor forward. */
|
2015-09-01 00:54:02 +01:00
|
|
|
build->cursor = nir_after_instr(instr);
|
2015-03-27 21:18:54 +00:00
|
|
|
}
|
|
|
|
|
2016-12-10 20:00:12 +00:00
|
|
|
static inline nir_instr *
|
|
|
|
nir_builder_last_instr(nir_builder *build)
|
|
|
|
{
|
|
|
|
assert(build->cursor.option == nir_cursor_after_instr);
|
|
|
|
return build->cursor.instr;
|
|
|
|
}
|
|
|
|
|
2015-03-27 21:18:54 +00:00
|
|
|
static inline void
|
2015-08-06 15:16:07 +01:00
|
|
|
nir_builder_cf_insert(nir_builder *build, nir_cf_node *cf)
|
2015-03-27 21:18:54 +00:00
|
|
|
{
|
2015-08-06 15:16:07 +01:00
|
|
|
nir_cf_node_insert(build->cursor, cf);
|
2015-03-27 21:18:54 +00:00
|
|
|
}
|
|
|
|
|
2017-02-15 16:42:45 +00:00
|
|
|
static inline bool
|
|
|
|
nir_builder_is_inside_cf(nir_builder *build, nir_cf_node *cf_node)
|
|
|
|
{
|
|
|
|
nir_block *block = nir_cursor_current_block(build->cursor);
|
|
|
|
for (nir_cf_node *n = &block->cf_node; n; n = n->parent) {
|
|
|
|
if (n == cf_node)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_if *
|
|
|
|
nir_push_if(nir_builder *build, nir_ssa_def *condition)
|
|
|
|
{
|
|
|
|
nir_if *nif = nir_if_create(build->shader);
|
|
|
|
nif->condition = nir_src_for_ssa(condition);
|
|
|
|
nir_builder_cf_insert(build, &nif->cf_node);
|
|
|
|
build->cursor = nir_before_cf_list(&nif->then_list);
|
|
|
|
return nif;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_if *
|
|
|
|
nir_push_else(nir_builder *build, nir_if *nif)
|
|
|
|
{
|
|
|
|
if (nif) {
|
|
|
|
assert(nir_builder_is_inside_cf(build, &nif->cf_node));
|
|
|
|
} else {
|
|
|
|
nir_block *block = nir_cursor_current_block(build->cursor);
|
|
|
|
nif = nir_cf_node_as_if(block->cf_node.parent);
|
|
|
|
}
|
|
|
|
build->cursor = nir_before_cf_list(&nif->else_list);
|
|
|
|
return nif;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
nir_pop_if(nir_builder *build, nir_if *nif)
|
|
|
|
{
|
|
|
|
if (nif) {
|
|
|
|
assert(nir_builder_is_inside_cf(build, &nif->cf_node));
|
|
|
|
} else {
|
|
|
|
nir_block *block = nir_cursor_current_block(build->cursor);
|
|
|
|
nif = nir_cf_node_as_if(block->cf_node.parent);
|
|
|
|
}
|
|
|
|
build->cursor = nir_after_cf_node(&nif->cf_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_if_phi(nir_builder *build, nir_ssa_def *then_def, nir_ssa_def *else_def)
|
|
|
|
{
|
|
|
|
nir_block *block = nir_cursor_current_block(build->cursor);
|
|
|
|
nir_if *nif = nir_cf_node_as_if(nir_cf_node_prev(&block->cf_node));
|
|
|
|
|
|
|
|
nir_phi_instr *phi = nir_phi_instr_create(build->shader);
|
|
|
|
|
|
|
|
nir_phi_src *src = ralloc(phi, nir_phi_src);
|
|
|
|
src->pred = nir_if_last_then_block(nif);
|
|
|
|
src->src = nir_src_for_ssa(then_def);
|
|
|
|
exec_list_push_tail(&phi->srcs, &src->node);
|
|
|
|
|
|
|
|
src = ralloc(phi, nir_phi_src);
|
|
|
|
src->pred = nir_if_last_else_block(nif);
|
|
|
|
src->src = nir_src_for_ssa(else_def);
|
|
|
|
exec_list_push_tail(&phi->srcs, &src->node);
|
|
|
|
|
|
|
|
assert(then_def->num_components == else_def->num_components);
|
|
|
|
assert(then_def->bit_size == else_def->bit_size);
|
|
|
|
nir_ssa_dest_init(&phi->instr, &phi->dest,
|
|
|
|
then_def->num_components, then_def->bit_size, NULL);
|
|
|
|
|
|
|
|
nir_builder_instr_insert(build, &phi->instr);
|
|
|
|
|
|
|
|
return &phi->dest.ssa;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_loop *
|
|
|
|
nir_push_loop(nir_builder *build)
|
|
|
|
{
|
|
|
|
nir_loop *loop = nir_loop_create(build->shader);
|
|
|
|
nir_builder_cf_insert(build, &loop->cf_node);
|
|
|
|
build->cursor = nir_before_cf_list(&loop->body);
|
|
|
|
return loop;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
nir_pop_loop(nir_builder *build, nir_loop *loop)
|
|
|
|
{
|
|
|
|
if (loop) {
|
|
|
|
assert(nir_builder_is_inside_cf(build, &loop->cf_node));
|
|
|
|
} else {
|
|
|
|
nir_block *block = nir_cursor_current_block(build->cursor);
|
|
|
|
loop = nir_cf_node_as_loop(block->cf_node.parent);
|
|
|
|
}
|
|
|
|
build->cursor = nir_after_cf_node(&loop->cf_node);
|
|
|
|
}
|
|
|
|
|
2016-03-25 17:43:46 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_ssa_undef(nir_builder *build, unsigned num_components, unsigned bit_size)
|
|
|
|
{
|
|
|
|
nir_ssa_undef_instr *undef =
|
2016-03-23 07:04:09 +00:00
|
|
|
nir_ssa_undef_instr_create(build->shader, num_components, bit_size);
|
2016-03-25 17:43:46 +00:00
|
|
|
if (!undef)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
nir_instr_insert(nir_before_cf_list(&build->impl->body), &undef->instr);
|
|
|
|
|
|
|
|
return &undef->def;
|
|
|
|
}
|
|
|
|
|
2015-03-25 09:11:52 +00:00
|
|
|
static inline nir_ssa_def *
|
2016-03-23 09:43:03 +00:00
|
|
|
nir_build_imm(nir_builder *build, unsigned num_components,
|
|
|
|
unsigned bit_size, nir_const_value value)
|
2015-03-25 09:11:52 +00:00
|
|
|
{
|
|
|
|
nir_load_const_instr *load_const =
|
2016-03-23 09:43:03 +00:00
|
|
|
nir_load_const_instr_create(build->shader, num_components, bit_size);
|
2015-03-25 09:11:52 +00:00
|
|
|
if (!load_const)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
load_const->value = value;
|
|
|
|
|
2015-03-27 21:18:54 +00:00
|
|
|
nir_builder_instr_insert(build, &load_const->instr);
|
2015-03-25 09:11:52 +00:00
|
|
|
|
|
|
|
return &load_const->def;
|
|
|
|
}
|
|
|
|
|
2018-10-19 15:35:49 +01:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_bool(nir_builder *build, bool x)
|
|
|
|
{
|
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
|
|
|
v.u32[0] = x ? NIR_TRUE : NIR_FALSE;
|
|
|
|
|
|
|
|
return nir_build_imm(build, 1, 32, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_true(nir_builder *build)
|
|
|
|
{
|
|
|
|
return nir_imm_bool(build, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_false(nir_builder *build)
|
|
|
|
{
|
|
|
|
return nir_imm_bool(build, false);
|
|
|
|
}
|
|
|
|
|
2018-10-22 20:08:44 +01:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_float16(nir_builder *build, float x)
|
|
|
|
{
|
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
|
|
|
v.u16[0] = _mesa_float_to_half(x);
|
|
|
|
|
|
|
|
return nir_build_imm(build, 1, 16, v);
|
|
|
|
}
|
|
|
|
|
2015-03-25 09:11:52 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_float(nir_builder *build, float x)
|
|
|
|
{
|
2015-09-21 16:22:12 +01:00
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
2016-03-16 11:11:34 +00:00
|
|
|
v.f32[0] = x;
|
2015-09-21 16:22:12 +01:00
|
|
|
|
2016-03-23 09:43:03 +00:00
|
|
|
return nir_build_imm(build, 1, 32, v);
|
2015-03-25 09:11:52 +00:00
|
|
|
}
|
|
|
|
|
2015-07-31 18:52:04 +01:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_double(nir_builder *build, double x)
|
|
|
|
{
|
2016-04-28 12:17:42 +01:00
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
|
|
|
v.f64[0] = x;
|
|
|
|
|
|
|
|
return nir_build_imm(build, 1, 64, v);
|
2015-07-31 18:52:04 +01:00
|
|
|
}
|
|
|
|
|
2018-03-21 19:34:37 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_floatN_t(nir_builder *build, double x, unsigned bit_size)
|
|
|
|
{
|
|
|
|
switch (bit_size) {
|
2018-10-22 20:08:44 +01:00
|
|
|
case 16:
|
|
|
|
return nir_imm_float16(build, x);
|
2018-03-21 19:34:37 +00:00
|
|
|
case 32:
|
|
|
|
return nir_imm_float(build, x);
|
|
|
|
case 64:
|
|
|
|
return nir_imm_double(build, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
unreachable("unknown float immediate bit size");
|
|
|
|
}
|
|
|
|
|
2015-03-25 09:11:52 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_vec4(nir_builder *build, float x, float y, float z, float w)
|
|
|
|
{
|
2015-09-21 16:22:12 +01:00
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
2016-03-16 11:11:34 +00:00
|
|
|
v.f32[0] = x;
|
|
|
|
v.f32[1] = y;
|
|
|
|
v.f32[2] = z;
|
|
|
|
v.f32[3] = w;
|
2015-09-21 16:22:12 +01:00
|
|
|
|
2016-03-23 09:43:03 +00:00
|
|
|
return nir_build_imm(build, 4, 32, v);
|
2015-03-25 09:11:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
2018-10-11 01:14:34 +01:00
|
|
|
nir_imm_ivec2(nir_builder *build, int x, int y)
|
|
|
|
{
|
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
|
|
|
v.i32[0] = x;
|
|
|
|
v.i32[1] = y;
|
|
|
|
|
|
|
|
return nir_build_imm(build, 2, 32, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
2015-03-25 09:11:52 +00:00
|
|
|
nir_imm_int(nir_builder *build, int x)
|
|
|
|
{
|
2015-09-21 16:22:12 +01:00
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
2016-03-16 11:11:34 +00:00
|
|
|
v.i32[0] = x;
|
2015-09-21 16:22:12 +01:00
|
|
|
|
2016-03-23 09:43:03 +00:00
|
|
|
return nir_build_imm(build, 1, 32, v);
|
2015-03-25 09:11:52 +00:00
|
|
|
}
|
2014-11-10 19:16:30 +00:00
|
|
|
|
2017-02-24 05:35:00 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_int64(nir_builder *build, int64_t x)
|
|
|
|
{
|
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
|
|
|
v.i64[0] = x;
|
|
|
|
|
|
|
|
return nir_build_imm(build, 1, 64, v);
|
|
|
|
}
|
|
|
|
|
2017-10-31 21:42:33 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_intN_t(nir_builder *build, uint64_t x, unsigned bit_size)
|
|
|
|
{
|
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
|
|
|
assert(bit_size <= 64);
|
|
|
|
v.i64[0] = x & (~0ull >> (64 - bit_size));
|
|
|
|
|
|
|
|
return nir_build_imm(build, 1, bit_size, v);
|
|
|
|
}
|
|
|
|
|
2016-01-13 21:32:44 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imm_ivec4(nir_builder *build, int x, int y, int z, int w)
|
|
|
|
{
|
|
|
|
nir_const_value v;
|
|
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
2016-03-16 11:11:34 +00:00
|
|
|
v.i32[0] = x;
|
|
|
|
v.i32[1] = y;
|
|
|
|
v.i32[2] = z;
|
|
|
|
v.i32[3] = w;
|
2016-01-13 21:32:44 +00:00
|
|
|
|
2016-03-23 09:43:03 +00:00
|
|
|
return nir_build_imm(build, 4, 32, v);
|
2016-01-13 21:32:44 +00:00
|
|
|
}
|
|
|
|
|
2014-11-10 19:16:30 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_build_alu(nir_builder *build, nir_op op, nir_ssa_def *src0,
|
|
|
|
nir_ssa_def *src1, nir_ssa_def *src2, nir_ssa_def *src3)
|
|
|
|
{
|
|
|
|
const nir_op_info *op_info = &nir_op_infos[op];
|
|
|
|
nir_alu_instr *instr = nir_alu_instr_create(build->shader, op);
|
|
|
|
if (!instr)
|
|
|
|
return NULL;
|
|
|
|
|
2016-03-17 22:54:26 +00:00
|
|
|
instr->exact = build->exact;
|
|
|
|
|
2014-11-10 19:16:30 +00:00
|
|
|
instr->src[0].src = nir_src_for_ssa(src0);
|
|
|
|
if (src1)
|
|
|
|
instr->src[1].src = nir_src_for_ssa(src1);
|
|
|
|
if (src2)
|
|
|
|
instr->src[2].src = nir_src_for_ssa(src2);
|
|
|
|
if (src3)
|
|
|
|
instr->src[3].src = nir_src_for_ssa(src3);
|
|
|
|
|
|
|
|
/* Guess the number of components the destination temporary should have
|
|
|
|
* based on our input sizes, if it's not fixed for the op.
|
|
|
|
*/
|
|
|
|
unsigned num_components = op_info->output_size;
|
|
|
|
if (num_components == 0) {
|
|
|
|
for (unsigned i = 0; i < op_info->num_inputs; i++) {
|
|
|
|
if (op_info->input_sizes[i] == 0)
|
|
|
|
num_components = MAX2(num_components,
|
|
|
|
instr->src[i].src.ssa->num_components);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(num_components != 0);
|
|
|
|
|
2015-11-17 12:57:54 +00:00
|
|
|
/* Figure out the bitwidth based on the source bitwidth if the instruction
|
|
|
|
* is variable-width.
|
|
|
|
*/
|
|
|
|
unsigned bit_size = nir_alu_type_get_type_size(op_info->output_type);
|
|
|
|
if (bit_size == 0) {
|
|
|
|
for (unsigned i = 0; i < op_info->num_inputs; i++) {
|
|
|
|
unsigned src_bit_size = instr->src[i].src.ssa->bit_size;
|
|
|
|
if (nir_alu_type_get_type_size(op_info->input_types[i]) == 0) {
|
|
|
|
if (bit_size)
|
|
|
|
assert(src_bit_size == bit_size);
|
|
|
|
else
|
|
|
|
bit_size = src_bit_size;
|
|
|
|
} else {
|
|
|
|
assert(src_bit_size ==
|
|
|
|
nir_alu_type_get_type_size(op_info->input_types[i]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-08 03:54:37 +00:00
|
|
|
/* When in doubt, assume 32. */
|
|
|
|
if (bit_size == 0)
|
|
|
|
bit_size = 32;
|
|
|
|
|
2014-11-10 19:16:30 +00:00
|
|
|
/* Make sure we don't swizzle from outside of our source vector (like if a
|
|
|
|
* scalar value was passed into a multiply with a vector).
|
|
|
|
*/
|
|
|
|
for (unsigned i = 0; i < op_info->num_inputs; i++) {
|
2018-07-12 02:40:23 +01:00
|
|
|
for (unsigned j = instr->src[i].src.ssa->num_components;
|
|
|
|
j < NIR_MAX_VEC_COMPONENTS; j++) {
|
2014-11-10 19:16:30 +00:00
|
|
|
instr->src[i].swizzle[j] = instr->src[i].src.ssa->num_components - 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-17 12:57:54 +00:00
|
|
|
nir_ssa_dest_init(&instr->instr, &instr->dest.dest, num_components,
|
|
|
|
bit_size, NULL);
|
2014-11-10 19:16:30 +00:00
|
|
|
instr->dest.write_mask = (1 << num_components) - 1;
|
|
|
|
|
2015-03-27 21:18:54 +00:00
|
|
|
nir_builder_instr_insert(build, &instr->instr);
|
2014-11-10 19:16:30 +00:00
|
|
|
|
|
|
|
return &instr->dest.dest.ssa;
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "nir_builder_opcodes.h"
|
|
|
|
|
2015-09-18 18:23:36 +01:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_vec(nir_builder *build, nir_ssa_def **comp, unsigned num_components)
|
|
|
|
{
|
|
|
|
switch (num_components) {
|
|
|
|
case 4:
|
|
|
|
return nir_vec4(build, comp[0], comp[1], comp[2], comp[3]);
|
|
|
|
case 3:
|
|
|
|
return nir_vec3(build, comp[0], comp[1], comp[2]);
|
|
|
|
case 2:
|
|
|
|
return nir_vec2(build, comp[0], comp[1]);
|
|
|
|
case 1:
|
|
|
|
return comp[0];
|
|
|
|
default:
|
|
|
|
unreachable("bad component count");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-25 21:51:02 +00:00
|
|
|
/**
|
|
|
|
* Similar to nir_fmov, but takes a nir_alu_src instead of a nir_ssa_def.
|
|
|
|
*/
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_fmov_alu(nir_builder *build, nir_alu_src src, unsigned num_components)
|
|
|
|
{
|
|
|
|
nir_alu_instr *mov = nir_alu_instr_create(build->shader, nir_op_fmov);
|
2015-11-17 12:57:54 +00:00
|
|
|
nir_ssa_dest_init(&mov->instr, &mov->dest.dest, num_components,
|
|
|
|
nir_src_bit_size(src.src), NULL);
|
2016-03-17 22:54:26 +00:00
|
|
|
mov->exact = build->exact;
|
2015-03-25 21:51:02 +00:00
|
|
|
mov->dest.write_mask = (1 << num_components) - 1;
|
|
|
|
mov->src[0] = src;
|
2015-03-27 21:18:54 +00:00
|
|
|
nir_builder_instr_insert(build, &mov->instr);
|
2015-03-25 21:51:02 +00:00
|
|
|
|
|
|
|
return &mov->dest.dest.ssa;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imov_alu(nir_builder *build, nir_alu_src src, unsigned num_components)
|
|
|
|
{
|
|
|
|
nir_alu_instr *mov = nir_alu_instr_create(build->shader, nir_op_imov);
|
2015-11-17 12:57:54 +00:00
|
|
|
nir_ssa_dest_init(&mov->instr, &mov->dest.dest, num_components,
|
|
|
|
nir_src_bit_size(src.src), NULL);
|
2016-03-17 22:54:26 +00:00
|
|
|
mov->exact = build->exact;
|
2015-03-25 21:51:02 +00:00
|
|
|
mov->dest.write_mask = (1 << num_components) - 1;
|
|
|
|
mov->src[0] = src;
|
2015-03-27 21:18:54 +00:00
|
|
|
nir_builder_instr_insert(build, &mov->instr);
|
2015-03-25 21:51:02 +00:00
|
|
|
|
|
|
|
return &mov->dest.dest.ssa;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Construct an fmov or imov that reswizzles the source's components.
|
|
|
|
*/
|
|
|
|
static inline nir_ssa_def *
|
2018-07-13 02:33:22 +01:00
|
|
|
nir_swizzle(nir_builder *build, nir_ssa_def *src, const unsigned *swiz,
|
2015-03-25 21:51:02 +00:00
|
|
|
unsigned num_components, bool use_fmov)
|
|
|
|
{
|
2018-07-12 02:40:23 +01:00
|
|
|
assert(num_components <= NIR_MAX_VEC_COMPONENTS);
|
2015-04-22 02:00:21 +01:00
|
|
|
nir_alu_src alu_src = { NIR_SRC_INIT };
|
2015-03-25 21:51:02 +00:00
|
|
|
alu_src.src = nir_src_for_ssa(src);
|
2018-07-12 02:40:23 +01:00
|
|
|
for (unsigned i = 0; i < num_components && i < NIR_MAX_VEC_COMPONENTS; i++)
|
2015-03-25 21:51:02 +00:00
|
|
|
alu_src.swizzle[i] = swiz[i];
|
|
|
|
|
|
|
|
return use_fmov ? nir_fmov_alu(build, alu_src, num_components) :
|
|
|
|
nir_imov_alu(build, alu_src, num_components);
|
|
|
|
}
|
|
|
|
|
2016-03-25 17:34:17 +00:00
|
|
|
/* Selects the right fdot given the number of components in each source. */
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_fdot(nir_builder *build, nir_ssa_def *src0, nir_ssa_def *src1)
|
|
|
|
{
|
|
|
|
assert(src0->num_components == src1->num_components);
|
|
|
|
switch (src0->num_components) {
|
|
|
|
case 1: return nir_fmul(build, src0, src1);
|
|
|
|
case 2: return nir_fdot2(build, src0, src1);
|
|
|
|
case 3: return nir_fdot3(build, src0, src1);
|
|
|
|
case 4: return nir_fdot4(build, src0, src1);
|
|
|
|
default:
|
|
|
|
unreachable("bad component size");
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-08-17 13:03:29 +01:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_bany_inequal(nir_builder *b, nir_ssa_def *src0, nir_ssa_def *src1)
|
|
|
|
{
|
|
|
|
switch (src0->num_components) {
|
|
|
|
case 1: return nir_ine(b, src0, src1);
|
|
|
|
case 2: return nir_bany_inequal2(b, src0, src1);
|
|
|
|
case 3: return nir_bany_inequal3(b, src0, src1);
|
|
|
|
case 4: return nir_bany_inequal4(b, src0, src1);
|
|
|
|
default:
|
|
|
|
unreachable("bad component size");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_bany(nir_builder *b, nir_ssa_def *src)
|
|
|
|
{
|
2018-10-19 15:35:49 +01:00
|
|
|
return nir_bany_inequal(b, src, nir_imm_false(b));
|
2016-08-17 13:03:29 +01:00
|
|
|
}
|
|
|
|
|
2015-09-10 21:06:05 +01:00
|
|
|
static inline nir_ssa_def *
|
2015-09-18 02:07:41 +01:00
|
|
|
nir_channel(nir_builder *b, nir_ssa_def *def, unsigned c)
|
2015-09-10 21:06:05 +01:00
|
|
|
{
|
2018-07-13 02:33:22 +01:00
|
|
|
return nir_swizzle(b, def, &c, 1, false);
|
2015-09-10 21:06:05 +01:00
|
|
|
}
|
|
|
|
|
2016-05-03 00:29:05 +01:00
|
|
|
static inline nir_ssa_def *
|
2018-07-12 02:40:23 +01:00
|
|
|
nir_channels(nir_builder *b, nir_ssa_def *def, nir_component_mask_t mask)
|
2016-05-03 00:29:05 +01:00
|
|
|
{
|
2018-07-12 02:40:23 +01:00
|
|
|
unsigned num_channels = 0, swizzle[NIR_MAX_VEC_COMPONENTS] = { 0 };
|
2016-05-03 00:29:05 +01:00
|
|
|
|
2018-07-12 02:40:23 +01:00
|
|
|
for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
|
2016-05-03 00:29:05 +01:00
|
|
|
if ((mask & (1 << i)) == 0)
|
|
|
|
continue;
|
|
|
|
swizzle[num_channels++] = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nir_swizzle(b, def, swizzle, num_channels, false);
|
|
|
|
}
|
|
|
|
|
2018-11-12 21:58:18 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_iadd_imm(nir_builder *build, nir_ssa_def *x, uint64_t y)
|
|
|
|
{
|
|
|
|
return nir_iadd(build, x, nir_imm_intN_t(build, y, x->bit_size));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_imul_imm(nir_builder *build, nir_ssa_def *x, uint64_t y)
|
|
|
|
{
|
|
|
|
return nir_imul(build, x, nir_imm_intN_t(build, y, x->bit_size));
|
|
|
|
}
|
|
|
|
|
2018-11-13 00:38:24 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_pack_bits(nir_builder *b, nir_ssa_def *src, unsigned dest_bit_size)
|
|
|
|
{
|
|
|
|
assert(src->num_components * src->bit_size == dest_bit_size);
|
|
|
|
|
|
|
|
switch (dest_bit_size) {
|
|
|
|
case 64:
|
|
|
|
switch (src->bit_size) {
|
|
|
|
case 32: return nir_pack_64_2x32(b, src);
|
|
|
|
case 16: return nir_pack_64_4x16(b, src);
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 32:
|
|
|
|
if (src->bit_size == 16)
|
|
|
|
return nir_pack_32_2x16(b, src);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we got here, we have no dedicated unpack opcode. */
|
|
|
|
nir_ssa_def *dest = nir_imm_intN_t(b, 0, dest_bit_size);
|
|
|
|
for (unsigned i = 0; i < src->num_components; i++) {
|
|
|
|
nir_ssa_def *val;
|
|
|
|
switch (dest_bit_size) {
|
|
|
|
case 64: val = nir_u2u64(b, nir_channel(b, src, i)); break;
|
|
|
|
case 32: val = nir_u2u32(b, nir_channel(b, src, i)); break;
|
|
|
|
case 16: val = nir_u2u16(b, nir_channel(b, src, i)); break;
|
|
|
|
default: unreachable("Invalid bit size");
|
|
|
|
}
|
|
|
|
val = nir_ishl(b, val, nir_imm_int(b, i * src->bit_size));
|
|
|
|
dest = nir_ior(b, dest, val);
|
|
|
|
}
|
|
|
|
return dest;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_unpack_bits(nir_builder *b, nir_ssa_def *src, unsigned dest_bit_size)
|
|
|
|
{
|
|
|
|
assert(src->num_components == 1);
|
|
|
|
assert(src->bit_size > dest_bit_size);
|
|
|
|
const unsigned dest_num_components = src->bit_size / dest_bit_size;
|
|
|
|
assert(dest_num_components <= NIR_MAX_VEC_COMPONENTS);
|
|
|
|
|
|
|
|
switch (src->bit_size) {
|
|
|
|
case 64:
|
|
|
|
switch (dest_bit_size) {
|
|
|
|
case 32: return nir_unpack_64_2x32(b, src);
|
|
|
|
case 16: return nir_unpack_64_4x16(b, src);
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 32:
|
|
|
|
if (dest_bit_size == 16)
|
|
|
|
return nir_unpack_32_2x16(b, src);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we got here, we have no dedicated unpack opcode. */
|
|
|
|
nir_ssa_def *dest_comps[NIR_MAX_VEC_COMPONENTS];
|
|
|
|
for (unsigned i = 0; i < dest_num_components; i++) {
|
|
|
|
nir_ssa_def *val = nir_ushr(b, src, nir_imm_int(b, i * dest_bit_size));
|
|
|
|
switch (dest_bit_size) {
|
|
|
|
case 32: dest_comps[i] = nir_u2u32(b, val); break;
|
|
|
|
case 16: dest_comps[i] = nir_u2u16(b, val); break;
|
|
|
|
case 8: dest_comps[i] = nir_u2u8(b, val); break;
|
|
|
|
default: unreachable("Invalid bit size");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nir_vec(b, dest_comps, dest_num_components);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_bitcast_vector(nir_builder *b, nir_ssa_def *src, unsigned dest_bit_size)
|
|
|
|
{
|
|
|
|
assert((src->bit_size * src->num_components) % dest_bit_size == 0);
|
|
|
|
const unsigned dest_num_components =
|
|
|
|
(src->bit_size * src->num_components) / dest_bit_size;
|
|
|
|
assert(dest_num_components <= NIR_MAX_VEC_COMPONENTS);
|
|
|
|
|
|
|
|
if (src->bit_size > dest_bit_size) {
|
|
|
|
assert(src->bit_size % dest_bit_size == 0);
|
|
|
|
if (src->num_components == 1) {
|
|
|
|
return nir_unpack_bits(b, src, dest_bit_size);
|
|
|
|
} else {
|
|
|
|
const unsigned divisor = src->bit_size / dest_bit_size;
|
|
|
|
assert(src->num_components * divisor == dest_num_components);
|
|
|
|
nir_ssa_def *dest[NIR_MAX_VEC_COMPONENTS];
|
|
|
|
for (unsigned i = 0; i < src->num_components; i++) {
|
|
|
|
nir_ssa_def *unpacked =
|
|
|
|
nir_unpack_bits(b, nir_channel(b, src, i), dest_bit_size);
|
|
|
|
assert(unpacked->num_components == divisor);
|
|
|
|
for (unsigned j = 0; j < divisor; j++)
|
|
|
|
dest[i * divisor + j] = nir_channel(b, unpacked, j);
|
|
|
|
}
|
|
|
|
return nir_vec(b, dest, dest_num_components);
|
|
|
|
}
|
|
|
|
} else if (src->bit_size < dest_bit_size) {
|
|
|
|
assert(dest_bit_size % src->bit_size == 0);
|
|
|
|
if (dest_num_components == 1) {
|
|
|
|
return nir_pack_bits(b, src, dest_bit_size);
|
|
|
|
} else {
|
|
|
|
const unsigned divisor = dest_bit_size / src->bit_size;
|
|
|
|
assert(src->num_components == dest_num_components * divisor);
|
|
|
|
nir_ssa_def *dest[NIR_MAX_VEC_COMPONENTS];
|
|
|
|
for (unsigned i = 0; i < dest_num_components; i++) {
|
|
|
|
nir_component_mask_t src_mask =
|
|
|
|
((1 << divisor) - 1) << (i * divisor);
|
|
|
|
dest[i] = nir_pack_bits(b, nir_channels(b, src, src_mask),
|
|
|
|
dest_bit_size);
|
|
|
|
}
|
|
|
|
return nir_vec(b, dest, dest_num_components);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
assert(src->bit_size == dest_bit_size);
|
|
|
|
return src;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-27 21:19:46 +00:00
|
|
|
/**
|
|
|
|
* Turns a nir_src into a nir_ssa_def * so it can be passed to
|
|
|
|
* nir_build_alu()-based builder calls.
|
nir: add nir_ssa_for_alu_src()
Using something like:
numer = nir_ssa_for_src(bld, alu->src[0].src,
nir_ssa_alu_instr_src_components(alu, 0));
for alu src's with swizzle, like:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_2 = udiv ssa_10.xx, ssa_11
ends up turning into something like:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_13 = imov ssa_10
...
because nir_ssa_for_src() ignore's the original nir_alu_src's swizzle.
Instead for alu instructions, nir_src_for_alu_src() should be used to
ensure the original alu src's swizzle doesn't get lost in translation:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_13 = imov ssa_10.xx
...
v2: check for abs/neg, and re-use existing nir_alu_src
Signed-off-by: Rob Clark <robclark@freedesktop.org>
Reviewed-by: Jason Ekstrand <jason.ekstrand@intel.com>
2015-11-05 15:23:48 +00:00
|
|
|
*
|
|
|
|
* See nir_ssa_for_alu_src() for alu instructions.
|
2015-03-27 21:19:46 +00:00
|
|
|
*/
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_ssa_for_src(nir_builder *build, nir_src src, int num_components)
|
|
|
|
{
|
|
|
|
if (src.is_ssa && src.ssa->num_components == num_components)
|
|
|
|
return src.ssa;
|
|
|
|
|
2015-04-22 02:00:21 +01:00
|
|
|
nir_alu_src alu = { NIR_SRC_INIT };
|
2015-03-27 21:19:46 +00:00
|
|
|
alu.src = src;
|
|
|
|
for (int j = 0; j < 4; j++)
|
|
|
|
alu.swizzle[j] = j;
|
|
|
|
|
|
|
|
return nir_imov_alu(build, alu, num_components);
|
nir: add nir_ssa_for_alu_src()
Using something like:
numer = nir_ssa_for_src(bld, alu->src[0].src,
nir_ssa_alu_instr_src_components(alu, 0));
for alu src's with swizzle, like:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_2 = udiv ssa_10.xx, ssa_11
ends up turning into something like:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_13 = imov ssa_10
...
because nir_ssa_for_src() ignore's the original nir_alu_src's swizzle.
Instead for alu instructions, nir_src_for_alu_src() should be used to
ensure the original alu src's swizzle doesn't get lost in translation:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_13 = imov ssa_10.xx
...
v2: check for abs/neg, and re-use existing nir_alu_src
Signed-off-by: Rob Clark <robclark@freedesktop.org>
Reviewed-by: Jason Ekstrand <jason.ekstrand@intel.com>
2015-11-05 15:23:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-02-28 01:21:42 +00:00
|
|
|
* Similar to nir_ssa_for_src(), but for alu srcs, respecting the
|
nir: add nir_ssa_for_alu_src()
Using something like:
numer = nir_ssa_for_src(bld, alu->src[0].src,
nir_ssa_alu_instr_src_components(alu, 0));
for alu src's with swizzle, like:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_2 = udiv ssa_10.xx, ssa_11
ends up turning into something like:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_13 = imov ssa_10
...
because nir_ssa_for_src() ignore's the original nir_alu_src's swizzle.
Instead for alu instructions, nir_src_for_alu_src() should be used to
ensure the original alu src's swizzle doesn't get lost in translation:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_13 = imov ssa_10.xx
...
v2: check for abs/neg, and re-use existing nir_alu_src
Signed-off-by: Rob Clark <robclark@freedesktop.org>
Reviewed-by: Jason Ekstrand <jason.ekstrand@intel.com>
2015-11-05 15:23:48 +00:00
|
|
|
* nir_alu_src's swizzle.
|
|
|
|
*/
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_ssa_for_alu_src(nir_builder *build, nir_alu_instr *instr, unsigned srcn)
|
|
|
|
{
|
2018-07-12 02:40:23 +01:00
|
|
|
static uint8_t trivial_swizzle[NIR_MAX_VEC_COMPONENTS];
|
|
|
|
for (int i = 0; i < NIR_MAX_VEC_COMPONENTS; ++i)
|
|
|
|
trivial_swizzle[i] = i;
|
nir: add nir_ssa_for_alu_src()
Using something like:
numer = nir_ssa_for_src(bld, alu->src[0].src,
nir_ssa_alu_instr_src_components(alu, 0));
for alu src's with swizzle, like:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_2 = udiv ssa_10.xx, ssa_11
ends up turning into something like:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_13 = imov ssa_10
...
because nir_ssa_for_src() ignore's the original nir_alu_src's swizzle.
Instead for alu instructions, nir_src_for_alu_src() should be used to
ensure the original alu src's swizzle doesn't get lost in translation:
vec1 ssa_10 = intrinsic load_uniform () () (0, 0)
vec2 ssa_11 = intrinsic load_uniform () () (1, 0)
vec2 ssa_13 = imov ssa_10.xx
...
v2: check for abs/neg, and re-use existing nir_alu_src
Signed-off-by: Rob Clark <robclark@freedesktop.org>
Reviewed-by: Jason Ekstrand <jason.ekstrand@intel.com>
2015-11-05 15:23:48 +00:00
|
|
|
nir_alu_src *src = &instr->src[srcn];
|
|
|
|
unsigned num_components = nir_ssa_alu_instr_src_components(instr, srcn);
|
|
|
|
|
|
|
|
if (src->src.is_ssa && (src->src.ssa->num_components == num_components) &&
|
|
|
|
!src->abs && !src->negate &&
|
|
|
|
(memcmp(src->swizzle, trivial_swizzle, num_components) == 0))
|
|
|
|
return src->src.ssa;
|
|
|
|
|
|
|
|
return nir_imov_alu(build, *src, num_components);
|
2015-03-27 21:19:46 +00:00
|
|
|
}
|
|
|
|
|
2018-03-15 14:57:58 +00:00
|
|
|
static inline nir_deref_instr *
|
|
|
|
nir_build_deref_var(nir_builder *build, nir_variable *var)
|
|
|
|
{
|
|
|
|
nir_deref_instr *deref =
|
|
|
|
nir_deref_instr_create(build->shader, nir_deref_type_var);
|
|
|
|
|
|
|
|
deref->mode = var->data.mode;
|
|
|
|
deref->type = var->type;
|
|
|
|
deref->var = var;
|
|
|
|
|
|
|
|
nir_ssa_dest_init(&deref->instr, &deref->dest, 1, 32, NULL);
|
|
|
|
|
|
|
|
nir_builder_instr_insert(build, &deref->instr);
|
|
|
|
|
|
|
|
return deref;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_deref_instr *
|
|
|
|
nir_build_deref_array(nir_builder *build, nir_deref_instr *parent,
|
|
|
|
nir_ssa_def *index)
|
|
|
|
{
|
|
|
|
assert(glsl_type_is_array(parent->type) ||
|
|
|
|
glsl_type_is_matrix(parent->type) ||
|
|
|
|
glsl_type_is_vector(parent->type));
|
|
|
|
|
|
|
|
nir_deref_instr *deref =
|
|
|
|
nir_deref_instr_create(build->shader, nir_deref_type_array);
|
|
|
|
|
|
|
|
deref->mode = parent->mode;
|
|
|
|
deref->type = glsl_get_array_element(parent->type);
|
|
|
|
deref->parent = nir_src_for_ssa(&parent->dest.ssa);
|
|
|
|
deref->arr.index = nir_src_for_ssa(index);
|
|
|
|
|
|
|
|
nir_ssa_dest_init(&deref->instr, &deref->dest,
|
|
|
|
parent->dest.ssa.num_components,
|
|
|
|
parent->dest.ssa.bit_size, NULL);
|
|
|
|
|
|
|
|
nir_builder_instr_insert(build, &deref->instr);
|
|
|
|
|
|
|
|
return deref;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_deref_instr *
|
|
|
|
nir_build_deref_array_wildcard(nir_builder *build, nir_deref_instr *parent)
|
|
|
|
{
|
|
|
|
assert(glsl_type_is_array(parent->type) ||
|
|
|
|
glsl_type_is_matrix(parent->type));
|
|
|
|
|
|
|
|
nir_deref_instr *deref =
|
|
|
|
nir_deref_instr_create(build->shader, nir_deref_type_array_wildcard);
|
|
|
|
|
|
|
|
deref->mode = parent->mode;
|
|
|
|
deref->type = glsl_get_array_element(parent->type);
|
|
|
|
deref->parent = nir_src_for_ssa(&parent->dest.ssa);
|
|
|
|
|
|
|
|
nir_ssa_dest_init(&deref->instr, &deref->dest,
|
|
|
|
parent->dest.ssa.num_components,
|
|
|
|
parent->dest.ssa.bit_size, NULL);
|
|
|
|
|
|
|
|
nir_builder_instr_insert(build, &deref->instr);
|
|
|
|
|
|
|
|
return deref;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_deref_instr *
|
|
|
|
nir_build_deref_struct(nir_builder *build, nir_deref_instr *parent,
|
|
|
|
unsigned index)
|
|
|
|
{
|
|
|
|
assert(glsl_type_is_struct(parent->type));
|
|
|
|
|
|
|
|
nir_deref_instr *deref =
|
|
|
|
nir_deref_instr_create(build->shader, nir_deref_type_struct);
|
|
|
|
|
|
|
|
deref->mode = parent->mode;
|
|
|
|
deref->type = glsl_get_struct_field(parent->type, index);
|
|
|
|
deref->parent = nir_src_for_ssa(&parent->dest.ssa);
|
|
|
|
deref->strct.index = index;
|
|
|
|
|
|
|
|
nir_ssa_dest_init(&deref->instr, &deref->dest,
|
|
|
|
parent->dest.ssa.num_components,
|
|
|
|
parent->dest.ssa.bit_size, NULL);
|
|
|
|
|
|
|
|
nir_builder_instr_insert(build, &deref->instr);
|
|
|
|
|
|
|
|
return deref;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline nir_deref_instr *
|
|
|
|
nir_build_deref_cast(nir_builder *build, nir_ssa_def *parent,
|
|
|
|
nir_variable_mode mode, const struct glsl_type *type)
|
|
|
|
{
|
|
|
|
nir_deref_instr *deref =
|
|
|
|
nir_deref_instr_create(build->shader, nir_deref_type_cast);
|
|
|
|
|
|
|
|
deref->mode = mode;
|
|
|
|
deref->type = type;
|
|
|
|
deref->parent = nir_src_for_ssa(parent);
|
|
|
|
|
|
|
|
nir_ssa_dest_init(&deref->instr, &deref->dest,
|
|
|
|
parent->num_components, parent->bit_size, NULL);
|
|
|
|
|
|
|
|
nir_builder_instr_insert(build, &deref->instr);
|
|
|
|
|
|
|
|
return deref;
|
|
|
|
}
|
|
|
|
|
2018-03-16 07:20:57 +00:00
|
|
|
/** Returns a deref that follows another but starting from the given parent
|
|
|
|
*
|
|
|
|
* The new deref will be the same type and take the same array or struct index
|
|
|
|
* as the leader deref but it may have a different parent. This is very
|
|
|
|
* useful for walking deref paths.
|
|
|
|
*/
|
|
|
|
static inline nir_deref_instr *
|
|
|
|
nir_build_deref_follower(nir_builder *b, nir_deref_instr *parent,
|
|
|
|
nir_deref_instr *leader)
|
|
|
|
{
|
|
|
|
/* If the derefs would have the same parent, don't make a new one */
|
|
|
|
assert(leader->parent.is_ssa);
|
|
|
|
if (leader->parent.ssa == &parent->dest.ssa)
|
|
|
|
return leader;
|
|
|
|
|
|
|
|
UNUSED nir_deref_instr *leader_parent = nir_src_as_deref(leader->parent);
|
|
|
|
|
|
|
|
switch (leader->deref_type) {
|
|
|
|
case nir_deref_type_var:
|
|
|
|
unreachable("A var dereference cannot have a parent");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case nir_deref_type_array:
|
|
|
|
case nir_deref_type_array_wildcard:
|
|
|
|
assert(glsl_type_is_matrix(parent->type) ||
|
|
|
|
glsl_type_is_array(parent->type));
|
|
|
|
assert(glsl_get_length(parent->type) ==
|
|
|
|
glsl_get_length(leader_parent->type));
|
|
|
|
|
|
|
|
if (leader->deref_type == nir_deref_type_array) {
|
|
|
|
assert(leader->arr.index.is_ssa);
|
|
|
|
return nir_build_deref_array(b, parent, leader->arr.index.ssa);
|
|
|
|
} else {
|
|
|
|
return nir_build_deref_array_wildcard(b, parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
case nir_deref_type_struct:
|
|
|
|
assert(glsl_type_is_struct(parent->type));
|
|
|
|
assert(glsl_get_length(parent->type) ==
|
|
|
|
glsl_get_length(leader_parent->type));
|
|
|
|
|
|
|
|
return nir_build_deref_struct(b, parent, leader->strct.index);
|
|
|
|
|
|
|
|
default:
|
|
|
|
unreachable("Invalid deref instruction type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-19 20:43:35 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_load_reg(nir_builder *build, nir_register *reg)
|
|
|
|
{
|
|
|
|
return nir_ssa_for_src(build, nir_src_for_reg(reg), reg->num_components);
|
|
|
|
}
|
|
|
|
|
2018-03-15 21:56:43 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_load_deref(nir_builder *build, nir_deref_instr *deref)
|
|
|
|
{
|
|
|
|
nir_intrinsic_instr *load =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_load_deref);
|
|
|
|
load->num_components = glsl_get_vector_elements(deref->type);
|
|
|
|
load->src[0] = nir_src_for_ssa(&deref->dest.ssa);
|
|
|
|
nir_ssa_dest_init(&load->instr, &load->dest, load->num_components,
|
|
|
|
glsl_get_bit_size(deref->type), NULL);
|
|
|
|
nir_builder_instr_insert(build, &load->instr);
|
|
|
|
return &load->dest.ssa;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
nir_store_deref(nir_builder *build, nir_deref_instr *deref,
|
|
|
|
nir_ssa_def *value, unsigned writemask)
|
|
|
|
{
|
|
|
|
nir_intrinsic_instr *store =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_store_deref);
|
|
|
|
store->num_components = glsl_get_vector_elements(deref->type);
|
|
|
|
store->src[0] = nir_src_for_ssa(&deref->dest.ssa);
|
|
|
|
store->src[1] = nir_src_for_ssa(value);
|
|
|
|
nir_intrinsic_set_write_mask(store,
|
|
|
|
writemask & ((1 << store->num_components) - 1));
|
|
|
|
nir_builder_instr_insert(build, &store->instr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
nir_copy_deref(nir_builder *build, nir_deref_instr *dest, nir_deref_instr *src)
|
|
|
|
{
|
|
|
|
nir_intrinsic_instr *copy =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_copy_deref);
|
|
|
|
copy->src[0] = nir_src_for_ssa(&dest->dest.ssa);
|
|
|
|
copy->src[1] = nir_src_for_ssa(&src->dest.ssa);
|
|
|
|
nir_builder_instr_insert(build, ©->instr);
|
|
|
|
}
|
|
|
|
|
2015-05-12 09:53:24 +01:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_load_var(nir_builder *build, nir_variable *var)
|
|
|
|
{
|
2018-03-26 22:35:05 +01:00
|
|
|
return nir_load_deref(build, nir_build_deref_var(build, var));
|
2015-05-12 09:53:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
nir: Add a writemask to store intrinsics.
Tessellation control shaders need to be careful when writing outputs.
Because multiple threads can concurrently write the same output
variables, we need to only write the exact components we were told.
Traditionally, for sub-vector writes, we've read the whole vector,
updated the temporary, and written the whole vector back. This breaks
down with concurrent access.
This patch prepares the way for a solution by adding a writemask field
to store_var intrinsics, as well as the other store intrinsics. It then
updates all produces to emit a writemask of "all channels enabled". It
updates nir_lower_io to copy the writemask to output store intrinsics.
Finally, it updates nir_lower_vars_to_ssa to handle partial writemasks
by doing a read-modify-write cycle (which is safe, because local
variables are specific to a single thread).
This should have no functional change, since no one actually emits
partial writemasks yet.
v2: Make nir_validate momentarily assert that writemasks cover the
complete value - we shouldn't have partial writemasks yet
(requested by Jason Ekstrand).
v3: Fix accidental SSBO change that arose from merge conflicts.
v4: Don't try to handle writemasks in ir3_compiler_nir - my code
for indirects was likely wrong, and TTN doesn't generate partial
writemasks today anyway. Change them to asserts as requested by
Rob Clark.
Signed-off-by: Kenneth Graunke <kenneth@whitecape.org>
Reviewed-by: Jason Ekstrand <jason.ekstrand@intel.com> [v3]
2015-11-17 08:26:37 +00:00
|
|
|
nir_store_var(nir_builder *build, nir_variable *var, nir_ssa_def *value,
|
|
|
|
unsigned writemask)
|
2015-05-12 09:53:24 +01:00
|
|
|
{
|
2018-03-26 22:35:05 +01:00
|
|
|
nir_store_deref(build, nir_build_deref_var(build, var), value, writemask);
|
2015-05-12 09:53:24 +01:00
|
|
|
}
|
|
|
|
|
2015-12-26 18:48:14 +00:00
|
|
|
static inline void
|
|
|
|
nir_copy_var(nir_builder *build, nir_variable *dest, nir_variable *src)
|
|
|
|
{
|
2018-03-26 22:35:05 +01:00
|
|
|
nir_copy_deref(build, nir_build_deref_var(build, dest),
|
|
|
|
nir_build_deref_var(build, src));
|
2015-12-26 18:48:14 +00:00
|
|
|
}
|
|
|
|
|
2018-03-22 23:41:18 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_load_param(nir_builder *build, uint32_t param_idx)
|
|
|
|
{
|
|
|
|
assert(param_idx < build->impl->function->num_params);
|
|
|
|
nir_parameter *param = &build->impl->function->params[param_idx];
|
|
|
|
|
|
|
|
nir_intrinsic_instr *load =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_load_param);
|
|
|
|
nir_intrinsic_set_param_idx(load, param_idx);
|
|
|
|
load->num_components = param->num_components;
|
|
|
|
nir_ssa_dest_init(&load->instr, &load->dest,
|
|
|
|
param->num_components, param->bit_size, NULL);
|
|
|
|
nir_builder_instr_insert(build, &load->instr);
|
|
|
|
return &load->dest.ssa;
|
|
|
|
}
|
|
|
|
|
2018-03-15 22:42:44 +00:00
|
|
|
#include "nir_builder_opcodes.h"
|
2016-08-06 01:10:18 +01:00
|
|
|
|
nir: Add new intrinsics for fragment shader input interpolation.
Backends can normally handle shader inputs solely by looking at
load_input intrinsics, and ignore the nir_variables in nir->inputs.
One exception is fragment shader inputs. load_input doesn't capture
the necessary interpolation information - flat, smooth, noperspective
mode, and centroid, sample, or pixel for the location. This means
that backends have to interpolate based on the nir_variables, then
associate those with the load_input intrinsics (say, by storing a
map of which variables are at which locations).
With GL_ARB_enhanced_layouts, we're going to have multiple varyings
packed into a single vec4 location. The intrinsics make this easy:
simply load N components from location <loc, component>. However,
working with variables and correlating the two is very awkward; we'd
much rather have intrinsics capture all the necessary information.
Fragment shader input interpolation typically works by producing a
set of barycentric coordinates, then using those to do a linear
interpolation between the values at the triangle's corners.
We represent this by introducing five new load_barycentric_* intrinsics:
- load_barycentric_pixel (ordinary variable)
- load_barycentric_centroid (centroid qualified variable)
- load_barycentric_sample (sample qualified variable)
- load_barycentric_at_sample (ARB_gpu_shader5's interpolateAtSample())
- load_barycentric_at_offset (ARB_gpu_shader5's interpolateAtOffset())
Each of these take the interpolation mode (smooth or noperspective only)
as a const_index, and produce a vec2. The last two also take a sample
or offset source.
We then introduce a new load_interpolated_input intrinsic, which
is like a normal load_input intrinsic, but with an additional
barycentric coordinate source.
The intention is that flat inputs will still use regular load_input
intrinsics. This makes them distinguishable from normal inputs that
need fancy interpolation, while also providing all the necessary data.
This nicely unifies regular inputs and interpolateAt functions.
Qualifiers and variables become irrelevant; there are just
load_barycentric intrinsics that determine the interpolation.
v2: Document the interp_mode const_index value, define a new
BARYCENTRIC() helper rather than using SYSTEM_VALUE() for
some of them (requested by Jason Ekstrand).
Signed-off-by: Kenneth Graunke <kenneth@whitecape.org>
Reviewed-by: Chris Forbes <chrisforbes@google.com>
Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>
2016-07-12 09:46:43 +01:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_load_barycentric(nir_builder *build, nir_intrinsic_op op,
|
|
|
|
unsigned interp_mode)
|
|
|
|
{
|
|
|
|
nir_intrinsic_instr *bary = nir_intrinsic_instr_create(build->shader, op);
|
|
|
|
nir_ssa_dest_init(&bary->instr, &bary->dest, 2, 32, NULL);
|
|
|
|
nir_intrinsic_set_interp_mode(bary, interp_mode);
|
|
|
|
nir_builder_instr_insert(build, &bary->instr);
|
|
|
|
return &bary->dest.ssa;
|
|
|
|
}
|
|
|
|
|
2016-02-14 01:14:27 +00:00
|
|
|
static inline void
|
|
|
|
nir_jump(nir_builder *build, nir_jump_type jump_type)
|
|
|
|
{
|
|
|
|
nir_jump_instr *jump = nir_jump_instr_create(build->shader, jump_type);
|
|
|
|
nir_builder_instr_insert(build, &jump->instr);
|
|
|
|
}
|
|
|
|
|
2017-02-23 00:53:18 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_compare_func(nir_builder *b, enum compare_func func,
|
|
|
|
nir_ssa_def *src0, nir_ssa_def *src1)
|
|
|
|
{
|
|
|
|
switch (func) {
|
|
|
|
case COMPARE_FUNC_NEVER:
|
|
|
|
return nir_imm_int(b, 0);
|
|
|
|
case COMPARE_FUNC_ALWAYS:
|
|
|
|
return nir_imm_int(b, ~0);
|
|
|
|
case COMPARE_FUNC_EQUAL:
|
|
|
|
return nir_feq(b, src0, src1);
|
|
|
|
case COMPARE_FUNC_NOTEQUAL:
|
|
|
|
return nir_fne(b, src0, src1);
|
|
|
|
case COMPARE_FUNC_GREATER:
|
|
|
|
return nir_flt(b, src1, src0);
|
|
|
|
case COMPARE_FUNC_GEQUAL:
|
|
|
|
return nir_fge(b, src0, src1);
|
|
|
|
case COMPARE_FUNC_LESS:
|
|
|
|
return nir_flt(b, src0, src1);
|
|
|
|
case COMPARE_FUNC_LEQUAL:
|
|
|
|
return nir_fge(b, src1, src0);
|
|
|
|
}
|
|
|
|
unreachable("bad compare func");
|
|
|
|
}
|
|
|
|
|
2014-11-10 19:16:30 +00:00
|
|
|
#endif /* NIR_BUILDER_H */
|