X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fcompiler%2Fnir%2Fnir.h;h=12cad6029cdc4b1fe177dd3b9cf6024dc23162a0;hb=5a6b04d94bd2ec175d485b71e8ae815efd778a8a;hp=f8e71d54a50d0783cc1a6b6a22573b9a82c1f196;hpb=6487e7a30c9e4c2a417ddfe632d5f68e065e21eb;p=mesa.git diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h index f8e71d54a50..12cad6029cd 100644 --- a/src/compiler/nir/nir.h +++ b/src/compiler/nir/nir.h @@ -57,6 +57,8 @@ extern "C" { #define NIR_FALSE 0u #define NIR_TRUE (~0u) +#define NIR_MAX_VEC_COMPONENTS 4 +typedef uint8_t nir_component_mask_t; /** Defines a cast function * @@ -78,6 +80,7 @@ name(const in_type *parent) \ struct nir_function; struct nir_shader; struct nir_instr; +struct nir_builder; /** @@ -98,7 +101,6 @@ typedef enum { nir_var_uniform = (1 << 4), nir_var_shader_storage = (1 << 5), nir_var_system_value = (1 << 6), - nir_var_param = (1 << 7), nir_var_shared = (1 << 8), nir_var_all = ~0, } nir_variable_mode; @@ -115,16 +117,16 @@ typedef enum { } nir_rounding_mode; typedef union { - float f32[4]; - double f64[4]; - int8_t i8[4]; - uint8_t u8[4]; - int16_t i16[4]; - uint16_t u16[4]; - int32_t i32[4]; - uint32_t u32[4]; - int64_t i64[4]; - uint64_t u64[4]; + float f32[NIR_MAX_VEC_COMPONENTS]; + double f64[NIR_MAX_VEC_COMPONENTS]; + int8_t i8[NIR_MAX_VEC_COMPONENTS]; + uint8_t u8[NIR_MAX_VEC_COMPONENTS]; + int16_t i16[NIR_MAX_VEC_COMPONENTS]; + uint16_t u16[NIR_MAX_VEC_COMPONENTS]; + int32_t i32[NIR_MAX_VEC_COMPONENTS]; + uint32_t u32[NIR_MAX_VEC_COMPONENTS]; + int64_t i64[NIR_MAX_VEC_COMPONENTS]; + uint64_t u64[NIR_MAX_VEC_COMPONENTS]; } nir_const_value; typedef struct nir_constant { @@ -135,7 +137,7 @@ typedef struct nir_constant { * by the type associated with the \c nir_variable. Constants may be * scalars, vectors, or matrices. */ - nir_const_value values[4]; + nir_const_value values[NIR_MAX_VEC_COMPONENTS]; /* we could get this from the var->type but makes clone *much* easier to * not have to care about the type. @@ -160,6 +162,22 @@ typedef enum { nir_depth_layout_unchanged } nir_depth_layout; +/** + * Enum keeping track of how a variable was declared. + */ +typedef enum { + /** + * Normal declaration. + */ + nir_var_declared_normally = 0, + + /** + * Variable is implicitly generated by the compiler and should not be + * visible via the API. + */ + nir_var_hidden, +} nir_var_declaration_type; + /** * Either a uniform, global variable, shader input, or shader output. Based on * ir_variable - it should be easy to translate between the two. @@ -252,6 +270,26 @@ typedef struct nir_variable { */ unsigned bindless:1; + /** + * Was an explicit binding set in the shader? + */ + unsigned explicit_binding:1; + + /** + * Was a transfer feedback buffer set in the shader? + */ + unsigned explicit_xfb_buffer:1; + + /** + * Was a transfer feedback stride set in the shader? + */ + unsigned explicit_xfb_stride:1; + + /** + * Was an explicit offset set in the shader? + */ + unsigned explicit_offset:1; + /** * \brief Layout qualifier for gl_FragDepth. * @@ -313,10 +351,28 @@ typedef struct nir_variable { int binding; /** - * Location an atomic counter is stored at. + * Location an atomic counter or transform feedback is stored at. */ unsigned offset; + /** + * Transform feedback buffer. + */ + unsigned xfb_buffer; + + /** + * Transform feedback stride. + */ + unsigned xfb_stride; + + /** + * How the variable was declared. See nir_var_declaration_type. + * + * This is used to detect variables generated by the compiler, so should + * not be visible via the API. + */ + unsigned how_declared:2; + /** * ARB_shader_image_load_store qualifiers. */ @@ -364,6 +420,17 @@ typedef struct nir_variable { * \sa ir_variable::location */ const struct glsl_type *interface_type; + + /** + * Description of per-member data for per-member struct variables + * + * This is used for variables which are actually an amalgamation of + * multiple entities such as a struct of built-in values or a struct of + * inputs each with their own layout specifier. This is only allowed on + * variables with a struct or array of array of struct type. + */ + unsigned num_members; + struct nir_variable_data *members; } nir_variable; #define nir_foreach_variable(var, var_list) \ @@ -375,7 +442,7 @@ typedef struct nir_variable { static inline bool nir_variable_is_global(const nir_variable *var) { - return var->data.mode != nir_var_local && var->data.mode != nir_var_param; + return var->data.mode != nir_var_local; } typedef struct nir_register { @@ -424,6 +491,7 @@ typedef struct nir_register { typedef enum { nir_instr_type_alu, + nir_instr_type_deref, nir_instr_type_call, nir_instr_type_tex, nir_instr_type_intrinsic, @@ -490,6 +558,7 @@ typedef struct nir_ssa_def { /** Index into the live_in and live_out bitfields */ unsigned live_index; + /** Instruction which produces this SSA value. */ nir_instr *parent_instr; /** set of nir_instrs where this register is used (read from) */ @@ -529,6 +598,7 @@ struct nir_if; typedef struct nir_src { union { + /** Instruction that consumes this value as a source. */ nir_instr *parent_instr; struct nir_if *parent_if; }; @@ -678,7 +748,7 @@ typedef struct { * 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]; + uint8_t swizzle[NIR_MAX_VEC_COMPONENTS]; } nir_alu_src; typedef struct { @@ -693,7 +763,7 @@ typedef struct { bool saturate; - unsigned write_mask : 4; /* ignored if dest.is_ssa is true */ + unsigned write_mask : NIR_MAX_VEC_COMPONENTS; /* ignored if dest.is_ssa is true */ } nir_alu_dest; typedef enum { @@ -822,14 +892,14 @@ typedef struct { /** * The number of components in each input */ - unsigned input_sizes[4]; + unsigned input_sizes[NIR_MAX_VEC_COMPONENTS]; /** * The type of vector that each input takes. Note that negate and * absolute value are only allowed on inputs with int or float type and * behave differently on the two. */ - nir_alu_type input_types[4]; + nir_alu_type input_types[NIR_MAX_VEC_COMPONENTS]; nir_op_algebraic_property algebraic_properties; } nir_op_info; @@ -891,73 +961,94 @@ bool nir_alu_srcs_equal(const nir_alu_instr *alu1, const nir_alu_instr *alu2, typedef enum { nir_deref_type_var, nir_deref_type_array, - nir_deref_type_struct + nir_deref_type_array_wildcard, + nir_deref_type_struct, + nir_deref_type_cast, } nir_deref_type; -typedef struct nir_deref { +typedef struct { + nir_instr instr; + + /** The type of this deref instruction */ nir_deref_type deref_type; - struct nir_deref *child; + + /** The mode of the underlying variable */ + nir_variable_mode mode; + + /** The dereferenced type of the resulting pointer value */ const struct glsl_type *type; -} nir_deref; -typedef struct { - nir_deref deref; - - nir_variable *var; -} nir_deref_var; - -/* This enum describes how the array is referenced. If the deref is - * direct then the base_offset is used. If the deref is indirect then - * offset is given by base_offset + indirect. If the deref is a wildcard - * then the deref refers to all of the elements of the array at the same - * time. Wildcard dereferences are only ever allowed in copy_var - * intrinsics and the source and destination derefs must have matching - * wildcards. - */ -typedef enum { - nir_deref_array_type_direct, - nir_deref_array_type_indirect, - nir_deref_array_type_wildcard, -} nir_deref_array_type; + union { + /** Variable being dereferenced if deref_type is a deref_var */ + nir_variable *var; -typedef struct { - nir_deref deref; + /** Parent deref if deref_type is not deref_var */ + nir_src parent; + }; - nir_deref_array_type deref_array_type; - unsigned base_offset; - nir_src indirect; -} nir_deref_array; + /** Additional deref parameters */ + union { + struct { + nir_src index; + } arr; -typedef struct { - nir_deref deref; + struct { + unsigned index; + } strct; + }; - unsigned index; -} nir_deref_struct; + /** Destination to store the resulting "pointer" */ + nir_dest dest; +} nir_deref_instr; -NIR_DEFINE_CAST(nir_deref_as_var, nir_deref, nir_deref_var, deref, - deref_type, nir_deref_type_var) -NIR_DEFINE_CAST(nir_deref_as_array, nir_deref, nir_deref_array, deref, - deref_type, nir_deref_type_array) -NIR_DEFINE_CAST(nir_deref_as_struct, nir_deref, nir_deref_struct, deref, - deref_type, nir_deref_type_struct) +NIR_DEFINE_CAST(nir_instr_as_deref, nir_instr, nir_deref_instr, instr, + type, nir_instr_type_deref) -/* Returns the last deref in the chain. */ -static inline nir_deref * -nir_deref_tail(nir_deref *deref) +static inline nir_deref_instr * +nir_src_as_deref(nir_src src) { - while (deref->child) - deref = deref->child; - return deref; + if (!src.is_ssa) + return NULL; + + if (src.ssa->parent_instr->type != nir_instr_type_deref) + return NULL; + + return nir_instr_as_deref(src.ssa->parent_instr); +} + +static inline nir_deref_instr * +nir_deref_instr_parent(const nir_deref_instr *instr) +{ + if (instr->deref_type == nir_deref_type_var) + return NULL; + else + return nir_src_as_deref(instr->parent); +} + +static inline nir_variable * +nir_deref_instr_get_variable(const nir_deref_instr *instr) +{ + while (instr->deref_type != nir_deref_type_var) { + if (instr->deref_type == nir_deref_type_cast) + return NULL; + + instr = nir_deref_instr_parent(instr); + } + + return instr->var; } +bool nir_deref_instr_has_indirect(nir_deref_instr *instr); + +bool nir_deref_instr_remove_if_unused(nir_deref_instr *instr); + typedef struct { nir_instr instr; - unsigned num_params; - nir_deref_var **params; - nir_deref_var *return_deref; - struct nir_function *callee; + + unsigned num_params; + nir_src params[]; } nir_call_instr; #include "nir_intrinsics.h" @@ -1009,11 +1100,15 @@ typedef struct { int const_index[NIR_INTRINSIC_MAX_CONST_INDEX]; - nir_deref_var *variables[2]; - nir_src src[]; } nir_intrinsic_instr; +static inline nir_variable * +nir_intrinsic_get_var(nir_intrinsic_instr *intrin, unsigned i) +{ + return nir_deref_instr_get_variable(nir_src_as_deref(intrin->src[i])); +} + /** * \name NIR intrinsics semantic flags * @@ -1101,11 +1196,16 @@ typedef enum { */ NIR_INTRINSIC_CLUSTER_SIZE = 11, + /** + * Parameter index for a load_param intrinsic + */ + NIR_INTRINSIC_PARAM_IDX = 12, + NIR_INTRINSIC_NUM_INDEX_FLAGS, } nir_intrinsic_index_flag; -#define NIR_INTRINSIC_MAX_INPUTS 4 +#define NIR_INTRINSIC_MAX_INPUTS 5 typedef struct { const char *name; @@ -1128,9 +1228,6 @@ typedef struct { */ 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; @@ -1193,6 +1290,7 @@ INTRINSIC_IDX_ACCESSORS(component, COMPONENT, unsigned) INTRINSIC_IDX_ACCESSORS(interp_mode, INTERP_MODE, unsigned) INTRINSIC_IDX_ACCESSORS(reduction_op, REDUCTION_OP, unsigned) INTRINSIC_IDX_ACCESSORS(cluster_size, CLUSTER_SIZE, unsigned) +INTRINSIC_IDX_ACCESSORS(param_idx, PARAM_IDX, unsigned) /** * \group texture information @@ -1212,6 +1310,8 @@ typedef enum { nir_tex_src_ms_mcs, /* MSAA compression value */ nir_tex_src_ddx, nir_tex_src_ddy, + nir_tex_src_texture_deref, /* < deref pointing to the texture */ + nir_tex_src_sampler_deref, /* < deref pointing to the sampler */ nir_tex_src_texture_offset, /* < dynamically uniform indirect offset */ nir_tex_src_sampler_offset, /* < dynamically uniform indirect offset */ nir_tex_src_plane, /* < selects plane for planar textures */ @@ -1272,12 +1372,6 @@ typedef struct { /** The size of the texture array or 0 if it's not an array */ unsigned texture_array_size; - /** The texture deref - * - * If this is null, use texture_index instead. - */ - nir_deref_var *texture; - /** The sampler index * * The following operations do not require a sampler and, as such, this @@ -1294,12 +1388,6 @@ typedef struct { * then the sampler index is given by sampler_index + sampler_offset. */ unsigned sampler_index; - - /** The sampler deref - * - * If this is null, use sampler_index instead. - */ - nir_deref_var *sampler; } nir_tex_instr; static inline unsigned @@ -1374,6 +1462,30 @@ nir_tex_instr_is_query(const nir_tex_instr *instr) } } +static inline bool +nir_alu_instr_is_comparison(const nir_alu_instr *instr) +{ + switch (instr->op) { + case nir_op_flt: + case nir_op_fge: + case nir_op_feq: + case nir_op_fne: + case nir_op_ilt: + case nir_op_ult: + case nir_op_ige: + case nir_op_uge: + case nir_op_ieq: + case nir_op_ine: + case nir_op_i2b: + case nir_op_f2b: + case nir_op_inot: + case nir_op_fnot: + return true; + default: + return false; + } +} + static inline nir_alu_type nir_tex_instr_src_type(const nir_tex_instr *instr, unsigned src) { @@ -1641,6 +1753,13 @@ nir_block_last_instr(nir_block *block) return exec_node_data(nir_instr, tail, node); } +static inline bool +nir_block_ends_in_jump(nir_block *block) +{ + return !exec_list_is_empty(&block->instr_list) && + nir_block_last_instr(block)->type == nir_instr_type_jump; +} + #define nir_foreach_instr(instr, block) \ foreach_list_typed(nir_instr, instr, node, &(block)->instr_list) #define nir_foreach_instr_reverse(instr, block) \ @@ -1682,6 +1801,12 @@ typedef struct { /* Unroll the loop regardless of its size */ bool force_unroll; + /* Does the loop contain complex loop terminators, continues or other + * complex behaviours? If this is true we can't rely on + * loop_terminator_list to be complete or accurate. + */ + bool complex_loop; + nir_loop_terminator *limiting_terminator; /* A list of loop_terminators terminating this loop. */ @@ -1722,13 +1847,6 @@ typedef struct { /** 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; @@ -1839,15 +1957,9 @@ nir_loop_last_block(nir_loop *loop) return nir_cf_node_as_block(exec_node_data(nir_cf_node, tail, 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; + uint8_t num_components; + uint8_t bit_size; } nir_parameter; typedef struct nir_function { @@ -1858,7 +1970,6 @@ typedef struct nir_function { unsigned num_params; nir_parameter *params; - const struct glsl_type *return_type; /** The implementation of this function. * @@ -1879,10 +1990,28 @@ typedef struct nir_shader_compiler_options { bool lower_fsqrt; bool lower_fmod32; bool lower_fmod64; + /** Lowers ibitfield_extract/ubitfield_extract to ibfe/ubfe. */ bool lower_bitfield_extract; + /** Lowers ibitfield_extract/ubitfield_extract to bfm, compares, shifts. */ + bool lower_bitfield_extract_to_shifts; + /** Lowers bitfield_insert to bfi/bfm */ bool lower_bitfield_insert; + /** Lowers bitfield_insert to bfm, compares, and shifts. */ + bool lower_bitfield_insert_to_shifts; + /** Lowers bitfield_reverse to shifts. */ + bool lower_bitfield_reverse; + /** Lowers bit_count to shifts. */ + bool lower_bit_count; + /** Lowers bfm to shifts and subtracts. */ + bool lower_bfm; + /** Lowers ifind_msb to compare and ufind_msb */ + bool lower_ifind_msb; + /** Lowers find_lsb to ufind_msb and logic ops */ + bool lower_find_lsb; bool lower_uadd_carry; bool lower_usub_borrow; + /** Lowers imul_high/umul_high to 16-bit multiplies and carry operations. */ + bool lower_mul_high; /** lowers fneg and ineg to fsub and isub. */ bool lower_negate; /** lowers fsub and isub to fadd+fneg and iadd+ineg. */ @@ -1894,6 +2023,9 @@ typedef struct nir_shader_compiler_options { /** enables rules to lower idiv by power-of-two: */ bool lower_idiv; + /* lower b2f to iand */ + bool lower_b2f; + /* Does the native fdot instruction replicate its result for four * components? If so, then opt_algebraic_late will turn all fdotN * instructions into fdot_replicatedN instructions. @@ -1930,10 +2062,33 @@ typedef struct nir_shader_compiler_options { /* Indicates that the driver only has zero-based vertex id */ bool vertex_id_zero_based; + /** + * If enabled, gl_BaseVertex will be lowered as: + * is_indexed_draw (~0/0) & firstvertex + */ + bool lower_base_vertex; + + /** + * If enabled, gl_HelperInvocation will be lowered as: + * + * !((1 << sample_id) & sample_mask_in)) + * + * This depends on some possibly hw implementation details, which may + * not be true for all hw. In particular that the FS is only executed + * for covered samples or for helper invocations. So, do not blindly + * enable this option. + * + * Note: See also issue #22 in ARB_shader_image_load_store + */ + bool lower_helper_invocation; + bool lower_cs_local_index_from_id; bool lower_device_index_to_zero; + /* Set if nir_lower_wpos_ytransform() should also invert gl_PointCoord. */ + bool lower_wpos_pntc; + /** * Should nir_lower_io() create load_interpolated_input intrinsics? * @@ -1993,6 +2148,14 @@ typedef struct nir_shader { * access plus one */ unsigned num_inputs, num_uniforms, num_outputs, num_shared; + + /** Constant data associated with this shader. + * + * Constant data is loaded through load_constant intrinsics. See also + * nir_opt_large_constants. + */ + void *constant_data; + unsigned constant_data_size; } nir_shader; static inline nir_function_impl * @@ -2001,7 +2164,6 @@ nir_shader_get_entrypoint(nir_shader *shader) assert(exec_list_length(&shader->functions) == 1); struct exec_node *func_node = exec_list_get_head(&shader->functions); nir_function *func = exec_node_data(nir_function, func_node, node); - assert(func->return_type == glsl_void_type()); assert(func->num_params == 0); assert(func->impl); return func->impl; @@ -2063,6 +2225,9 @@ void nir_metadata_preserve(nir_function_impl *impl, nir_metadata preserved); /** creates an instruction with default swizzle/writemask/etc. with NULL registers */ nir_alu_instr *nir_alu_instr_create(nir_shader *shader, nir_op op); +nir_deref_instr *nir_deref_instr_create(nir_shader *shader, + nir_deref_type deref_type); + nir_jump_instr *nir_jump_instr_create(nir_shader *shader, nir_jump_type type); nir_load_const_instr *nir_load_const_instr_create(nir_shader *shader, @@ -2085,17 +2250,6 @@ nir_ssa_undef_instr *nir_ssa_undef_instr_create(nir_shader *shader, unsigned num_components, unsigned bit_size); -nir_deref_var *nir_deref_var_create(void *mem_ctx, nir_variable *var); -nir_deref_array *nir_deref_array_create(void *mem_ctx); -nir_deref_struct *nir_deref_struct_create(void *mem_ctx, unsigned field_index); - -typedef bool (*nir_deref_foreach_leaf_cb)(nir_deref_var *deref, void *state); -bool nir_deref_foreach_leaf(nir_deref_var *deref, - nir_deref_foreach_leaf_cb cb, void *state); - -nir_load_const_instr * -nir_deref_get_const_initializer_load(nir_shader *shader, nir_deref_var *deref); - nir_const_value nir_alu_binop_identity(nir_op binop, unsigned bit_size); /** @@ -2327,8 +2481,6 @@ void nir_instr_move_src(nir_instr *dest_instr, nir_src *dest, nir_src *src); void nir_if_rewrite_condition(nir_if *if_stmt, nir_src new_src); void nir_instr_rewrite_dest(nir_instr *instr, nir_dest *dest, nir_dest new_dest); -void nir_instr_rewrite_deref(nir_instr *instr, nir_deref_var **deref, - nir_deref_var *new_deref); void nir_ssa_dest_init(nir_instr *instr, nir_dest *dest, unsigned num_components, unsigned bit_size, @@ -2349,7 +2501,7 @@ void nir_ssa_def_rewrite_uses(nir_ssa_def *def, nir_src new_src); void nir_ssa_def_rewrite_uses_after(nir_ssa_def *def, nir_src new_src, nir_instr *after_me); -uint8_t nir_ssa_def_components_read(const nir_ssa_def *def); +nir_component_mask_t nir_ssa_def_components_read(const nir_ssa_def *def); /* * finds the next basic block in source-code order, returns NULL if there is @@ -2423,8 +2575,6 @@ nir_shader *nir_shader_clone(void *mem_ctx, const nir_shader *s); nir_function_impl *nir_function_impl_clone(const nir_function_impl *fi); nir_constant *nir_constant_clone(const nir_constant *c, nir_variable *var); nir_variable *nir_variable_clone(const nir_variable *c, nir_shader *shader); -nir_deref *nir_deref_clone(const nir_deref *deref, void *mem_ctx); -nir_deref_var *nir_deref_var_clone(const nir_deref_var *deref, void *mem_ctx); nir_shader *nir_shader_serialize_deserialize(void *mem_ctx, nir_shader *s); @@ -2522,7 +2672,11 @@ void nir_dump_cfg(nir_shader *shader, FILE *fp); int nir_gs_count_vertices(const nir_shader *shader); +bool nir_shrink_vec_array_vars(nir_shader *shader, nir_variable_mode modes); +bool nir_split_array_vars(nir_shader *shader, nir_variable_mode modes); bool nir_split_var_copies(nir_shader *shader); +bool nir_split_per_member_structs(nir_shader *shader); +bool nir_split_struct_vars(nir_shader *shader, nir_variable_mode modes); bool nir_lower_returns_impl(nir_function_impl *impl); bool nir_lower_returns(nir_shader *shader); @@ -2532,8 +2686,12 @@ bool nir_inline_functions(nir_shader *shader); bool nir_propagate_invariant(nir_shader *shader); void nir_lower_var_copy_instr(nir_intrinsic_instr *copy, nir_shader *shader); +void nir_lower_deref_copy_instr(struct nir_builder *b, + nir_intrinsic_instr *copy); bool nir_lower_var_copies(nir_shader *shader); +void nir_fixup_deref_modes(nir_shader *shader); + bool nir_lower_global_vars_to_local(nir_shader *shader); bool nir_lower_indirect_derefs(nir_shader *shader, nir_variable_mode modes); @@ -2570,19 +2728,22 @@ nir_src *nir_get_io_vertex_index_src(nir_intrinsic_instr *instr); bool nir_is_per_vertex_io(const nir_variable *var, gl_shader_stage stage); -void nir_lower_io_types(nir_shader *shader); bool nir_lower_regs_to_ssa_impl(nir_function_impl *impl); bool nir_lower_regs_to_ssa(nir_shader *shader); bool nir_lower_vars_to_ssa(nir_shader *shader); +bool nir_remove_dead_derefs(nir_shader *shader); +bool nir_remove_dead_derefs_impl(nir_function_impl *impl); bool nir_remove_dead_variables(nir_shader *shader, nir_variable_mode modes); bool nir_lower_constant_initializers(nir_shader *shader, nir_variable_mode modes); +bool nir_move_load_const(nir_shader *shader); bool nir_move_vec_src_uses_to_dest(nir_shader *shader); bool nir_lower_vec_to_movs(nir_shader *shader); void nir_lower_alpha_test(nir_shader *shader, enum compare_func func, bool alpha_to_one); +bool nir_lower_alu(nir_shader *shader); bool nir_lower_alu_to_scalar(nir_shader *shader); bool nir_lower_load_const_to_scalar(nir_shader *shader); bool nir_lower_read_invocation_to_scalar(nir_shader *shader); @@ -2713,7 +2874,8 @@ void nir_lower_two_sided_color(nir_shader *shader); bool nir_lower_clamp_color_outputs(nir_shader *shader); void nir_lower_passthrough_edgeflags(nir_shader *shader); -void nir_lower_tes_patch_vertices(nir_shader *tes, unsigned patch_vertices); +bool nir_lower_patch_vertices(nir_shader *nir, unsigned static_count, + const gl_state_index16 *uniform_state_tokens); typedef struct nir_lower_wpos_ytransform_options { gl_state_index16 state_tokens[STATE_LENGTH]; @@ -2752,6 +2914,12 @@ bool nir_lower_to_source_mods(nir_shader *shader); bool nir_lower_gs_intrinsics(nir_shader *shader); +typedef unsigned (*nir_lower_bit_size_callback)(const nir_alu_instr *, void *); + +bool nir_lower_bit_size(nir_shader *shader, + nir_lower_bit_size_callback callback, + void *callback_data); + typedef enum { nir_lower_imul64 = (1 << 0), nir_lower_isign64 = (1 << 1), @@ -2774,7 +2942,7 @@ typedef enum { } nir_lower_doubles_options; bool nir_lower_doubles(nir_shader *shader, nir_lower_doubles_options options); -bool nir_lower_64bit_pack(nir_shader *shader); +bool nir_lower_pack(nir_shader *shader); bool nir_normalize_cubemap_coords(nir_shader *shader); @@ -2816,12 +2984,18 @@ bool nir_opt_dce(nir_shader *shader); bool nir_opt_dead_cf(nir_shader *shader); +bool nir_opt_find_array_copies(nir_shader *shader); + bool nir_opt_gcm(nir_shader *shader, bool value_number); bool nir_opt_if(nir_shader *shader); bool nir_opt_intrinsics(nir_shader *shader); +bool nir_opt_large_constants(nir_shader *shader, + glsl_type_size_align_func size_align, + unsigned threshold); + bool nir_opt_loop_unroll(nir_shader *shader, nir_variable_mode indirect_mask); bool nir_opt_move_comparisons(nir_shader *shader); @@ -2830,6 +3004,7 @@ bool nir_opt_move_load_ubo(nir_shader *shader); bool nir_opt_peephole_select(nir_shader *shader, unsigned limit); +bool nir_opt_remove_phis_impl(nir_function_impl *impl); bool nir_opt_remove_phis(nir_shader *shader); bool nir_opt_shrink_load(nir_shader *shader); @@ -2842,6 +3017,9 @@ bool nir_opt_conditional_discard(nir_shader *shader); void nir_sweep(nir_shader *shader); +void nir_remap_attributes(nir_shader *shader, + const nir_shader_compiler_options *options); + nir_intrinsic_op nir_intrinsic_from_system_value(gl_system_value val); gl_system_value nir_system_value_from_intrinsic(nir_intrinsic_op intrin);