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"
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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 *
|
|
|
|
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
|
|
|
|
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]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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++) {
|
|
|
|
for (unsigned j = instr->src[i].src.ssa->num_components; j < 4; j++) {
|
|
|
|
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 *
|
2016-04-19 20:44:25 +01:00
|
|
|
nir_swizzle(nir_builder *build, nir_ssa_def *src, const unsigned swiz[4],
|
2015-03-25 21:51:02 +00:00
|
|
|
unsigned num_components, bool use_fmov)
|
|
|
|
{
|
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);
|
2015-08-03 23:04:13 +01:00
|
|
|
for (unsigned i = 0; i < num_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)
|
|
|
|
{
|
|
|
|
return nir_bany_inequal(b, src, nir_imm_int(b, 0));
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2015-09-15 20:09:06 +01:00
|
|
|
unsigned swizzle[4] = {c, c, c, c};
|
|
|
|
return nir_swizzle(b, def, swizzle, 1, false);
|
2015-09-10 21:06:05 +01:00
|
|
|
}
|
|
|
|
|
2016-05-03 00:29:05 +01:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_channels(nir_builder *b, nir_ssa_def *def, unsigned mask)
|
|
|
|
{
|
|
|
|
unsigned num_channels = 0, swizzle[4] = { 0, 0, 0, 0 };
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < 4; i++) {
|
|
|
|
if ((mask & (1 << i)) == 0)
|
|
|
|
continue;
|
|
|
|
swizzle[num_channels++] = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nir_swizzle(b, def, swizzle, num_channels, false);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Similar to nir_ssa_for_src(), but for alu src's, respecting the
|
|
|
|
* nir_alu_src's swizzle.
|
|
|
|
*/
|
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_ssa_for_alu_src(nir_builder *build, nir_alu_instr *instr, unsigned srcn)
|
|
|
|
{
|
|
|
|
static uint8_t trivial_swizzle[4] = { 0, 1, 2, 3 };
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-05-12 09:53:24 +01:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_load_var(nir_builder *build, nir_variable *var)
|
|
|
|
{
|
|
|
|
const unsigned num_components = glsl_get_vector_elements(var->type);
|
|
|
|
|
|
|
|
nir_intrinsic_instr *load =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_load_var);
|
|
|
|
load->num_components = num_components;
|
|
|
|
load->variables[0] = nir_deref_var_create(load, var);
|
2015-11-17 12:57:54 +00:00
|
|
|
nir_ssa_dest_init(&load->instr, &load->dest, num_components,
|
2016-05-11 20:05:09 +01:00
|
|
|
glsl_get_bit_size(var->type), NULL);
|
2015-05-12 09:53:24 +01:00
|
|
|
nir_builder_instr_insert(build, &load->instr);
|
|
|
|
return &load->dest.ssa;
|
|
|
|
}
|
|
|
|
|
2016-12-10 19:32:29 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_load_deref_var(nir_builder *build, nir_deref_var *deref)
|
|
|
|
{
|
|
|
|
const struct glsl_type *type = nir_deref_tail(&deref->deref)->type;
|
|
|
|
const unsigned num_components = glsl_get_vector_elements(type);
|
|
|
|
|
|
|
|
nir_intrinsic_instr *load =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_load_var);
|
|
|
|
load->num_components = num_components;
|
|
|
|
load->variables[0] = nir_deref_var_clone(deref, load);
|
|
|
|
nir_ssa_dest_init(&load->instr, &load->dest, num_components,
|
|
|
|
glsl_get_bit_size(type), NULL);
|
|
|
|
nir_builder_instr_insert(build, &load->instr);
|
|
|
|
return &load->dest.ssa;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
|
|
|
const unsigned num_components = glsl_get_vector_elements(var->type);
|
|
|
|
|
|
|
|
nir_intrinsic_instr *store =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_store_var);
|
|
|
|
store->num_components = num_components;
|
2016-01-21 19:12:58 +00:00
|
|
|
nir_intrinsic_set_write_mask(store, writemask);
|
2015-05-12 09:53:24 +01:00
|
|
|
store->variables[0] = nir_deref_var_create(store, var);
|
|
|
|
store->src[0] = nir_src_for_ssa(value);
|
|
|
|
nir_builder_instr_insert(build, &store->instr);
|
|
|
|
}
|
|
|
|
|
2016-03-25 17:35:03 +00:00
|
|
|
static inline void
|
|
|
|
nir_store_deref_var(nir_builder *build, nir_deref_var *deref,
|
|
|
|
nir_ssa_def *value, unsigned writemask)
|
|
|
|
{
|
|
|
|
const unsigned num_components =
|
|
|
|
glsl_get_vector_elements(nir_deref_tail(&deref->deref)->type);
|
|
|
|
|
|
|
|
nir_intrinsic_instr *store =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_store_var);
|
|
|
|
store->num_components = num_components;
|
|
|
|
store->const_index[0] = writemask & ((1 << num_components) - 1);
|
2016-12-24 17:42:34 +00:00
|
|
|
store->variables[0] = nir_deref_var_clone(deref, store);
|
2016-03-25 17:35:03 +00:00
|
|
|
store->src[0] = nir_src_for_ssa(value);
|
|
|
|
nir_builder_instr_insert(build, &store->instr);
|
|
|
|
}
|
|
|
|
|
2015-12-26 18:48:14 +00:00
|
|
|
static inline void
|
|
|
|
nir_copy_deref_var(nir_builder *build, nir_deref_var *dest, nir_deref_var *src)
|
|
|
|
{
|
|
|
|
assert(nir_deref_tail(&dest->deref)->type ==
|
|
|
|
nir_deref_tail(&src->deref)->type);
|
|
|
|
|
|
|
|
nir_intrinsic_instr *copy =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_copy_var);
|
2016-12-24 17:42:34 +00:00
|
|
|
copy->variables[0] = nir_deref_var_clone(dest, copy);
|
|
|
|
copy->variables[1] = nir_deref_var_clone(src, copy);
|
2015-12-26 18:48:14 +00:00
|
|
|
nir_builder_instr_insert(build, ©->instr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
nir_copy_var(nir_builder *build, nir_variable *dest, nir_variable *src)
|
|
|
|
{
|
|
|
|
nir_intrinsic_instr *copy =
|
|
|
|
nir_intrinsic_instr_create(build->shader, nir_intrinsic_copy_var);
|
|
|
|
copy->variables[0] = nir_deref_var_create(copy, dest);
|
|
|
|
copy->variables[1] = nir_deref_var_create(copy, src);
|
|
|
|
nir_builder_instr_insert(build, ©->instr);
|
|
|
|
}
|
|
|
|
|
2016-08-06 01:10:18 +01:00
|
|
|
/* Generic builder for system values. */
|
2015-12-15 02:46:16 +00:00
|
|
|
static inline nir_ssa_def *
|
|
|
|
nir_load_system_value(nir_builder *build, nir_intrinsic_op op, int index)
|
|
|
|
{
|
|
|
|
nir_intrinsic_instr *load = nir_intrinsic_instr_create(build->shader, op);
|
|
|
|
load->num_components = nir_intrinsic_infos[op].dest_components;
|
|
|
|
load->const_index[0] = index;
|
|
|
|
nir_ssa_dest_init(&load->instr, &load->dest,
|
2015-11-17 12:57:54 +00:00
|
|
|
nir_intrinsic_infos[op].dest_components, 32, NULL);
|
2015-12-15 02:46:16 +00:00
|
|
|
nir_builder_instr_insert(build, &load->instr);
|
|
|
|
return &load->dest.ssa;
|
|
|
|
}
|
|
|
|
|
2016-08-06 01:10:18 +01:00
|
|
|
/* Generate custom builders for system values. */
|
|
|
|
#define INTRINSIC(name, num_srcs, src_components, has_dest, dest_components, \
|
|
|
|
num_variables, num_indices, idx0, idx1, idx2, flags)
|
|
|
|
#define LAST_INTRINSIC(name)
|
|
|
|
|
|
|
|
#define DEFINE_SYSTEM_VALUE(name) \
|
|
|
|
static inline nir_ssa_def * \
|
|
|
|
nir_load_##name(nir_builder *build) \
|
|
|
|
{ \
|
|
|
|
return nir_load_system_value(build, nir_intrinsic_load_##name, 0); \
|
|
|
|
} \
|
|
|
|
|
|
|
|
#include "nir_intrinsics.h"
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2014-11-10 19:16:30 +00:00
|
|
|
#endif /* NIR_BUILDER_H */
|