diff options
| -rw-r--r-- | src/glsl/Makefile.sources | 2 | ||||
| -rw-r--r-- | src/glsl/nir/nir.h | 1150 | ||||
| -rw-r--r-- | src/glsl/nir/nir_intrinsics.c | 49 | ||||
| -rw-r--r-- | src/glsl/nir/nir_intrinsics.h | 158 | ||||
| -rw-r--r-- | src/glsl/nir/nir_opcodes.c | 46 | ||||
| -rw-r--r-- | src/glsl/nir/nir_opcodes.h | 346 |
6 files changed, 1751 insertions, 0 deletions
diff --git a/src/glsl/Makefile.sources b/src/glsl/Makefile.sources index c3a90f77596..e8eedd14d01 100644 --- a/src/glsl/Makefile.sources +++ b/src/glsl/Makefile.sources @@ -14,6 +14,8 @@ LIBGLCPP_GENERATED_FILES = \ $(GLSL_BUILDDIR)/glcpp/glcpp-parse.c NIR_FILES = \ + $(GLSL_SRCDIR)/nir/nir_intrinsics.c \ + $(GLSL_SRCDIR)/nir/nir_opcodes.c \ $(GLSL_SRCDIR)/nir/nir_types.cpp # libglsl diff --git a/src/glsl/nir/nir.h b/src/glsl/nir/nir.h new file mode 100644 index 00000000000..7e9ddf755aa --- /dev/null +++ b/src/glsl/nir/nir.h @@ -0,0 +1,1150 @@ +/* + * Copyright © 2014 Connor Abbott + * + * 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. + * + * Authors: + * Connor Abbott ([email protected]) + * + */ + +#pragma once + +#include "util/hash_table.h" +#include "main/set.h" +#include "../list.h" +#include "GL/gl.h" /* GLenum */ +#include "util/ralloc.h" +#include "nir_types.h" +#include <stdio.h> + +#ifdef __cplusplus +extern "C" { +#endif + +struct nir_function_overload; +struct nir_function; + + +/** + * Description of built-in state associated with a uniform + * + * \sa nir_variable::state_slots + */ +typedef struct { + int tokens[5]; + int swizzle; +} nir_state_slot; + +typedef enum { + nir_var_shader_in, + nir_var_shader_out, + nir_var_global, + nir_var_local, + nir_var_uniform, + nir_var_system_value +} nir_variable_mode; + +/** + * Data stored in an nir_constant + */ +union nir_constant_data { + unsigned u[16]; + int i[16]; + float f[16]; + bool b[16]; +}; + +typedef struct nir_constant { + /** + * Value of the constant. + * + * The field used to back the values supplied by the constant is determined + * by the type associated with the \c ir_instruction. Constants may be + * scalars, vectors, or matrices. + */ + union nir_constant_data value; + + /* Array elements / Structure Fields */ + struct nir_constant **elements; +} nir_constant; + +/** + * \brief Layout qualifiers for gl_FragDepth. + * + * The AMD/ARB_conservative_depth extensions allow gl_FragDepth to be redeclared + * with a layout qualifier. + */ +typedef enum { + nir_depth_layout_none, /**< No depth layout is specified. */ + nir_depth_layout_any, + nir_depth_layout_greater, + nir_depth_layout_less, + nir_depth_layout_unchanged +} nir_depth_layout; + +/** + * Either a uniform, global variable, shader input, or shader output. Based on + * ir_variable - it should be easy to translate between the two. + */ + +typedef struct { + struct exec_node node; + + /** + * Declared type of the variable + */ + const struct glsl_type *type; + + /** + * Declared name of the variable + */ + char *name; + + /** + * For variables which satisfy the is_interface_instance() predicate, this + * points to an array of integers such that if the ith member of the + * interface block is an array, max_ifc_array_access[i] is the maximum + * array element of that member that has been accessed. If the ith member + * of the interface block is not an array, max_ifc_array_access[i] is + * unused. + * + * For variables whose type is not an interface block, this pointer is + * NULL. + */ + unsigned *max_ifc_array_access; + + struct nir_variable_data { + + /** + * Is the variable read-only? + * + * This is set for variables declared as \c const, shader inputs, + * and uniforms. + */ + unsigned read_only:1; + unsigned centroid:1; + unsigned sample:1; + unsigned invariant:1; + + /** + * Storage class of the variable. + * + * \sa nir_variable_mode + */ + unsigned mode:4; + + /** + * Interpolation mode for shader inputs / outputs + * + * \sa ir_variable_interpolation + */ + unsigned interpolation:2; + + /** + * \name ARB_fragment_coord_conventions + * @{ + */ + unsigned origin_upper_left:1; + unsigned pixel_center_integer:1; + /*@}*/ + + /** + * Was the location explicitly set in the shader? + * + * If the location is explicitly set in the shader, it \b cannot be changed + * by the linker or by the API (e.g., calls to \c glBindAttribLocation have + * no effect). + */ + unsigned explicit_location:1; + unsigned explicit_index:1; + + /** + * Was an initial binding explicitly set in the shader? + * + * If so, constant_value contains an integer ir_constant representing the + * initial binding point. + */ + unsigned explicit_binding:1; + + /** + * Does this variable have an initializer? + * + * This is used by the linker to cross-validiate initializers of global + * variables. + */ + unsigned has_initializer:1; + + /** + * Is this variable a generic output or input that has not yet been matched + * up to a variable in another stage of the pipeline? + * + * This is used by the linker as scratch storage while assigning locations + * to generic inputs and outputs. + */ + unsigned is_unmatched_generic_inout:1; + + /** + * If non-zero, then this variable may be packed along with other variables + * into a single varying slot, so this offset should be applied when + * accessing components. For example, an offset of 1 means that the x + * component of this variable is actually stored in component y of the + * location specified by \c location. + */ + unsigned location_frac:2; + + /** + * Non-zero if this variable was created by lowering a named interface + * block which was not an array. + * + * Note that this variable and \c from_named_ifc_block_array will never + * both be non-zero. + */ + unsigned from_named_ifc_block_nonarray:1; + + /** + * Non-zero if this variable was created by lowering a named interface + * block which was an array. + * + * Note that this variable and \c from_named_ifc_block_nonarray will never + * both be non-zero. + */ + unsigned from_named_ifc_block_array:1; + + /** + * \brief Layout qualifier for gl_FragDepth. + * + * This is not equal to \c ir_depth_layout_none if and only if this + * variable is \c gl_FragDepth and a layout qualifier is specified. + */ + nir_depth_layout depth_layout; + + /** + * Storage location of the base of this variable + * + * The precise meaning of this field depends on the nature of the variable. + * + * - Vertex shader input: one of the values from \c gl_vert_attrib. + * - Vertex shader output: one of the values from \c gl_varying_slot. + * - Geometry shader input: one of the values from \c gl_varying_slot. + * - Geometry shader output: one of the values from \c gl_varying_slot. + * - Fragment shader input: one of the values from \c gl_varying_slot. + * - Fragment shader output: one of the values from \c gl_frag_result. + * - Uniforms: Per-stage uniform slot number for default uniform block. + * - Uniforms: Index within the uniform block definition for UBO members. + * - Other: This field is not currently used. + * + * If the variable is a uniform, shader input, or shader output, and the + * slot has not been assigned, the value will be -1. + */ + int location; + + /** + * The actual location of the variable in the IR. Only valid for inputs + * and outputs. + */ + unsigned int driver_location; + + /** + * output index for dual source blending. + */ + int index; + + /** + * Initial binding point for a sampler or UBO. + * + * For array types, this represents the binding point for the first element. + */ + int binding; + + /** + * Location an atomic counter is stored at. + */ + struct { + unsigned buffer_index; + unsigned offset; + } atomic; + + /** + * ARB_shader_image_load_store qualifiers. + */ + struct { + bool read_only; /**< "readonly" qualifier. */ + bool write_only; /**< "writeonly" qualifier. */ + bool coherent; + bool _volatile; + bool restrict_flag; + + /** Image internal format if specified explicitly, otherwise GL_NONE. */ + GLenum format; + } image; + + /** + * Highest element accessed with a constant expression array index + * + * Not used for non-array variables. + */ + unsigned max_array_access; + + } data; + + /** + * Built-in state that backs this uniform + * + * Once set at variable creation, \c state_slots must remain invariant. + * This is because, ideally, this array would be shared by all clones of + * this variable in the IR tree. In other words, we'd really like for it + * to be a fly-weight. + * + * If the variable is not a uniform, \c num_state_slots will be zero and + * \c state_slots will be \c NULL. + */ + /*@{*/ + unsigned num_state_slots; /**< Number of state slots used */ + nir_state_slot *state_slots; /**< State descriptors. */ + /*@}*/ + + /** + * Value assigned in the initializer of a variable declared "const" + */ + nir_constant *constant_value; + + /** + * Constant expression assigned in the initializer of the variable + * + * \warning + * This field and \c ::constant_value are distinct. Even if the two fields + * refer to constants with the same value, they must point to separate + * objects. + */ + nir_constant *constant_initializer; + + /** + * For variables that are in an interface block or are an instance of an + * interface block, this is the \c GLSL_TYPE_INTERFACE type for that block. + * + * \sa ir_variable::location + */ + const struct glsl_type *interface_type; +} nir_variable; + +typedef struct { + struct exec_node node; + + unsigned num_components; /** < number of vector components */ + unsigned num_array_elems; /** < size of array (0 for no array) */ + + /** for liveness analysis, the index in the bit-array of live variables */ + unsigned index; + + /** only for debug purposes, can be NULL */ + const char *name; + + /** whether this register is local (per-function) or global (per-shader) */ + bool is_global; + + /** + * If this flag is set to true, then accessing channels >= num_components + * is well-defined, and simply spills over to the next array element. This + * is useful for backends that can do per-component accessing, in + * particular scalar backends. By setting this flag and making + * num_components equal to 1, structures can be packed tightly into + * registers and then registers can be accessed per-component to get to + * each structure member, even if it crosses vec4 boundaries. + */ + bool is_packed; + + /** set of nir_instr's where this register is used (read from) */ + struct set *uses; + + /** set of nir_instr's where this register is defined (written to) */ + struct set *defs; + + /** set of ifs where this register is used as a condition */ + struct set *if_uses; +} nir_register; + +typedef enum { + nir_instr_type_alu, + nir_instr_type_call, + nir_instr_type_texture, + nir_instr_type_intrinsic, + nir_instr_type_load_const, + nir_instr_type_jump, + nir_instr_type_ssa_undef, + nir_instr_type_phi, +} nir_instr_type; + +typedef struct { + struct exec_node node; + nir_instr_type type; + struct nir_block *block; +} nir_instr; + +#define nir_instr_next(instr) \ + exec_node_data(nir_instr, (instr)->node.next, node) + +#define nir_instr_prev(instr) \ + exec_node_data(nir_instr, (instr)->node.prev, node) + +typedef struct { + /** for debugging only, can be NULL */ + const char* name; + + /** index into the bit-array for liveness analysis */ + unsigned index; + + nir_instr *parent_instr; + + struct set *uses; + struct set *if_uses; + + uint8_t num_components; +} nir_ssa_def; + +struct nir_src; + +typedef struct { + nir_register *reg; + struct nir_src *indirect; /** < NULL for no indirect offset */ + unsigned base_offset; + + /* TODO use-def chain goes here */ +} nir_reg_src; + +typedef struct { + nir_register *reg; + struct nir_src *indirect; /** < NULL for no indirect offset */ + unsigned base_offset; + + /* TODO def-use chain goes here */ +} nir_reg_dest; + +typedef struct nir_src { + union { + nir_reg_src reg; + nir_ssa_def *ssa; + }; + + bool is_ssa; +} nir_src; + +typedef struct { + union { + nir_reg_dest reg; + nir_ssa_def ssa; + }; + + bool is_ssa; +} nir_dest; + +nir_src nir_src_copy(nir_src src, void *mem_ctx); +nir_dest nir_dest_copy(nir_dest dest, void *mem_ctx); + +typedef struct { + nir_src src; + + /** + * \name input modifiers + */ + /*@{*/ + /** + * For inputs interpreted as a floating point, flips the sign bit. For inputs + * interpreted as an integer, performs the two's complement negation. + */ + bool negate; + + /** + * Clears the sign bit for floating point values, and computes the integer + * absolute value for integers. Note that the negate modifier acts after + * the absolute value modifier, therefore if both are set then all inputs + * will become negative. + */ + bool abs; + /*@}*/ + + /** + * For each input component, says which component of the register it is + * chosen from. Note that which elements of the swizzle are used and which + * are ignored are based on the write mask for most opcodes - for example, + * a statement like "foo.xzw = bar.zyx" would have a writemask of 1101b and + * a swizzle of {2, x, 1, 0} where x means "don't care." + */ + uint8_t swizzle[4]; +} nir_alu_src; + +typedef struct { + nir_dest dest; + + /** + * \name saturate output modifier + * + * Only valid for opcodes that output floating-point numbers. Clamps the + * output to between 0.0 and 1.0 inclusive. + */ + + bool saturate; + + unsigned write_mask : 4; /* ignored if dest.is_ssa is true */ +} nir_alu_dest; + +#define OPCODE(name, num_inputs, per_component, output_size, output_type, \ + input_sizes, input_types) \ + nir_op_##name, + +#define LAST_OPCODE(name) nir_last_opcode = nir_op_##name, + +typedef enum { +#include "nir_opcodes.h" + nir_num_opcodes = nir_last_opcode + 1 +} nir_op; + +#undef OPCODE +#undef LAST_OPCODE + +typedef enum { + nir_type_float, + nir_type_int, + nir_type_unsigned, + nir_type_bool +} nir_alu_type; + +typedef struct { + const char *name; + + unsigned num_inputs; + + /** + * If true, the opcode acts in the standard, per-component manner; the + * operation is performed on each component (except the ones that are masked + * out) with the input being taken from the input swizzle for that component. + * + * If false, the size of the output and inputs are explicitly given; swizzle + * and writemask are still in effect, but if the output component is masked + * out, then the input component may still be in use. + * + * The size of some of the inputs may be given (i.e. non-zero) even though + * per_component is false; in that case, each component of the input acts + * per-component, while the rest of the inputs and the output are normal. + * For example, for conditional select the condition is per-component but + * everything else is normal. + */ + bool per_component; + + /** + * If per_component is false, the number of components in the output. + */ + unsigned output_size; + + /** + * The type of vector that the instruction outputs. Note that this + * determines whether the saturate modifier is allowed. + */ + + nir_alu_type output_type; + + /** + * If per_component is false, the number of components in each input. + */ + unsigned input_sizes[4]; + + /** + * The type of vector that each input takes. Note that negate is only + * allowed on inputs with int or float type, and behaves differently on the + * two, and absolute value is only allowed on float type inputs. + */ + nir_alu_type input_types[4]; +} nir_op_info; + +extern const nir_op_info nir_op_infos[nir_num_opcodes]; + +typedef struct nir_alu_instr { + nir_instr instr; + nir_op op; + bool has_predicate; + nir_src predicate; + nir_alu_dest dest; + nir_alu_src src[]; +} nir_alu_instr; + +/* is this source channel used? */ +static inline bool +nir_alu_instr_channel_used(nir_alu_instr *instr, unsigned src, unsigned channel) +{ + if (nir_op_infos[instr->op].input_sizes[src] > 0) + return channel < nir_op_infos[instr->op].input_sizes[src]; + + return (instr->dest.write_mask >> channel) & 1; +} + +typedef enum { + nir_deref_type_var, + nir_deref_type_array, + nir_deref_type_struct +} nir_deref_type; + +typedef struct nir_deref { + nir_deref_type deref_type; + struct nir_deref *child; + const struct glsl_type *type; +} nir_deref; + +typedef struct { + nir_deref deref; + + nir_variable *var; +} nir_deref_var; + +typedef struct { + nir_deref deref; + + unsigned base_offset; + bool has_indirect; + nir_src indirect; +} nir_deref_array; + +typedef struct { + nir_deref deref; + + const char *elem; +} nir_deref_struct; + +#define nir_deref_as_var(_deref) exec_node_data(nir_deref_var, _deref, deref) +#define nir_deref_as_array(_deref) \ + exec_node_data(nir_deref_array, _deref, deref) +#define nir_deref_as_struct(_deref) \ + exec_node_data(nir_deref_struct, _deref, deref) + +typedef struct { + nir_instr instr; + + unsigned num_params; + nir_deref_var **params; + nir_deref_var *return_deref; + + bool has_predicate; + nir_src predicate; + + struct nir_function_overload *callee; +} nir_call_instr; + +#define INTRINSIC(name, num_srcs, src_components, has_dest, dest_components, \ + num_variables, num_indices, flags) \ + nir_intrinsic_##name, + +#define LAST_INTRINSIC(name) nir_last_intrinsic = nir_intrinsic_##name, + +typedef enum { +#include "nir_intrinsics.h" + nir_num_intrinsics = nir_last_intrinsic + 1 +} nir_intrinsic_op; + +#undef INTRINSIC +#undef LAST_INTRINSIC + +typedef struct { + nir_instr instr; + + nir_intrinsic_op intrinsic; + + nir_dest dest; + + int const_index[3]; + + nir_deref_var *variables[2]; + + bool has_predicate; + nir_src predicate; + + nir_src src[]; +} nir_intrinsic_instr; + +/** + * \name NIR intrinsics semantic flags + * + * information about what the compiler can do with the intrinsics. + * + * \sa nir_intrinsic_info::flags + */ +/*@{*/ +/** + * whether the intrinsic can be safely eliminated if none of its register + * outputs are being used. + */ +#define NIR_INTRINSIC_CAN_ELIMINATE (1 << 0) + +/** + * Whether the intrinsic can be reordered with respect to any other intrinsic, + * i.e. whether the only reodering dependencies of the intrinsic are due to the + * register reads/writes. + */ +#define NIR_INTRINSIC_CAN_REORDER (1 << 1) +/*@}*/ + +#define NIR_INTRINSIC_MAX_INPUTS 4 + +typedef struct { + const char *name; + + unsigned num_srcs; /** < number of register/SSA inputs */ + + /** number of components of each input register */ + unsigned src_components[NIR_INTRINSIC_MAX_INPUTS]; + + bool has_dest; + + /** number of components of each output register */ + unsigned dest_components; + + /** the number of inputs/outputs that are variables */ + unsigned num_variables; + + /** the number of constant indices used by the intrinsic */ + unsigned num_indices; + + /** semantic flags for calls to this intrinsic */ + unsigned flags; +} nir_intrinsic_info; + +extern const nir_intrinsic_info nir_intrinsic_infos[nir_num_intrinsics]; + +/** + * \group texture information + * + * This gives semantic information about textures which is useful to the + * frontend, the backend, and lowering passes, but not the optimizer. + */ + +typedef enum { + nir_tex_src_coord, + nir_tex_src_projector, + nir_tex_src_comparitor, /* shadow comparitor */ + nir_tex_src_offset, + nir_tex_src_bias, + nir_tex_src_lod, + nir_tex_src_ms_index, /* MSAA sample index */ + nir_tex_src_ddx, + nir_tex_src_ddy, + nir_tex_src_sampler_index, /* < dynamically uniform indirect index */ + nir_num_texinput_types +} nir_texinput_type; + +typedef enum { + nir_texop_tex, /**< Regular texture look-up */ + nir_texop_txb, /**< Texture look-up with LOD bias */ + nir_texop_txl, /**< Texture look-up with explicit LOD */ + nir_texop_txd, /**< Texture look-up with partial derivatvies */ + nir_texop_txf, /**< Texel fetch with explicit LOD */ + nir_texop_txf_ms, /**< Multisample texture fetch */ + nir_texop_txs, /**< Texture size */ + nir_texop_lod, /**< Texture lod query */ + nir_texop_tg4, /**< Texture gather */ + nir_texop_query_levels /**< Texture levels query */ +} nir_texop; + +typedef struct { + nir_instr instr; + + bool has_predicate; + nir_src predicate; + + enum glsl_sampler_dim sampler_dim; + nir_alu_type dest_type; + + nir_texop op; + nir_dest dest; + nir_src src[4]; + nir_texinput_type src_type[4]; + unsigned num_srcs, coord_components; + bool is_array, is_shadow; + + /** + * If is_shadow is true, whether this is the old-style shadow that outputs 4 + * components or the new-style shadow that outputs 1 component. + */ + bool is_new_style_shadow; + + /* constant offset - must be 0 if the offset source is used */ + int const_offset[4]; + + /* gather component selector */ + unsigned component : 2; + + unsigned sampler_index; + nir_deref_var *sampler; /* if this is NULL, use sampler_index instead */ +} nir_tex_instr; + +static inline unsigned +nir_tex_instr_dest_size(nir_tex_instr *instr) +{ + if (instr->op == nir_texop_txs) { + unsigned ret; + switch (instr->sampler_dim) { + case GLSL_SAMPLER_DIM_1D: + case GLSL_SAMPLER_DIM_BUF: + ret = 1; + break; + case GLSL_SAMPLER_DIM_2D: + case GLSL_SAMPLER_DIM_CUBE: + case GLSL_SAMPLER_DIM_MS: + case GLSL_SAMPLER_DIM_RECT: + case GLSL_SAMPLER_DIM_EXTERNAL: + ret = 2; + break; + case GLSL_SAMPLER_DIM_3D: + ret = 3; + break; + default: + assert(0); + break; + } + if (instr->is_array) + ret++; + return ret; + } + + if (instr->op == nir_texop_query_levels) + return 2; + + if (instr->is_shadow && instr->is_new_style_shadow) + return 1; + + return 4; +} + +static inline unsigned +nir_tex_instr_src_size(nir_tex_instr *instr, unsigned src) +{ + if (instr->src_type[src] == nir_tex_src_coord) + return instr->coord_components; + + + if (instr->src_type[src] == nir_tex_src_offset || + instr->src_type[src] == nir_tex_src_ddx || + instr->src_type[src] == nir_tex_src_ddy) { + if (instr->is_array) + return instr->coord_components - 1; + else + return instr->coord_components; + } + + return 1; +} + +static inline int +nir_tex_instr_src_index(nir_tex_instr *instr, nir_texinput_type type) +{ + for (unsigned i = 0; i < instr->num_srcs; i++) + if (instr->src_type[i] == type) + return (int) i; + + return -1; +} + +typedef struct { + union { + float f[4]; + int32_t i[4]; + uint32_t u[4]; + }; +} nir_const_value; + +typedef struct { + nir_instr instr; + + union { + nir_const_value value; + nir_const_value *array; + }; + + unsigned num_components; + + /** + * The number of constant array elements to be copied into the variable. If + * this != 0, then value.array holds the array of size array_elems; + * otherwise, value.value holds the single vector constant (the more common + * case, and the only case for SSA destinations). + */ + unsigned array_elems; + + bool has_predicate; + nir_src predicate; + + nir_dest dest; +} nir_load_const_instr; + +typedef enum { + nir_jump_return, + nir_jump_break, + nir_jump_continue, +} nir_jump_type; + +typedef struct { + nir_instr instr; + nir_jump_type type; +} nir_jump_instr; + +/* creates a new SSA variable in an undefined state */ + +typedef struct { + nir_instr instr; + nir_ssa_def def; +} nir_ssa_undef_instr; + +typedef struct { + struct exec_node node; + struct nir_block *pred; + nir_src src; +} nir_phi_src; + +typedef struct { + nir_instr instr; + + struct exec_list srcs; + nir_dest dest; +} nir_phi_instr; + +#define nir_instr_as_alu(_instr) exec_node_data(nir_alu_instr, _instr, instr) +#define nir_instr_as_call(_instr) exec_node_data(nir_call_instr, _instr, instr) +#define nir_instr_as_jump(_instr) exec_node_data(nir_jump_instr, _instr, instr) +#define nir_instr_as_texture(_instr) \ + exec_node_data(nir_tex_instr, _instr, instr) +#define nir_instr_as_intrinsic(_instr) \ + exec_node_data(nir_intrinsic_instr, _instr, instr) +#define nir_instr_as_load_const(_instr) \ + exec_node_data(nir_load_const_instr, _instr, instr) +#define nir_instr_as_ssa_undef(_instr) \ + exec_node_data(nir_ssa_undef_instr, _instr, instr) +#define nir_instr_as_phi(_instr) \ + exec_node_data(nir_phi_instr, _instr, instr) + + +/* + * Control flow + * + * Control flow consists of a tree of control flow nodes, which include + * if-statements and loops. The leaves of the tree are basic blocks, lists of + * instructions that always run start-to-finish. Each basic block also keeps + * track of its successors (blocks which may run immediately after the current + * block) and predecessors (blocks which could have run immediately before the + * current block). Each function also has a start block and an end block which + * all return statements point to (which is always empty). Together, all the + * blocks with their predecessors and successors make up the control flow + * graph (CFG) of the function. There are helpers that modify the tree of + * control flow nodes while modifying the CFG appropriately; these should be + * used instead of modifying the tree directly. + */ + +typedef enum { + nir_cf_node_block, + nir_cf_node_if, + nir_cf_node_loop, + nir_cf_node_function +} nir_cf_node_type; + +typedef struct nir_cf_node { + struct exec_node node; + nir_cf_node_type type; + struct nir_cf_node *parent; +} nir_cf_node; + +typedef struct nir_block { + nir_cf_node cf_node; + struct exec_list instr_list; + + unsigned index; + + /* + * Each block can only have up to 2 successors, so we put them in a simple + * array - no need for anything more complicated. + */ + struct nir_block *successors[2]; + + struct set *predecessors; +} nir_block; + +#define nir_block_first_instr(block) \ + exec_node_data(nir_instr, exec_list_get_head(&(block)->instr_list), node) +#define nir_block_last_instr(block) \ + exec_node_data(nir_instr, exec_list_get_tail(&(block)->instr_list), node) + +#define nir_foreach_instr(block, instr) \ + foreach_list_typed(nir_instr, instr, node, &(block)->instr_list) +#define nir_foreach_instr_reverse(block, instr) \ + foreach_list_typed_reverse(nir_instr, instr, node, &(block)->instr_list) +#define nir_foreach_instr_safe(block, instr) \ + foreach_list_typed_safe(nir_instr, instr, node, &(block)->instr_list) + +typedef struct { + nir_cf_node cf_node; + nir_src condition; + struct exec_list then_list; + struct exec_list else_list; +} nir_if; + +#define nir_if_first_then_node(if) \ + exec_node_data(nir_cf_node, exec_list_get_head(&(if)->then_list), node) +#define nir_if_last_then_node(if) \ + exec_node_data(nir_cf_node, exec_list_get_tail(&(if)->then_list), node) +#define nir_if_first_else_node(if) \ + exec_node_data(nir_cf_node, exec_list_get_head(&(if)->else_list), node) +#define nir_if_last_else_node(if) \ + exec_node_data(nir_cf_node, exec_list_get_tail(&(if)->else_list), node) + +typedef struct { + nir_cf_node cf_node; + struct exec_list body; +} nir_loop; + +#define nir_loop_first_cf_node(loop) \ + exec_node_data(nir_cf_node, exec_list_get_head(&(loop)->body), node) +#define nir_loop_last_cf_node(loop) \ + exec_node_data(nir_cf_node, exec_list_get_tail(&(loop)->body), node) + +typedef struct { + nir_cf_node cf_node; + + /** pointer to the overload of which this is an implementation */ + struct nir_function_overload *overload; + + struct exec_list body; /** < list of nir_cf_node */ + + nir_block *start_block, *end_block; + + /** list for all local variables in the function */ + struct exec_list locals; + + /** array of variables used as parameters */ + unsigned num_params; + nir_variable **params; + + /** variable used to hold the result of the function */ + nir_variable *return_var; + + /** list of local registers in the function */ + struct exec_list registers; + + /** next available local register index */ + unsigned reg_alloc; + + /** next available SSA value index */ + unsigned ssa_alloc; + + /* total number of basic blocks, only valid when block_index_dirty = false */ + unsigned num_blocks; + + bool block_index_dirty; +} nir_function_impl; + +#define nir_cf_node_next(_node) \ + exec_node_data(nir_cf_node, exec_node_get_next(&(_node)->node), node) + +#define nir_cf_node_prev(_node) \ + exec_node_data(nir_cf_node, exec_node_get_prev(&(_node)->node), node) + +#define nir_cf_node_is_first(_node) \ + exec_node_is_head_sentinel((_node)->node.prev) + +#define nir_cf_node_is_last(_node) \ + exec_node_is_tail_sentinel((_node)->node.next) + +#define nir_cf_node_as_block(node) \ + exec_node_data(nir_block, node, cf_node) + +#define nir_cf_node_as_if(node) \ + exec_node_data(nir_if, node, cf_node) + +#define nir_cf_node_as_loop(node) \ + exec_node_data(nir_loop, node, cf_node) + +#define nir_cf_node_as_function(node) \ + exec_node_data(nir_function_impl, node, cf_node) + +typedef enum { + nir_parameter_in, + nir_parameter_out, + nir_parameter_inout, +} nir_parameter_type; + +typedef struct { + nir_parameter_type param_type; + const struct glsl_type *type; +} nir_parameter; + +typedef struct nir_function_overload { + struct exec_node node; + + unsigned num_params; + nir_parameter *params; + const struct glsl_type *return_type; + + nir_function_impl *impl; /** < NULL if the overload is only declared yet */ + + /** pointer to the function of which this is an overload */ + struct nir_function *function; +} nir_function_overload; + +typedef struct nir_function { + struct exec_node node; + + struct exec_list overload_list; + const char *name; +} nir_function; + +#define nir_function_first_overload(func) \ + exec_node_data(nir_function_overload, \ + exec_list_get_head(&(func)->overload_list), node) + +typedef struct nir_shader { + /** hash table of name -> uniform */ + struct hash_table *uniforms; + + /** hash table of name -> input */ + struct hash_table *inputs; + + /** hash table of name -> output */ + struct hash_table *outputs; + + /** list of global variables in the shader */ + struct exec_list globals; + + struct exec_list system_values; + + struct exec_list functions; + + /** list of global registers in the shader */ + struct exec_list registers; + + /** structures used in this shader */ + unsigned num_user_structures; + struct glsl_type **user_structures; + + /** next available global register index */ + unsigned reg_alloc; +} nir_shader; + +#define nir_foreach_overload(shader, overload) \ + foreach_list_typed(nir_function, func, node, &(shader)->functions) \ + foreach_list_typed(nir_function_overload, overload, node, \ + &(func)->overload_list) + +#ifdef __cplusplus +} /* extern "C" */ +#endif diff --git a/src/glsl/nir/nir_intrinsics.c b/src/glsl/nir/nir_intrinsics.c new file mode 100644 index 00000000000..a7c868c39af --- /dev/null +++ b/src/glsl/nir/nir_intrinsics.c @@ -0,0 +1,49 @@ +/* + * Copyright © 2014 Intel Corporation + * + * 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. + * + * Authors: + * Connor Abbott ([email protected]) + * + */ + +#include "nir.h" + +#define OPCODE(name) nir_intrinsic_##name + +#define INTRINSIC(_name, _num_srcs, _src_components, _has_dest, \ + _dest_components, _num_variables, _num_indices, _flags) \ +{ \ + .name = #_name, \ + .num_srcs = _num_srcs, \ + .src_components = _src_components, \ + .has_dest = _has_dest, \ + .dest_components = _dest_components, \ + .num_variables = _num_variables, \ + .num_indices = _num_indices, \ + .flags = _flags \ +}, + +#define LAST_INTRINSIC(name) + +const nir_intrinsic_info nir_intrinsic_infos[nir_num_intrinsics] = { +#include "nir_intrinsics.h" +};
\ No newline at end of file diff --git a/src/glsl/nir/nir_intrinsics.h b/src/glsl/nir/nir_intrinsics.h new file mode 100644 index 00000000000..e82152c7f9e --- /dev/null +++ b/src/glsl/nir/nir_intrinsics.h @@ -0,0 +1,158 @@ +/* + * Copyright © 2014 Intel Corporation + * + * 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. + * + * Authors: + * Connor Abbott ([email protected]) + * + */ + +/** + * This header file defines all the available intrinsics in one place. It + * expands to a list of macros of the form: + * + * INTRINSIC(name, num_srcs, src_components, has_dest, dest_components, + * num_variables, num_indices, flags) + * + * Which should correspond one-to-one with the nir_intrinsic_info structure. It + * is included in both ir.h to create the nir_intrinsic enum (with members of + * the form nir_intrinsic_(name)) and and in opcodes.c to create + * nir_intrinsic_infos, which is a const array of nir_intrinsic_info structures + * for each intrinsic. + */ + +#define ARR(...) { __VA_ARGS__ } + + +INTRINSIC(load_var_vec1, 0, ARR(), true, 1, 1, 0, + NIR_INTRINSIC_CAN_ELIMINATE) +INTRINSIC(load_var_vec2, 0, ARR(), true, 2, 1, 0, + NIR_INTRINSIC_CAN_ELIMINATE) +INTRINSIC(load_var_vec3, 0, ARR(), true, 3, 1, 0, + NIR_INTRINSIC_CAN_ELIMINATE) +INTRINSIC(load_var_vec4, 0, ARR(), true, 4, 1, 0, + NIR_INTRINSIC_CAN_ELIMINATE) +INTRINSIC(store_var_vec1, 1, ARR(1), false, 0, 1, 0, 0) +INTRINSIC(store_var_vec2, 1, ARR(2), false, 0, 1, 0, 0) +INTRINSIC(store_var_vec3, 1, ARR(3), false, 0, 1, 0, 0) +INTRINSIC(store_var_vec4, 1, ARR(4), false, 0, 1, 0, 0) +INTRINSIC(copy_var, 0, ARR(), false, 0, 2, 0, 0) + +/* + * a barrier is an intrinsic with no inputs/outputs but which can't be moved + * around/optimized in general + */ +#define BARRIER(name) INTRINSIC(name, 0, ARR(), false, 0, 0, 0, 0) + +BARRIER(discard) + +INTRINSIC(emit_vertex, 0, ARR(), false, 0, 0, 1, 0) +INTRINSIC(end_primitive, 0, ARR(), false, 0, 0, 1, 0) + +/* + * Atomic counters + * + * The *_var variants take an atomic_uint nir_variable, while the other, + * lowered, variants take a constant buffer index and register offset. + */ + +#define ATOMIC(name, flags) \ + INTRINSIC(atomic_counter_##name##_var, 0, ARR(), true, 1, 1, 0, flags) \ + INTRINSIC(atomic_counter_##name, 1, ARR(1), true, 1, 0, 1, flags) + +ATOMIC(inc, 0) +ATOMIC(dec, 0) +ATOMIC(read, NIR_INTRINSIC_CAN_ELIMINATE) + +#define SYSTEM_VALUE(name, components) \ + INTRINSIC(load_##name, 0, ARR(), true, components, 0, 0, \ + NIR_INTRINSIC_CAN_ELIMINATE | NIR_INTRINSIC_CAN_REORDER) + +SYSTEM_VALUE(front_face, 1) +SYSTEM_VALUE(vertex_id, 1) +SYSTEM_VALUE(instance_id, 1) +SYSTEM_VALUE(sample_id, 1) +SYSTEM_VALUE(sample_pos, 2) +SYSTEM_VALUE(sample_mask_in, 1) +SYSTEM_VALUE(invocation_id, 1) + +#define LOAD(name, num_indices, flags) \ + INTRINSIC(load_##name##_vec1, 0, ARR(), true, 1, 0, num_indices, \ + NIR_INTRINSIC_CAN_ELIMINATE | flags) \ + INTRINSIC(load_##name##_vec2, 0, ARR(), true, 2, 0, num_indices, \ + NIR_INTRINSIC_CAN_ELIMINATE | flags) \ + INTRINSIC(load_##name##_vec3, 0, ARR(), true, 3, 0, num_indices, \ + NIR_INTRINSIC_CAN_ELIMINATE | flags) \ + INTRINSIC(load_##name##_vec4, 0, ARR(), true, 4, 0, num_indices, \ + NIR_INTRINSIC_CAN_ELIMINATE | flags) \ + INTRINSIC(load_##name##_vec1_indirect, 1, ARR(1), true, 1, 0, num_indices, \ + NIR_INTRINSIC_CAN_ELIMINATE | flags) \ + INTRINSIC(load_##name##_vec2_indirect, 1, ARR(1), true, 2, 0, num_indices, \ + NIR_INTRINSIC_CAN_ELIMINATE | flags) \ + INTRINSIC(load_##name##_vec3_indirect, 1, ARR(1), true, 3, 0, num_indices, \ + NIR_INTRINSIC_CAN_ELIMINATE | flags) \ + INTRINSIC(load_##name##_vec4_indirect, 1, ARR(1), true, 4, 0, num_indices, \ + NIR_INTRINSIC_CAN_ELIMINATE | flags) \ + + +/* + * The first index is the address to load from, and the second index is the + * number of array elements to load. For UBO's (and SSBO's), the first index + * is the UBO buffer index (TODO nonconstant UBO buffer index) and the second + * and third indices play the role of the first and second indices in the other + * loads. Indirect loads have an additional register input, which is added + * to the constant address to compute the final address to load from. + * + * For vector backends, the address is in terms of one vec4, and so each array + * element is +4 scalar components from the previous array element. For scalar + * backends, the address is in terms of a single 4-byte float/int and arrays + * elements begin immediately after the previous array element. + */ + +LOAD(uniform, 2, NIR_INTRINSIC_CAN_REORDER) +LOAD(ubo, 3, NIR_INTRINSIC_CAN_REORDER) +LOAD(input, 2, NIR_INTRINSIC_CAN_REORDER) +/* LOAD(ssbo, 2, 0) */ + +#define STORE(name, num_indices, flags) \ + INTRINSIC(store_##name##_vec1, 1, ARR(1), false, 0, 0, num_indices, flags) \ + INTRINSIC(store_##name##_vec2, 1, ARR(2), false, 0, 0, num_indices, flags) \ + INTRINSIC(store_##name##_vec3, 1, ARR(3), false, 0, 0, num_indices, flags) \ + INTRINSIC(store_##name##_vec4, 1, ARR(4), false, 0, 0, num_indices, flags) \ + INTRINSIC(store_##name##_vec1_indirect, 2, ARR(1, 1), false, 0, 0, \ + num_indices, flags) \ + INTRINSIC(store_##name##_vec2_indirect, 2, ARR(2, 1), false, 0, 0, \ + num_indices, flags) \ + INTRINSIC(store_##name##_vec3_indirect, 2, ARR(3, 1), false, 0, 0, \ + num_indices, flags) \ + INTRINSIC(store_##name##_vec4_indirect, 2, ARR(4, 1), false, 0, 0, \ + num_indices, flags) \ + +/* + * Stores work the same way as loads, except now the first register input is + * the value or array to store and the optional second input is the indirect + * offset. + */ + +STORE(output, 2, 0) +/* STORE(ssbo, 3, 0) */ + +LAST_INTRINSIC(store_output_vec4_indirect) diff --git a/src/glsl/nir/nir_opcodes.c b/src/glsl/nir/nir_opcodes.c new file mode 100644 index 00000000000..a62f989eed7 --- /dev/null +++ b/src/glsl/nir/nir_opcodes.c @@ -0,0 +1,46 @@ +/* + * Copyright © 2014 Intel Corporation + * + * 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. + * + * Authors: + * Connor Abbott ([email protected]) + * + */ + +#include "nir.h" + +#define OPCODE(_name, _num_inputs, _per_component, _output_size, _output_type, \ + _input_sizes, _input_types) \ +{ \ + .name = #_name, \ + .num_inputs = _num_inputs, \ + .per_component = _per_component, \ + .output_size = _output_size, \ + .output_type = _output_type, \ + .input_sizes = _input_sizes, \ + .input_types = _input_types, \ +}, + +#define LAST_OPCODE(name) + +const nir_op_info nir_op_infos[nir_num_opcodes] = { +#include "nir_opcodes.h" +}; diff --git a/src/glsl/nir/nir_opcodes.h b/src/glsl/nir/nir_opcodes.h new file mode 100644 index 00000000000..36a50d7ba77 --- /dev/null +++ b/src/glsl/nir/nir_opcodes.h @@ -0,0 +1,346 @@ +/* + * Copyright © 2014 Intel Corporation + * + * 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. + * + * Authors: + * Connor Abbott ([email protected]) + * + */ + +/** + * This header file defines all the available opcodes in one place. It expands + * to a list of macros of the form: + * + * OPCODE(name, num_inputs, per_component, output_size, output_type, + * input_sizes, input_types) + * + * Which should correspond one-to-one with the nir_op_info structure. It is + * included in both ir.h to create the nir_op enum (with members of the form + * nir_op_(name)) and and in opcodes.c to create nir_op_infos, which is a + * const array of nir_op_info structures for each opcode. + */ + +#define ARR(...) { __VA_ARGS__ } + +#define UNOP(name, type) OPCODE(name, 1, false, 0, type, ARR(0), ARR(type)) +#define UNOP_CONVERT(name, in_type, out_type) \ + OPCODE(name, 1, false, 0, out_type, ARR(0), ARR(in_type)) +#define UNOP_HORIZ(name, output_size, output_type, input_size, input_type) \ + OPCODE(name, 1, true, output_size, output_type, ARR(input_size), \ + ARR(input_type)) + +#define UNOP_REDUCE(name, output_size, output_type, input_type) \ + UNOP_HORIZ(name##2, output_size, output_type, 2, input_type) \ + UNOP_HORIZ(name##3, output_size, output_type, 3, input_type) \ + UNOP_HORIZ(name##4, output_size, output_type, 4, input_type) + +/** + * These two move instructions differ in what modifiers they support and what + * the negate modifier means. Otherwise, they are identical. + */ +UNOP(fmov, nir_type_float) +UNOP(imov, nir_type_int) + +UNOP(inot, nir_type_int) /* invert every bit of the integer */ +UNOP(fnot, nir_type_float) /* (src == 0.0) ? 1.0 : 0.0 */ +UNOP(fsign, nir_type_float) +UNOP(isign, nir_type_int) +UNOP(frcp, nir_type_float) +UNOP(frsq, nir_type_float) +UNOP(fsqrt, nir_type_float) +UNOP(fexp, nir_type_float) /* < e^x */ +UNOP(flog, nir_type_float) /* log base e */ +UNOP(fexp2, nir_type_float) +UNOP(flog2, nir_type_float) +UNOP_CONVERT(f2i, nir_type_float, nir_type_int) /**< Float-to-integer conversion. */ +UNOP_CONVERT(f2u, nir_type_float, nir_type_unsigned) /**< Float-to-unsigned conversion. */ +UNOP_CONVERT(i2f, nir_type_int, nir_type_float) /**< Integer-to-float conversion. */ +UNOP_CONVERT(f2b, nir_type_float, nir_type_bool) /**< Float-to-boolean conversion */ +UNOP_CONVERT(b2f, nir_type_bool, nir_type_float) /**< Boolean-to-float conversion */ +UNOP_CONVERT(i2b, nir_type_int, nir_type_bool) /**< int-to-boolean conversion */ +UNOP_CONVERT(b2i, nir_type_bool, nir_type_int) /**< Boolean-to-int conversion */ +UNOP_CONVERT(u2f, nir_type_unsigned, nir_type_float) /**< Unsigned-to-float conversion. */ + +UNOP_REDUCE(bany, 1, nir_type_bool, nir_type_bool) /* returns ~0 if any component of src[0] != 0 */ +UNOP_REDUCE(ball, 1, nir_type_bool, nir_type_bool) /* returns ~0 if all components of src[0] != 0 */ +UNOP_REDUCE(fany, 1, nir_type_float, nir_type_float) /* returns 1.0 if any component of src[0] != 0 */ +UNOP_REDUCE(fall, 1, nir_type_float, nir_type_float) /* returns 1.0 if all components of src[0] != 0 */ + +/** + * \name Unary floating-point rounding operations. + */ +/*@{*/ +UNOP(ftrunc, nir_type_float) +UNOP(fceil, nir_type_float) +UNOP(ffloor, nir_type_float) +UNOP(ffract, nir_type_float) +UNOP(fround_even, nir_type_float) +/*@}*/ + +/** + * \name Trigonometric operations. + */ +/*@{*/ +UNOP(fsin, nir_type_float) +UNOP(fcos, nir_type_float) +UNOP(fsin_reduced, nir_type_float) +UNOP(fcos_reduced, nir_type_float) +/*@}*/ + +/** + * \name Partial derivatives. + */ +/*@{*/ +UNOP(fddx, nir_type_float) +UNOP(fddy, nir_type_float) +/*@}*/ + +/** + * \name Floating point pack and unpack operations. + */ +/*@{*/ +UNOP_HORIZ(pack_snorm_2x16, 1, nir_type_unsigned, 2, nir_type_float) +UNOP_HORIZ(pack_snorm_4x8, 1, nir_type_unsigned, 4, nir_type_float) +UNOP_HORIZ(pack_unorm_2x16, 1, nir_type_unsigned, 2, nir_type_float) +UNOP_HORIZ(pack_unorm_4x8, 1, nir_type_unsigned, 4, nir_type_float) +UNOP_HORIZ(pack_half_2x16, 1, nir_type_unsigned, 2, nir_type_float) +UNOP_HORIZ(unpack_snorm_2x16, 2, nir_type_float, 1, nir_type_unsigned) +UNOP_HORIZ(unpack_snorm_4x8, 4, nir_type_float, 1, nir_type_unsigned) +UNOP_HORIZ(unpack_unorm_2x16, 2, nir_type_float, 1, nir_type_unsigned) +UNOP_HORIZ(unpack_unorm_4x8, 4, nir_type_float, 1, nir_type_unsigned) +UNOP_HORIZ(unpack_half_2x16, 2, nir_type_float, 1, nir_type_unsigned) +/*@}*/ + +/** + * \name Lowered floating point unpacking operations. + */ +/*@{*/ +UNOP_HORIZ(unpack_half_2x16_split_x, 1, nir_type_float, 1, nir_type_unsigned) +UNOP_HORIZ(unpack_half_2x16_split_y, 1, nir_type_float, 1, nir_type_unsigned) +/*@}*/ + +/** + * \name Bit operations, part of ARB_gpu_shader5. + */ +/*@{*/ +UNOP(bitfield_reverse, nir_type_unsigned) +UNOP(bit_count, nir_type_unsigned) +UNOP(find_msb, nir_type_unsigned) +UNOP(find_lsb, nir_type_unsigned) +/*@}*/ + +UNOP_HORIZ(fnoise1_1, 1, nir_type_float, 1, nir_type_float) +UNOP_HORIZ(fnoise1_2, 1, nir_type_float, 2, nir_type_float) +UNOP_HORIZ(fnoise1_3, 1, nir_type_float, 3, nir_type_float) +UNOP_HORIZ(fnoise1_4, 1, nir_type_float, 4, nir_type_float) +UNOP_HORIZ(fnoise2_1, 2, nir_type_float, 1, nir_type_float) +UNOP_HORIZ(fnoise2_2, 2, nir_type_float, 2, nir_type_float) +UNOP_HORIZ(fnoise2_3, 2, nir_type_float, 3, nir_type_float) +UNOP_HORIZ(fnoise2_4, 2, nir_type_float, 4, nir_type_float) +UNOP_HORIZ(fnoise3_1, 3, nir_type_float, 1, nir_type_float) +UNOP_HORIZ(fnoise3_2, 3, nir_type_float, 2, nir_type_float) +UNOP_HORIZ(fnoise3_3, 3, nir_type_float, 3, nir_type_float) +UNOP_HORIZ(fnoise3_4, 3, nir_type_float, 4, nir_type_float) +UNOP_HORIZ(fnoise4_1, 4, nir_type_float, 1, nir_type_float) +UNOP_HORIZ(fnoise4_2, 4, nir_type_float, 2, nir_type_float) +UNOP_HORIZ(fnoise4_3, 4, nir_type_float, 3, nir_type_float) +UNOP_HORIZ(fnoise4_4, 4, nir_type_float, 4, nir_type_float) + +#define BINOP(name, type) \ + OPCODE(name, 2, true, 0, type, ARR(0, 0), ARR(type, type)) +#define BINOP_CONVERT(name, out_type, in_type) \ + OPCODE(name, 2, true, 0, out_type, ARR(0, 0), ARR(in_type, in_type)) +#define BINOP_COMPARE(name, type) BINOP_CONVERT(name, nir_type_bool, type) +#define BINOP_HORIZ(name, output_size, output_type, src1_size, src1_type, \ + src2_size, src2_type) \ + OPCODE(name, 2, true, output_size, output_type, ARR(src1_size, src2_size), \ + ARR(src1_type, src2_type)) +#define BINOP_REDUCE(name, output_size, output_type, src_type) \ + BINOP_HORIZ(name##2, output_size, output_type, 2, src_type, 2, src_type) \ + BINOP_HORIZ(name##3, output_size, output_type, 3, src_type, 3, src_type) \ + BINOP_HORIZ(name##4, output_size, output_type, 4, src_type, 4, src_type) \ + +BINOP(fadd, nir_type_float) +BINOP(iadd, nir_type_int) +BINOP(fsub, nir_type_float) +BINOP(isub, nir_type_int) + +BINOP(fmul, nir_type_float) +BINOP(imul, nir_type_int) /* low 32-bits of signed/unsigned integer multiply */ +BINOP(imul_high, nir_type_int) /* high 32-bits of signed integer multiply */ +BINOP(umul_high, nir_type_int) /* high 32-bits of unsigned integer multiply */ + +BINOP(fdiv, nir_type_float) +BINOP(idiv, nir_type_int) +BINOP(udiv, nir_type_unsigned) + +/** + * returns a boolean representing the carry resulting from the addition of + * the two unsigned arguments. + */ +BINOP_CONVERT(uadd_carry, nir_type_bool, nir_type_unsigned) + +/** + * returns a boolean representing the borrow resulting from the subtraction + * of the two unsigned arguments. + */ +BINOP_CONVERT(usub_borrow, nir_type_bool, nir_type_unsigned) + +BINOP(fmod, nir_type_float) +BINOP(umod, nir_type_unsigned) + +/** + * \name comparisons + */ +/*@{*/ + +/** + * these integer-aware comparisons return a boolean (0 or ~0) + */ +BINOP_COMPARE(flt, nir_type_float) +BINOP_COMPARE(fge, nir_type_float) +BINOP_COMPARE(feq, nir_type_float) +BINOP_COMPARE(fne, nir_type_float) +BINOP_COMPARE(ilt, nir_type_int) +BINOP_COMPARE(ige, nir_type_int) +BINOP_COMPARE(ieq, nir_type_int) +BINOP_COMPARE(ine, nir_type_int) +BINOP_COMPARE(ult, nir_type_int) +BINOP_COMPARE(uge, nir_type_int) + +/** integer-aware GLSL-style comparisons that compare floats and ints */ +BINOP_REDUCE(ball_fequal, 1, nir_type_bool, nir_type_float) +BINOP_REDUCE(bany_fnequal, 1, nir_type_bool, nir_type_float) +BINOP_REDUCE(ball_iequal, 1, nir_type_bool, nir_type_int) +BINOP_REDUCE(bany_inequal, 1, nir_type_bool, nir_type_int) + +/** non-integer-aware GLSL-style comparisons that return 0.0 or 1.0 */ +BINOP_REDUCE(fall_equal, 1, nir_type_float, nir_type_float) +BINOP_REDUCE(fany_nequal, 1, nir_type_float, nir_type_float) + +/** + * These comparisons for integer-less hardware return 1.0 and 0.0 for true + * and false respectively + */ +BINOP(slt, nir_type_float) /* Set on Less Than */ +BINOP(sge, nir_type_float) /* Set on Greater Than or Equal */ +BINOP(seq, nir_type_float) /* Set on Equal */ +BINOP(sne, nir_type_float) /* Set on Not Equal */ + +/*@}*/ + +BINOP(ishl, nir_type_int) +BINOP(ishr, nir_type_int) +BINOP(ushr, nir_type_unsigned) + +/** + * \name bitwise logic operators + * + * These are also used as boolean and, or, xor for hardware supporting + * integers. + */ +/*@{*/ +BINOP(iand, nir_type_unsigned) +BINOP(ior, nir_type_unsigned) +BINOP(ixor, nir_type_unsigned) +/*@{*/ + +/** + * \name floating point logic operators + * + * These use (src != 0.0) for testing the truth of the input, and output 1.0 + * for true and 0.0 for false + */ +BINOP(fand, nir_type_float) +BINOP(for, nir_type_float) +BINOP(fxor, nir_type_float) + +BINOP_REDUCE(fdot, 1, nir_type_float, nir_type_float) + +BINOP(fmin, nir_type_float) +BINOP(imin, nir_type_int) +BINOP(umin, nir_type_unsigned) +BINOP(fmax, nir_type_float) +BINOP(imax, nir_type_int) +BINOP(umax, nir_type_unsigned) + +BINOP(fpow, nir_type_float) + +BINOP_HORIZ(pack_half_2x16_split, 1, nir_type_unsigned, 1, nir_type_float, 1, nir_type_float) + +BINOP(bfm, nir_type_unsigned) + +BINOP(ldexp, nir_type_unsigned) + +/** + * Combines the first component of each input to make a 2-component vector. + */ +BINOP_HORIZ(vec2, 2, nir_type_unsigned, 1, nir_type_unsigned, 1, nir_type_unsigned) + +#define TRIOP(name, type) \ + OPCODE(name, 3, true, 0, type, ARR(0, 0, 0), ARR(type, type, type)) +#define TRIOP_HORIZ(name, output_size, src1_size, src2_size, src3_size) \ + OPCODE(name, 3, false, output_size, nir_type_unsigned, \ + ARR(src1_size, src2_size, src3_size), \ + ARR(nir_type_unsigned, nir_type_unsigned, nir_type_unsigned)) + +TRIOP(ffma, nir_type_float) + +TRIOP(flrp, nir_type_float) + +/** + * \name Conditional Select + * + * A vector conditional select instruction (like ?:, but operating per- + * component on vectors). There are two versions, one for floating point + * bools (0.0 vs 1.0) and one for integer bools (0 vs ~0). + */ + +OPCODE(fcsel, 3, true, 0, nir_type_float, ARR(1, 0, 0), + ARR(nir_type_float, nir_type_float, nir_type_float)) +OPCODE(bcsel, 3, true, 0, nir_type_unsigned, ARR(1, 0, 0), + ARR(nir_type_bool, nir_type_unsigned, nir_type_unsigned)) + +TRIOP(bfi, nir_type_unsigned) + +TRIOP(ubitfield_extract, nir_type_unsigned) +OPCODE(ibitfield_extract, 3, true, 0, nir_type_int, ARR(0, 0, 0), + ARR(nir_type_int, nir_type_unsigned, nir_type_unsigned)) + +/** + * Combines the first component of each input to make a 3-component vector. + */ +TRIOP_HORIZ(vec3, 3, 1, 1, 1) + +#define QUADOP(name) \ + OPCODE(name, 4, true, 0, nir_type_unsigned, ARR(0, 0, 0, 0), \ + ARR(nir_type_unsigned, nir_type_unsigned, nir_type_unsigned, nir_type_unsigned)) +#define QUADOP_HORIZ(name, output_size, src1_size, src2_size, src3_size, \ + src4_size) \ + OPCODE(name, 4, false, output_size, nir_type_unsigned, \ + ARR(src1_size, src2_size, src3_size, src4_size), \ + ARR(nir_type_unsigned, nir_type_unsigned, nir_type_unsigned, nir_type_unsigned)) + +QUADOP(bitfield_insert) + +QUADOP_HORIZ(vec4, 4, 1, 1, 1, 1) + +LAST_OPCODE(vec4) |