#include "../mesa-asahi-20240727/src/gallium/frontends/rusticl/rusticl_mesa_bindings.h"

// Static wrappers

int64_t u_intN_max__extern(unsigned int bit_size) { return u_intN_max(bit_size); }
int64_t u_intN_min__extern(unsigned int bit_size) { return u_intN_min(bit_size); }
uint64_t u_uintN_max__extern(unsigned int bit_size) { return u_uintN_max(bit_size); }
void mesa_count_tess_level_components__extern(const enum tess_primitive_mode mode, unsigned int *outer, unsigned int *inner) { mesa_count_tess_level_components(mode, outer, inner); }
unsigned int mesa_vertices_per_prim__extern(enum mesa_prim prim) { return mesa_vertices_per_prim(prim); }
unsigned int u_decomposed_prims_for_vertices__extern(enum mesa_prim primitive, int vertices) { return u_decomposed_prims_for_vertices(primitive, vertices); }
enum mesa_prim u_decomposed_prim__extern(enum mesa_prim prim) { return u_decomposed_prim(prim); }
enum mesa_prim u_reduced_prim__extern(enum mesa_prim prim) { return u_reduced_prim(prim); }
void blob_finish__extern(struct blob *blob) { blob_finish(blob); }
enum pipe_video_chroma_format pipe_format_to_chroma_format__extern(enum pipe_format format) { return pipe_format_to_chroma_format(format); }
const char * util_format_name__extern(enum pipe_format format) { return util_format_name(format); }
const char * util_format_short_name__extern(enum pipe_format format) { return util_format_short_name(format); }
bool util_format_is_plain__extern(enum pipe_format format) { return util_format_is_plain(format); }
bool util_format_is_compressed__extern(enum pipe_format format) { return util_format_is_compressed(format); }
bool util_format_is_s3tc__extern(enum pipe_format format) { return util_format_is_s3tc(format); }
bool util_format_is_etc__extern(enum pipe_format format) { return util_format_is_etc(format); }
bool util_format_is_srgb__extern(enum pipe_format format) { return util_format_is_srgb(format); }
bool util_format_has_depth__extern(const struct util_format_description *desc) { return util_format_has_depth(desc); }
bool util_format_has_stencil__extern(const struct util_format_description *desc) { return util_format_has_stencil(desc); }
bool util_format_is_depth_or_stencil__extern(enum pipe_format format) { return util_format_is_depth_or_stencil(format); }
bool util_format_is_depth_and_stencil__extern(enum pipe_format format) { return util_format_is_depth_and_stencil(format); }
enum pipe_format util_format_get_depth_only__extern(enum pipe_format format) { return util_format_get_depth_only(format); }
bool util_format_is_yuv__extern(enum pipe_format format) { return util_format_is_yuv(format); }
unsigned int util_format_get_mask__extern(enum pipe_format format) { return util_format_get_mask(format); }
unsigned int util_format_colormask__extern(const struct util_format_description *desc) { return util_format_colormask(desc); }
bool util_format_colormask_full__extern(const struct util_format_description *desc, unsigned int colormask) { return util_format_colormask_full(desc, colormask); }
bool util_format_is_rgba8_variant__extern(const struct util_format_description *desc) { return util_format_is_rgba8_variant(desc); }
bool util_format_is_rgbx_or_bgrx__extern(enum pipe_format format) { return util_format_is_rgbx_or_bgrx(format); }
unsigned int util_format_get_blocksizebits__extern(enum pipe_format format) { return util_format_get_blocksizebits(format); }
unsigned int util_format_get_blocksize__extern(enum pipe_format format) { return util_format_get_blocksize(format); }
unsigned int util_format_get_blockwidth__extern(enum pipe_format format) { return util_format_get_blockwidth(format); }
unsigned int util_format_get_blockheight__extern(enum pipe_format format) { return util_format_get_blockheight(format); }
unsigned int util_format_get_blockdepth__extern(enum pipe_format format) { return util_format_get_blockdepth(format); }
unsigned int util_format_get_nblocksx__extern(enum pipe_format format, unsigned int x) { return util_format_get_nblocksx(format, x); }
unsigned int util_format_get_nblocksy__extern(enum pipe_format format, unsigned int y) { return util_format_get_nblocksy(format, y); }
unsigned int util_format_get_nblocksz__extern(enum pipe_format format, unsigned int z) { return util_format_get_nblocksz(format, z); }
uint64_t util_format_get_nblocks__extern(enum pipe_format format, unsigned int width, unsigned int height) { return util_format_get_nblocks(format, width, height); }
unsigned int util_format_get_stride__extern(enum pipe_format format, unsigned int width) { return util_format_get_stride(format, width); }
uint64_t util_format_get_2d_size__extern(enum pipe_format format, unsigned int stride, unsigned int height) { return util_format_get_2d_size(format, stride, height); }
unsigned int util_format_get_component_bits__extern(enum pipe_format format, enum util_format_colorspace colorspace, unsigned int component) { return util_format_get_component_bits(format, colorspace, component); }
unsigned int util_format_get_component_shift__extern(enum pipe_format format, enum util_format_colorspace colorspace, unsigned int component) { return util_format_get_component_shift(format, colorspace, component); }
enum pipe_format util_format_srgb__extern(enum pipe_format format) { return util_format_srgb(format); }
enum pipe_format util_format_linear__extern(enum pipe_format format) { return util_format_linear(format); }
enum pipe_format util_format_stencil_only__extern(enum pipe_format format) { return util_format_stencil_only(format); }
enum pipe_format util_format_as_renderable__extern(enum pipe_format format) { return util_format_as_renderable(format); }
enum pipe_format util_format_intensity_to_red__extern(enum pipe_format format) { return util_format_intensity_to_red(format); }
enum pipe_format util_format_luminance_to_red__extern(enum pipe_format format) { return util_format_luminance_to_red(format); }
unsigned int util_format_get_num_planes__extern(enum pipe_format format) { return util_format_get_num_planes(format); }
enum pipe_format util_format_get_plane_format__extern(enum pipe_format format, unsigned int plane) { return util_format_get_plane_format(format, plane); }
unsigned int util_format_get_plane_width__extern(enum pipe_format format, unsigned int plane, unsigned int width) { return util_format_get_plane_width(format, plane, width); }
unsigned int util_format_get_plane_height__extern(enum pipe_format format, unsigned int plane, unsigned int height) { return util_format_get_plane_height(format, plane, height); }
unsigned int util_format_get_nr_components__extern(enum pipe_format format) { return util_format_get_nr_components(format); }
int util_format_get_first_non_void_channel__extern(enum pipe_format format) { return util_format_get_first_non_void_channel(format); }
bool util_format_is_unorm8__extern(const struct util_format_description *desc) { return util_format_is_unorm8(desc); }
void util_format_unpack_z_float__extern(enum pipe_format format, float *dst, const void *src, unsigned int w) { util_format_unpack_z_float(format, dst, src, w); }
void util_format_unpack_z_32unorm__extern(enum pipe_format format, uint32_t *dst, const void *src, unsigned int w) { util_format_unpack_z_32unorm(format, dst, src, w); }
void util_format_unpack_s_8uint__extern(enum pipe_format format, uint8_t *dst, const void *src, unsigned int w) { util_format_unpack_s_8uint(format, dst, src, w); }
void util_format_unpack_rgba__extern(enum pipe_format format, void *dst, const void *src, unsigned int w) { util_format_unpack_rgba(format, dst, src, w); }
void util_format_pack_z_float__extern(enum pipe_format format, void *dst, const float *src, unsigned int w) { util_format_pack_z_float(format, dst, src, w); }
void util_format_pack_z_32unorm__extern(enum pipe_format format, void *dst, const uint32_t *src, unsigned int w) { util_format_pack_z_32unorm(format, dst, src, w); }
void util_format_pack_s_8uint__extern(enum pipe_format format, void *dst, const uint8_t *src, unsigned int w) { util_format_pack_s_8uint(format, dst, src, w); }
void util_format_pack_rgba__extern(enum pipe_format format, void *dst, const void *src, unsigned int w) { util_format_pack_rgba(format, dst, src, w); }
unsigned int glsl_base_type_bit_size__extern(enum glsl_base_type type) { return glsl_base_type_bit_size(type); }
bool glsl_base_type_is_16bit__extern(enum glsl_base_type type) { return glsl_base_type_is_16bit(type); }
bool glsl_base_type_is_64bit__extern(enum glsl_base_type type) { return glsl_base_type_is_64bit(type); }
bool glsl_base_type_is_integer__extern(enum glsl_base_type type) { return glsl_base_type_is_integer(type); }
unsigned int glsl_base_type_get_bit_size__extern(const enum glsl_base_type base_type) { return glsl_base_type_get_bit_size(base_type); }
enum glsl_base_type glsl_unsigned_base_type_of__extern(enum glsl_base_type type) { return glsl_unsigned_base_type_of(type); }
enum glsl_base_type glsl_signed_base_type_of__extern(enum glsl_base_type type) { return glsl_signed_base_type_of(type); }
enum glsl_base_type glsl_get_base_type__extern(const glsl_type *t) { return glsl_get_base_type(t); }
unsigned int glsl_get_bit_size__extern(const glsl_type *t) { return glsl_get_bit_size(t); }
bool glsl_type_is_boolean__extern(const glsl_type *t) { return glsl_type_is_boolean(t); }
bool glsl_type_is_sampler__extern(const glsl_type *t) { return glsl_type_is_sampler(t); }
bool glsl_type_is_texture__extern(const glsl_type *t) { return glsl_type_is_texture(t); }
bool glsl_type_is_image__extern(const glsl_type *t) { return glsl_type_is_image(t); }
bool glsl_type_is_atomic_uint__extern(const glsl_type *t) { return glsl_type_is_atomic_uint(t); }
bool glsl_type_is_struct__extern(const glsl_type *t) { return glsl_type_is_struct(t); }
bool glsl_type_is_interface__extern(const glsl_type *t) { return glsl_type_is_interface(t); }
bool glsl_type_is_array__extern(const glsl_type *t) { return glsl_type_is_array(t); }
bool glsl_type_is_cmat__extern(const glsl_type *t) { return glsl_type_is_cmat(t); }
bool glsl_type_is_void__extern(const glsl_type *t) { return glsl_type_is_void(t); }
bool glsl_type_is_subroutine__extern(const glsl_type *t) { return glsl_type_is_subroutine(t); }
bool glsl_type_is_error__extern(const glsl_type *t) { return glsl_type_is_error(t); }
bool glsl_type_is_double__extern(const glsl_type *t) { return glsl_type_is_double(t); }
bool glsl_type_is_float__extern(const glsl_type *t) { return glsl_type_is_float(t); }
bool glsl_type_is_numeric__extern(const glsl_type *t) { return glsl_type_is_numeric(t); }
bool glsl_type_is_integer__extern(const glsl_type *t) { return glsl_type_is_integer(t); }
bool glsl_type_is_struct_or_ifc__extern(const glsl_type *t) { return glsl_type_is_struct_or_ifc(t); }
bool glsl_type_is_packed__extern(const glsl_type *t) { return glsl_type_is_packed(t); }
bool glsl_type_is_16bit__extern(const glsl_type *t) { return glsl_type_is_16bit(t); }
bool glsl_type_is_32bit__extern(const glsl_type *t) { return glsl_type_is_32bit(t); }
bool glsl_type_is_64bit__extern(const glsl_type *t) { return glsl_type_is_64bit(t); }
bool glsl_type_is_integer_16__extern(const glsl_type *t) { return glsl_type_is_integer_16(t); }
bool glsl_type_is_integer_32__extern(const glsl_type *t) { return glsl_type_is_integer_32(t); }
bool glsl_type_is_integer_64__extern(const glsl_type *t) { return glsl_type_is_integer_64(t); }
bool glsl_type_is_integer_32_64__extern(const glsl_type *t) { return glsl_type_is_integer_32_64(t); }
bool glsl_type_is_integer_16_32__extern(const glsl_type *t) { return glsl_type_is_integer_16_32(t); }
bool glsl_type_is_integer_16_32_64__extern(const glsl_type *t) { return glsl_type_is_integer_16_32_64(t); }
bool glsl_type_is_float_16__extern(const glsl_type *t) { return glsl_type_is_float_16(t); }
bool glsl_type_is_float_16_32__extern(const glsl_type *t) { return glsl_type_is_float_16_32(t); }
bool glsl_type_is_float_16_32_64__extern(const glsl_type *t) { return glsl_type_is_float_16_32_64(t); }
bool glsl_type_is_float_32_64__extern(const glsl_type *t) { return glsl_type_is_float_32_64(t); }
bool glsl_type_is_int_16_32_64__extern(const glsl_type *t) { return glsl_type_is_int_16_32_64(t); }
bool glsl_type_is_uint_16_32_64__extern(const glsl_type *t) { return glsl_type_is_uint_16_32_64(t); }
bool glsl_type_is_int_16_32__extern(const glsl_type *t) { return glsl_type_is_int_16_32(t); }
bool glsl_type_is_uint_16_32__extern(const glsl_type *t) { return glsl_type_is_uint_16_32(t); }
bool glsl_type_is_unsized_array__extern(const glsl_type *t) { return glsl_type_is_unsized_array(t); }
bool glsl_type_is_array_of_arrays__extern(const glsl_type *t) { return glsl_type_is_array_of_arrays(t); }
bool glsl_type_is_bare_sampler__extern(const glsl_type *t) { return glsl_type_is_bare_sampler(t); }
bool glsl_matrix_type_is_row_major__extern(const glsl_type *t) { return glsl_matrix_type_is_row_major(t); }
bool glsl_sampler_type_is_shadow__extern(const glsl_type *t) { return glsl_sampler_type_is_shadow(t); }
bool glsl_sampler_type_is_array__extern(const glsl_type *t) { return glsl_sampler_type_is_array(t); }
bool glsl_struct_type_is_packed__extern(const glsl_type *t) { return glsl_struct_type_is_packed(t); }
unsigned int glsl_get_vector_elements__extern(const glsl_type *t) { return glsl_get_vector_elements(t); }
unsigned int glsl_get_components__extern(const glsl_type *t) { return glsl_get_components(t); }
unsigned int glsl_get_matrix_columns__extern(const glsl_type *t) { return glsl_get_matrix_columns(t); }
int glsl_array_size__extern(const glsl_type *t) { return glsl_array_size(t); }
enum glsl_sampler_dim glsl_get_sampler_dim__extern(const glsl_type *t) { return glsl_get_sampler_dim(t); }
enum glsl_base_type glsl_get_sampler_result_type__extern(const glsl_type *t) { return glsl_get_sampler_result_type(t); }
int glsl_get_struct_field_offset__extern(const glsl_type *t, unsigned int index) { return glsl_get_struct_field_offset(t, index); }
const char * glsl_get_struct_elem_name__extern(const glsl_type *t, unsigned int index) { return glsl_get_struct_elem_name(t, index); }
const glsl_type * glsl_void_type__extern(void) { return glsl_void_type(); }
const glsl_type * glsl_float_type__extern(void) { return glsl_float_type(); }
const glsl_type * glsl_float16_t_type__extern(void) { return glsl_float16_t_type(); }
const glsl_type * glsl_double_type__extern(void) { return glsl_double_type(); }
const glsl_type * glsl_vec2_type__extern(void) { return glsl_vec2_type(); }
const glsl_type * glsl_dvec2_type__extern(void) { return glsl_dvec2_type(); }
const glsl_type * glsl_uvec2_type__extern(void) { return glsl_uvec2_type(); }
const glsl_type * glsl_ivec2_type__extern(void) { return glsl_ivec2_type(); }
const glsl_type * glsl_bvec2_type__extern(void) { return glsl_bvec2_type(); }
const glsl_type * glsl_vec4_type__extern(void) { return glsl_vec4_type(); }
const glsl_type * glsl_dvec4_type__extern(void) { return glsl_dvec4_type(); }
const glsl_type * glsl_uvec4_type__extern(void) { return glsl_uvec4_type(); }
const glsl_type * glsl_ivec4_type__extern(void) { return glsl_ivec4_type(); }
const glsl_type * glsl_bvec4_type__extern(void) { return glsl_bvec4_type(); }
const glsl_type * glsl_int_type__extern(void) { return glsl_int_type(); }
const glsl_type * glsl_uint_type__extern(void) { return glsl_uint_type(); }
const glsl_type * glsl_int64_t_type__extern(void) { return glsl_int64_t_type(); }
const glsl_type * glsl_uint64_t_type__extern(void) { return glsl_uint64_t_type(); }
const glsl_type * glsl_int16_t_type__extern(void) { return glsl_int16_t_type(); }
const glsl_type * glsl_uint16_t_type__extern(void) { return glsl_uint16_t_type(); }
const glsl_type * glsl_int8_t_type__extern(void) { return glsl_int8_t_type(); }
const glsl_type * glsl_uint8_t_type__extern(void) { return glsl_uint8_t_type(); }
const glsl_type * glsl_bool_type__extern(void) { return glsl_bool_type(); }
const glsl_type * glsl_atomic_uint_type__extern(void) { return glsl_atomic_uint_type(); }
const glsl_type * glsl_floatN_t_type__extern(unsigned int bit_size) { return glsl_floatN_t_type(bit_size); }
const glsl_type * glsl_intN_t_type__extern(unsigned int bit_size) { return glsl_intN_t_type(bit_size); }
const glsl_type * glsl_uintN_t_type__extern(unsigned int bit_size) { return glsl_uintN_t_type(bit_size); }
const glsl_type * glsl_simple_type__extern(unsigned int base_type, unsigned int rows, unsigned int columns) { return glsl_simple_type(base_type, rows, columns); }
const glsl_type * glsl_struct_type__extern(const glsl_struct_field *fields, unsigned int num_fields, const char *name, bool packed) { return glsl_struct_type(fields, num_fields, name, packed); }
const glsl_type * glsl_scalar_type__extern(enum glsl_base_type base_type) { return glsl_scalar_type(base_type); }
const glsl_type * glsl_vector_type__extern(enum glsl_base_type base_type, unsigned int components) { return glsl_vector_type(base_type, components); }
const glsl_type * glsl_matrix_type__extern(enum glsl_base_type base_type, unsigned int rows, unsigned int columns) { return glsl_matrix_type(base_type, rows, columns); }
const glsl_type * glsl_explicit_matrix_type__extern(const glsl_type *mat, unsigned int stride, bool row_major) { return glsl_explicit_matrix_type(mat, stride, row_major); }
const glsl_type * glsl_transposed_type__extern(const glsl_type *t) { return glsl_transposed_type(t); }
const glsl_type * glsl_texture_type_to_sampler__extern(const glsl_type *t, bool is_shadow) { return glsl_texture_type_to_sampler(t, is_shadow); }
const glsl_type * glsl_sampler_type_to_texture__extern(const glsl_type *t) { return glsl_sampler_type_to_texture(t); }
unsigned int glsl_count_attribute_slots__extern(const glsl_type *t, bool is_gl_vertex_input) { return glsl_count_attribute_slots(t, is_gl_vertex_input); }
enum glsl_interface_packing glsl_get_ifc_packing__extern(const glsl_type *t) { return glsl_get_ifc_packing(t); }
unsigned int glsl_get_explicit_stride__extern(const glsl_type *t) { return glsl_get_explicit_stride(t); }
unsigned int glsl_get_explicit_alignment__extern(const glsl_type *t) { return glsl_get_explicit_alignment(t); }
const glsl_type * glsl_get_explicit_interface_type__extern(const glsl_type *t, bool supports_std430) { return glsl_get_explicit_interface_type(t, supports_std430); }
int u_bit_scan__extern(unsigned int *mask) { return u_bit_scan(mask); }
int u_bit_scan64__extern(uint64_t *mask) { return u_bit_scan64(mask); }
void u_bit_scan_consecutive_range__extern(unsigned int *mask, int *start, int *count) { u_bit_scan_consecutive_range(mask, start, count); }
void u_bit_scan_consecutive_range64__extern(uint64_t *mask, int *start, int *count) { u_bit_scan_consecutive_range64(mask, start, count); }
unsigned int u_bit_consecutive__extern(unsigned int start, unsigned int count) { return u_bit_consecutive(start, count); }
uint64_t u_bit_consecutive64__extern(unsigned int start, unsigned int count) { return u_bit_consecutive64(start, count); }
bool nir_num_components_valid__extern(unsigned int num_components) { return nir_num_components_valid(num_components); }
nir_component_mask_t nir_component_mask__extern(unsigned int num_components) { return nir_component_mask(num_components); }
nir_const_value nir_const_value_for_raw_uint__extern(uint64_t x, unsigned int bit_size) { return nir_const_value_for_raw_uint(x, bit_size); }
nir_const_value nir_const_value_for_int__extern(int64_t i, unsigned int bit_size) { return nir_const_value_for_int(i, bit_size); }
nir_const_value nir_const_value_for_uint__extern(uint64_t u, unsigned int bit_size) { return nir_const_value_for_uint(u, bit_size); }
nir_const_value nir_const_value_for_bool__extern(bool b, unsigned int bit_size) { return nir_const_value_for_bool(b, bit_size); }
int64_t nir_const_value_as_int__extern(nir_const_value value, unsigned int bit_size) { return nir_const_value_as_int(value, bit_size); }
uint64_t nir_const_value_as_uint__extern(nir_const_value value, unsigned int bit_size) { return nir_const_value_as_uint(value, bit_size); }
bool nir_const_value_as_bool__extern(nir_const_value value, unsigned int bit_size) { return nir_const_value_as_bool(value, bit_size); }
bool nir_variable_is_global__extern(const nir_variable *var) { return nir_variable_is_global(var); }
nir_instr * nir_instr_next__extern(nir_instr *instr) { return nir_instr_next(instr); }
nir_instr * nir_instr_prev__extern(nir_instr *instr) { return nir_instr_prev(instr); }
bool nir_instr_is_first__extern(const nir_instr *instr) { return nir_instr_is_first(instr); }
bool nir_instr_is_last__extern(const nir_instr *instr) { return nir_instr_is_last(instr); }
bool nir_src_is_if__extern(const nir_src *src) { return nir_src_is_if(src); }
nir_instr * nir_src_parent_instr__extern(const nir_src *src) { return nir_src_parent_instr(src); }
struct nir_if * nir_src_parent_if__extern(const nir_src *src) { return nir_src_parent_if(src); }
void nir_src_set_parent_instr__extern(nir_src *src, nir_instr *parent_instr) { nir_src_set_parent_instr(src, parent_instr); }
void nir_src_set_parent_if__extern(nir_src *src, struct nir_if *parent_if) { nir_src_set_parent_if(src, parent_if); }
nir_src nir_src_init__extern(void) { return nir_src_init(); }
bool nir_def_used_by_if__extern(const nir_def *def) { return nir_def_used_by_if(def); }
bool nir_def_only_used_by_if__extern(const nir_def *def) { return nir_def_only_used_by_if(def); }
nir_src nir_src_for_ssa__extern(nir_def *def) { return nir_src_for_ssa(def); }
unsigned int nir_src_bit_size__extern(nir_src src) { return nir_src_bit_size(src); }
unsigned int nir_src_num_components__extern(nir_src src) { return nir_src_num_components(src); }
bool nir_src_is_const__extern(nir_src src) { return nir_src_is_const(src); }
bool nir_src_is_undef__extern(nir_src src) { return nir_src_is_undef(src); }
bool nir_src_is_divergent__extern(nir_src src) { return nir_src_is_divergent(src); }
bool nir_is_same_comp_swizzle__extern(uint8_t *swiz, unsigned int nr_comp) { return nir_is_same_comp_swizzle(swiz, nr_comp); }
bool nir_is_sequential_comp_swizzle__extern(uint8_t *swiz, unsigned int nr_comp) { return nir_is_sequential_comp_swizzle(swiz, nr_comp); }
unsigned int nir_alu_type_get_type_size__extern(nir_alu_type type) { return nir_alu_type_get_type_size(type); }
nir_alu_type nir_alu_type_get_base_type__extern(nir_alu_type type) { return nir_alu_type_get_base_type(type); }
nir_alu_type nir_get_nir_type_for_glsl_type__extern(const struct glsl_type *type) { return nir_get_nir_type_for_glsl_type(type); }
nir_alu_type nir_atomic_op_type__extern(nir_atomic_op op) { return nir_atomic_op_type(op); }
bool nir_op_is_vec_or_mov__extern(nir_op op) { return nir_op_is_vec_or_mov(op); }
bool nir_is_float_control_signed_zero_preserve__extern(unsigned int execution_mode, unsigned int bit_size) { return nir_is_float_control_signed_zero_preserve(execution_mode, bit_size); }
bool nir_is_float_control_inf_preserve__extern(unsigned int execution_mode, unsigned int bit_size) { return nir_is_float_control_inf_preserve(execution_mode, bit_size); }
bool nir_is_float_control_nan_preserve__extern(unsigned int execution_mode, unsigned int bit_size) { return nir_is_float_control_nan_preserve(execution_mode, bit_size); }
bool nir_is_float_control_signed_zero_inf_nan_preserve__extern(unsigned int execution_mode, unsigned int bit_size) { return nir_is_float_control_signed_zero_inf_nan_preserve(execution_mode, bit_size); }
bool nir_is_denorm_flush_to_zero__extern(unsigned int execution_mode, unsigned int bit_size) { return nir_is_denorm_flush_to_zero(execution_mode, bit_size); }
bool nir_is_denorm_preserve__extern(unsigned int execution_mode, unsigned int bit_size) { return nir_is_denorm_preserve(execution_mode, bit_size); }
bool nir_is_rounding_mode_rtne__extern(unsigned int execution_mode, unsigned int bit_size) { return nir_is_rounding_mode_rtne(execution_mode, bit_size); }
bool nir_is_rounding_mode_rtz__extern(unsigned int execution_mode, unsigned int bit_size) { return nir_is_rounding_mode_rtz(execution_mode, bit_size); }
bool nir_has_any_rounding_mode_rtz__extern(unsigned int execution_mode) { return nir_has_any_rounding_mode_rtz(execution_mode); }
bool nir_has_any_rounding_mode_rtne__extern(unsigned int execution_mode) { return nir_has_any_rounding_mode_rtne(execution_mode); }
nir_rounding_mode nir_get_rounding_mode_from_float_controls__extern(unsigned int execution_mode, nir_alu_type type) { return nir_get_rounding_mode_from_float_controls(execution_mode, type); }
bool nir_has_any_rounding_mode_enabled__extern(unsigned int execution_mode) { return nir_has_any_rounding_mode_enabled(execution_mode); }
bool nir_op_is_selection__extern(nir_op op) { return nir_op_is_selection(op); }
bool nir_op_is_derivative__extern(nir_op op) { return nir_op_is_derivative(op); }
bool nir_alu_instr_is_signed_zero_preserve__extern(nir_alu_instr *alu) { return nir_alu_instr_is_signed_zero_preserve(alu); }
bool nir_alu_instr_is_inf_preserve__extern(nir_alu_instr *alu) { return nir_alu_instr_is_inf_preserve(alu); }
bool nir_alu_instr_is_nan_preserve__extern(nir_alu_instr *alu) { return nir_alu_instr_is_nan_preserve(alu); }
bool nir_alu_instr_is_signed_zero_inf_nan_preserve__extern(nir_alu_instr *alu) { return nir_alu_instr_is_signed_zero_inf_nan_preserve(alu); }
bool nir_alu_instr_channel_used__extern(const nir_alu_instr *instr, unsigned int src, unsigned int channel) { return nir_alu_instr_channel_used(instr, src, channel); }
bool nir_deref_mode_may_be__extern(const nir_deref_instr *deref, nir_variable_mode modes) { return nir_deref_mode_may_be(deref, modes); }
bool nir_deref_mode_must_be__extern(const nir_deref_instr *deref, nir_variable_mode modes) { return nir_deref_mode_must_be(deref, modes); }
bool nir_deref_mode_is__extern(const nir_deref_instr *deref, nir_variable_mode mode) { return nir_deref_mode_is(deref, mode); }
bool nir_deref_mode_is_one_of__extern(const nir_deref_instr *deref, nir_variable_mode modes) { return nir_deref_mode_is_one_of(deref, modes); }
bool nir_deref_mode_is_in_set__extern(const nir_deref_instr *deref, nir_variable_mode modes) { return nir_deref_mode_is_in_set(deref, modes); }
nir_deref_instr * nir_src_as_deref__extern(nir_src src) { return nir_src_as_deref(src); }
nir_deref_instr * nir_deref_instr_parent__extern(const nir_deref_instr *instr) { return nir_deref_instr_parent(instr); }
nir_variable * nir_deref_instr_get_variable__extern(const nir_deref_instr *instr) { return nir_deref_instr_get_variable(instr); }
nir_variable * nir_intrinsic_get_var__extern(const nir_intrinsic_instr *intrin, unsigned int i) { return nir_intrinsic_get_var(intrin, i); }
int nir_intrinsic_base__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_base(instr); }
void nir_intrinsic_set_base__extern(nir_intrinsic_instr *instr, int val) { nir_intrinsic_set_base(instr, val); }
bool nir_intrinsic_has_base__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_base(instr); }
unsigned int nir_intrinsic_write_mask__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_write_mask(instr); }
void nir_intrinsic_set_write_mask__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_write_mask(instr, val); }
bool nir_intrinsic_has_write_mask__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_write_mask(instr); }
unsigned int nir_intrinsic_stream_id__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_stream_id(instr); }
void nir_intrinsic_set_stream_id__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_stream_id(instr, val); }
bool nir_intrinsic_has_stream_id__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_stream_id(instr); }
unsigned int nir_intrinsic_ucp_id__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_ucp_id(instr); }
void nir_intrinsic_set_ucp_id__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_ucp_id(instr, val); }
bool nir_intrinsic_has_ucp_id__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_ucp_id(instr); }
unsigned int nir_intrinsic_range_base__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_range_base(instr); }
void nir_intrinsic_set_range_base__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_range_base(instr, val); }
bool nir_intrinsic_has_range_base__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_range_base(instr); }
unsigned int nir_intrinsic_range__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_range(instr); }
void nir_intrinsic_set_range__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_range(instr, val); }
bool nir_intrinsic_has_range__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_range(instr); }
unsigned int nir_intrinsic_desc_set__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_desc_set(instr); }
void nir_intrinsic_set_desc_set__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_desc_set(instr, val); }
bool nir_intrinsic_has_desc_set__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_desc_set(instr); }
unsigned int nir_intrinsic_binding__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_binding(instr); }
void nir_intrinsic_set_binding__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_binding(instr, val); }
bool nir_intrinsic_has_binding__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_binding(instr); }
unsigned int nir_intrinsic_component__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_component(instr); }
void nir_intrinsic_set_component__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_component(instr, val); }
bool nir_intrinsic_has_component__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_component(instr); }
unsigned int nir_intrinsic_column__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_column(instr); }
void nir_intrinsic_set_column__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_column(instr, val); }
bool nir_intrinsic_has_column__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_column(instr); }
unsigned int nir_intrinsic_interp_mode__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_interp_mode(instr); }
void nir_intrinsic_set_interp_mode__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_interp_mode(instr, val); }
bool nir_intrinsic_has_interp_mode__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_interp_mode(instr); }
unsigned int nir_intrinsic_reduction_op__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_reduction_op(instr); }
void nir_intrinsic_set_reduction_op__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_reduction_op(instr, val); }
bool nir_intrinsic_has_reduction_op__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_reduction_op(instr); }
unsigned int nir_intrinsic_cluster_size__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_cluster_size(instr); }
void nir_intrinsic_set_cluster_size__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_cluster_size(instr, val); }
bool nir_intrinsic_has_cluster_size__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_cluster_size(instr); }
unsigned int nir_intrinsic_param_idx__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_param_idx(instr); }
void nir_intrinsic_set_param_idx__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_param_idx(instr, val); }
bool nir_intrinsic_has_param_idx__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_param_idx(instr); }
enum glsl_sampler_dim nir_intrinsic_image_dim__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_image_dim(instr); }
void nir_intrinsic_set_image_dim__extern(nir_intrinsic_instr *instr, enum glsl_sampler_dim val) { nir_intrinsic_set_image_dim(instr, val); }
bool nir_intrinsic_has_image_dim__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_image_dim(instr); }
bool nir_intrinsic_image_array__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_image_array(instr); }
void nir_intrinsic_set_image_array__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_image_array(instr, val); }
bool nir_intrinsic_has_image_array__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_image_array(instr); }
enum pipe_format nir_intrinsic_format__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_format(instr); }
void nir_intrinsic_set_format__extern(nir_intrinsic_instr *instr, enum pipe_format val) { nir_intrinsic_set_format(instr, val); }
bool nir_intrinsic_has_format__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_format(instr); }
enum gl_access_qualifier nir_intrinsic_access__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_access(instr); }
void nir_intrinsic_set_access__extern(nir_intrinsic_instr *instr, enum gl_access_qualifier val) { nir_intrinsic_set_access(instr, val); }
bool nir_intrinsic_has_access__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_access(instr); }
unsigned int nir_intrinsic_call_idx__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_call_idx(instr); }
void nir_intrinsic_set_call_idx__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_call_idx(instr, val); }
bool nir_intrinsic_has_call_idx__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_call_idx(instr); }
unsigned int nir_intrinsic_stack_size__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_stack_size(instr); }
void nir_intrinsic_set_stack_size__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_stack_size(instr, val); }
bool nir_intrinsic_has_stack_size__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_stack_size(instr); }
unsigned int nir_intrinsic_align_mul__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_align_mul(instr); }
void nir_intrinsic_set_align_mul__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_align_mul(instr, val); }
bool nir_intrinsic_has_align_mul__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_align_mul(instr); }
unsigned int nir_intrinsic_align_offset__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_align_offset(instr); }
void nir_intrinsic_set_align_offset__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_align_offset(instr, val); }
bool nir_intrinsic_has_align_offset__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_align_offset(instr); }
unsigned int nir_intrinsic_desc_type__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_desc_type(instr); }
void nir_intrinsic_set_desc_type__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_desc_type(instr, val); }
bool nir_intrinsic_has_desc_type__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_desc_type(instr); }
nir_alu_type nir_intrinsic_src_type__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_src_type(instr); }
void nir_intrinsic_set_src_type__extern(nir_intrinsic_instr *instr, nir_alu_type val) { nir_intrinsic_set_src_type(instr, val); }
bool nir_intrinsic_has_src_type__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_src_type(instr); }
nir_alu_type nir_intrinsic_dest_type__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_dest_type(instr); }
void nir_intrinsic_set_dest_type__extern(nir_intrinsic_instr *instr, nir_alu_type val) { nir_intrinsic_set_dest_type(instr, val); }
bool nir_intrinsic_has_dest_type__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_dest_type(instr); }
unsigned int nir_intrinsic_swizzle_mask__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_swizzle_mask(instr); }
void nir_intrinsic_set_swizzle_mask__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_swizzle_mask(instr, val); }
bool nir_intrinsic_has_swizzle_mask__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_swizzle_mask(instr); }
bool nir_intrinsic_fetch_inactive__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_fetch_inactive(instr); }
void nir_intrinsic_set_fetch_inactive__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_fetch_inactive(instr, val); }
bool nir_intrinsic_has_fetch_inactive__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_fetch_inactive(instr); }
uint8_t nir_intrinsic_offset0__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_offset0(instr); }
void nir_intrinsic_set_offset0__extern(nir_intrinsic_instr *instr, uint8_t val) { nir_intrinsic_set_offset0(instr, val); }
bool nir_intrinsic_has_offset0__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_offset0(instr); }
uint8_t nir_intrinsic_offset1__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_offset1(instr); }
void nir_intrinsic_set_offset1__extern(nir_intrinsic_instr *instr, uint8_t val) { nir_intrinsic_set_offset1(instr, val); }
bool nir_intrinsic_has_offset1__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_offset1(instr); }
bool nir_intrinsic_st64__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_st64(instr); }
void nir_intrinsic_set_st64__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_st64(instr, val); }
bool nir_intrinsic_has_st64__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_st64(instr); }
unsigned int nir_intrinsic_arg_upper_bound_u32_amd__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_arg_upper_bound_u32_amd(instr); }
void nir_intrinsic_set_arg_upper_bound_u32_amd__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_arg_upper_bound_u32_amd(instr, val); }
bool nir_intrinsic_has_arg_upper_bound_u32_amd__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_arg_upper_bound_u32_amd(instr); }
enum gl_access_qualifier nir_intrinsic_dst_access__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_dst_access(instr); }
void nir_intrinsic_set_dst_access__extern(nir_intrinsic_instr *instr, enum gl_access_qualifier val) { nir_intrinsic_set_dst_access(instr, val); }
bool nir_intrinsic_has_dst_access__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_dst_access(instr); }
enum gl_access_qualifier nir_intrinsic_src_access__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_src_access(instr); }
void nir_intrinsic_set_src_access__extern(nir_intrinsic_instr *instr, enum gl_access_qualifier val) { nir_intrinsic_set_src_access(instr, val); }
bool nir_intrinsic_has_src_access__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_src_access(instr); }
unsigned int nir_intrinsic_driver_location__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_driver_location(instr); }
void nir_intrinsic_set_driver_location__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_driver_location(instr, val); }
bool nir_intrinsic_has_driver_location__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_driver_location(instr); }
nir_memory_semantics nir_intrinsic_memory_semantics__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_memory_semantics(instr); }
void nir_intrinsic_set_memory_semantics__extern(nir_intrinsic_instr *instr, nir_memory_semantics val) { nir_intrinsic_set_memory_semantics(instr, val); }
bool nir_intrinsic_has_memory_semantics__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_memory_semantics(instr); }
nir_variable_mode nir_intrinsic_memory_modes__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_memory_modes(instr); }
void nir_intrinsic_set_memory_modes__extern(nir_intrinsic_instr *instr, nir_variable_mode val) { nir_intrinsic_set_memory_modes(instr, val); }
bool nir_intrinsic_has_memory_modes__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_memory_modes(instr); }
mesa_scope nir_intrinsic_memory_scope__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_memory_scope(instr); }
void nir_intrinsic_set_memory_scope__extern(nir_intrinsic_instr *instr, mesa_scope val) { nir_intrinsic_set_memory_scope(instr, val); }
bool nir_intrinsic_has_memory_scope__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_memory_scope(instr); }
mesa_scope nir_intrinsic_execution_scope__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_execution_scope(instr); }
void nir_intrinsic_set_execution_scope__extern(nir_intrinsic_instr *instr, mesa_scope val) { nir_intrinsic_set_execution_scope(instr, val); }
bool nir_intrinsic_has_execution_scope__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_execution_scope(instr); }
struct nir_io_semantics nir_intrinsic_io_semantics__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_io_semantics(instr); }
void nir_intrinsic_set_io_semantics__extern(nir_intrinsic_instr *instr, struct nir_io_semantics val) { nir_intrinsic_set_io_semantics(instr, val); }
bool nir_intrinsic_has_io_semantics__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_io_semantics(instr); }
struct nir_io_xfb nir_intrinsic_io_xfb__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_io_xfb(instr); }
void nir_intrinsic_set_io_xfb__extern(nir_intrinsic_instr *instr, struct nir_io_xfb val) { nir_intrinsic_set_io_xfb(instr, val); }
bool nir_intrinsic_has_io_xfb__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_io_xfb(instr); }
struct nir_io_xfb nir_intrinsic_io_xfb2__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_io_xfb2(instr); }
void nir_intrinsic_set_io_xfb2__extern(nir_intrinsic_instr *instr, struct nir_io_xfb val) { nir_intrinsic_set_io_xfb2(instr, val); }
bool nir_intrinsic_has_io_xfb2__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_io_xfb2(instr); }
nir_ray_query_value nir_intrinsic_ray_query_value__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_ray_query_value(instr); }
void nir_intrinsic_set_ray_query_value__extern(nir_intrinsic_instr *instr, nir_ray_query_value val) { nir_intrinsic_set_ray_query_value(instr, val); }
bool nir_intrinsic_has_ray_query_value__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_ray_query_value(instr); }
bool nir_intrinsic_committed__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_committed(instr); }
void nir_intrinsic_set_committed__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_committed(instr, val); }
bool nir_intrinsic_has_committed__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_committed(instr); }
nir_rounding_mode nir_intrinsic_rounding_mode__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_rounding_mode(instr); }
void nir_intrinsic_set_rounding_mode__extern(nir_intrinsic_instr *instr, nir_rounding_mode val) { nir_intrinsic_set_rounding_mode(instr, val); }
bool nir_intrinsic_has_rounding_mode__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_rounding_mode(instr); }
unsigned int nir_intrinsic_saturate__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_saturate(instr); }
void nir_intrinsic_set_saturate__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_saturate(instr, val); }
bool nir_intrinsic_has_saturate__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_saturate(instr); }
bool nir_intrinsic_synchronous__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_synchronous(instr); }
void nir_intrinsic_set_synchronous__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_synchronous(instr, val); }
bool nir_intrinsic_has_synchronous__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_synchronous(instr); }
unsigned int nir_intrinsic_value_id__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_value_id(instr); }
void nir_intrinsic_set_value_id__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_value_id(instr, val); }
bool nir_intrinsic_has_value_id__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_value_id(instr); }
bool nir_intrinsic_sign_extend__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_sign_extend(instr); }
void nir_intrinsic_set_sign_extend__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_sign_extend(instr, val); }
bool nir_intrinsic_has_sign_extend__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_sign_extend(instr); }
unsigned int nir_intrinsic_flags__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_flags(instr); }
void nir_intrinsic_set_flags__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_flags(instr, val); }
bool nir_intrinsic_has_flags__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_flags(instr); }
nir_atomic_op nir_intrinsic_atomic_op__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_atomic_op(instr); }
void nir_intrinsic_set_atomic_op__extern(nir_intrinsic_instr *instr, nir_atomic_op val) { nir_intrinsic_set_atomic_op(instr, val); }
bool nir_intrinsic_has_atomic_op__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_atomic_op(instr); }
unsigned int nir_intrinsic_resource_block_intel__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_resource_block_intel(instr); }
void nir_intrinsic_set_resource_block_intel__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_resource_block_intel(instr, val); }
bool nir_intrinsic_has_resource_block_intel__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_resource_block_intel(instr); }
nir_resource_data_intel nir_intrinsic_resource_access_intel__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_resource_access_intel(instr); }
void nir_intrinsic_set_resource_access_intel__extern(nir_intrinsic_instr *instr, nir_resource_data_intel val) { nir_intrinsic_set_resource_access_intel(instr, val); }
bool nir_intrinsic_has_resource_access_intel__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_resource_access_intel(instr); }
unsigned int nir_intrinsic_num_components__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_num_components(instr); }
void nir_intrinsic_set_num_components__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_num_components(instr, val); }
bool nir_intrinsic_has_num_components__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_num_components(instr); }
unsigned int nir_intrinsic_num_array_elems__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_num_array_elems(instr); }
void nir_intrinsic_set_num_array_elems__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_num_array_elems(instr, val); }
bool nir_intrinsic_has_num_array_elems__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_num_array_elems(instr); }
unsigned int nir_intrinsic_bit_size__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_bit_size(instr); }
void nir_intrinsic_set_bit_size__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_bit_size(instr, val); }
bool nir_intrinsic_has_bit_size__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_bit_size(instr); }
bool nir_intrinsic_divergent__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_divergent(instr); }
void nir_intrinsic_set_divergent__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_divergent(instr, val); }
bool nir_intrinsic_has_divergent__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_divergent(instr); }
bool nir_intrinsic_legacy_fabs__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_legacy_fabs(instr); }
void nir_intrinsic_set_legacy_fabs__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_legacy_fabs(instr, val); }
bool nir_intrinsic_has_legacy_fabs__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_legacy_fabs(instr); }
bool nir_intrinsic_legacy_fneg__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_legacy_fneg(instr); }
void nir_intrinsic_set_legacy_fneg__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_legacy_fneg(instr, val); }
bool nir_intrinsic_has_legacy_fneg__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_legacy_fneg(instr); }
bool nir_intrinsic_legacy_fsat__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_legacy_fsat(instr); }
void nir_intrinsic_set_legacy_fsat__extern(nir_intrinsic_instr *instr, bool val) { nir_intrinsic_set_legacy_fsat(instr, val); }
bool nir_intrinsic_has_legacy_fsat__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_legacy_fsat(instr); }
struct glsl_cmat_description nir_intrinsic_cmat_desc__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_cmat_desc(instr); }
void nir_intrinsic_set_cmat_desc__extern(nir_intrinsic_instr *instr, struct glsl_cmat_description val) { nir_intrinsic_set_cmat_desc(instr, val); }
bool nir_intrinsic_has_cmat_desc__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_cmat_desc(instr); }
enum glsl_matrix_layout nir_intrinsic_matrix_layout__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_matrix_layout(instr); }
void nir_intrinsic_set_matrix_layout__extern(nir_intrinsic_instr *instr, enum glsl_matrix_layout val) { nir_intrinsic_set_matrix_layout(instr, val); }
bool nir_intrinsic_has_matrix_layout__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_matrix_layout(instr); }
nir_cmat_signed nir_intrinsic_cmat_signed_mask__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_cmat_signed_mask(instr); }
void nir_intrinsic_set_cmat_signed_mask__extern(nir_intrinsic_instr *instr, nir_cmat_signed val) { nir_intrinsic_set_cmat_signed_mask(instr, val); }
bool nir_intrinsic_has_cmat_signed_mask__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_cmat_signed_mask(instr); }
nir_op nir_intrinsic_alu_op__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_alu_op(instr); }
void nir_intrinsic_set_alu_op__extern(nir_intrinsic_instr *instr, nir_op val) { nir_intrinsic_set_alu_op(instr, val); }
bool nir_intrinsic_has_alu_op__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_alu_op(instr); }
unsigned int nir_intrinsic_systolic_depth__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_systolic_depth(instr); }
void nir_intrinsic_set_systolic_depth__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_systolic_depth(instr, val); }
bool nir_intrinsic_has_systolic_depth__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_systolic_depth(instr); }
unsigned int nir_intrinsic_repeat_count__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_repeat_count(instr); }
void nir_intrinsic_set_repeat_count__extern(nir_intrinsic_instr *instr, unsigned int val) { nir_intrinsic_set_repeat_count(instr, val); }
bool nir_intrinsic_has_repeat_count__extern(const nir_intrinsic_instr *instr) { return nir_intrinsic_has_repeat_count(instr); }
void nir_intrinsic_set_align__extern(nir_intrinsic_instr *intrin, unsigned int align_mul, unsigned int align_offset) { nir_intrinsic_set_align(intrin, align_mul, align_offset); }
uint32_t nir_combined_align__extern(uint32_t align_mul, uint32_t align_offset) { return nir_combined_align(align_mul, align_offset); }
unsigned int nir_intrinsic_align__extern(const nir_intrinsic_instr *intrin) { return nir_intrinsic_align(intrin); }
bool nir_intrinsic_has_align__extern(const nir_intrinsic_instr *intrin) { return nir_intrinsic_has_align(intrin); }
bool nir_intrinsic_can_reorder__extern(nir_intrinsic_instr *instr) { return nir_intrinsic_can_reorder(instr); }
bool nir_intrinsic_is_ray_query__extern(nir_intrinsic_op intrinsic) { return nir_intrinsic_is_ray_query(intrinsic); }
unsigned int nir_tex_instr_dest_size__extern(const nir_tex_instr *instr) { return nir_tex_instr_dest_size(instr); }
int nir_tex_instr_src_index__extern(const nir_tex_instr *instr, nir_tex_src_type type) { return nir_tex_instr_src_index(instr, type); }
nir_phi_src * nir_phi_get_src_from_block__extern(nir_phi_instr *phi, struct nir_block *block) { return nir_phi_get_src_from_block(phi, block); }
nir_alu_instr * nir_instr_as_alu__extern(const nir_instr *parent) { return nir_instr_as_alu(parent); }
nir_deref_instr * nir_instr_as_deref__extern(const nir_instr *parent) { return nir_instr_as_deref(parent); }
nir_call_instr * nir_instr_as_call__extern(const nir_instr *parent) { return nir_instr_as_call(parent); }
nir_jump_instr * nir_instr_as_jump__extern(const nir_instr *parent) { return nir_instr_as_jump(parent); }
nir_tex_instr * nir_instr_as_tex__extern(const nir_instr *parent) { return nir_instr_as_tex(parent); }
nir_intrinsic_instr * nir_instr_as_intrinsic__extern(const nir_instr *parent) { return nir_instr_as_intrinsic(parent); }
nir_load_const_instr * nir_instr_as_load_const__extern(const nir_instr *parent) { return nir_instr_as_load_const(parent); }
nir_undef_instr * nir_instr_as_undef__extern(const nir_instr *parent) { return nir_instr_as_undef(parent); }
nir_phi_instr * nir_instr_as_phi__extern(const nir_instr *parent) { return nir_instr_as_phi(parent); }
nir_parallel_copy_instr * nir_instr_as_parallel_copy__extern(const nir_instr *parent) { return nir_instr_as_parallel_copy(parent); }
int64_t nir_src_comp_as_int__extern(nir_src src, unsigned int comp) { return nir_src_comp_as_int(src, comp); }
int64_t nir_src_as_int__extern(nir_src src) { return nir_src_as_int(src); }
uint64_t nir_src_comp_as_uint__extern(nir_src src, unsigned int comp) { return nir_src_comp_as_uint(src, comp); }
uint64_t nir_src_as_uint__extern(nir_src src) { return nir_src_as_uint(src); }
bool nir_src_comp_as_bool__extern(nir_src src, unsigned int comp) { return nir_src_comp_as_bool(src, comp); }
bool nir_src_as_bool__extern(nir_src src) { return nir_src_as_bool(src); }
double nir_src_comp_as_float__extern(nir_src src, unsigned int comp) { return nir_src_comp_as_float(src, comp); }
double nir_src_as_float__extern(nir_src src) { return nir_src_as_float(src); }
bool nir_scalar_is_const__extern(nir_scalar s) { return nir_scalar_is_const(s); }
bool nir_scalar_is_undef__extern(nir_scalar s) { return nir_scalar_is_undef(s); }
nir_const_value nir_scalar_as_const_value__extern(nir_scalar s) { return nir_scalar_as_const_value(s); }
int64_t nir_scalar_as_int__extern(nir_scalar s) { return nir_scalar_as_int(s); }
uint64_t nir_scalar_as_uint__extern(nir_scalar s) { return nir_scalar_as_uint(s); }
bool nir_scalar_as_bool__extern(nir_scalar s) { return nir_scalar_as_bool(s); }
double nir_scalar_as_float__extern(nir_scalar s) { return nir_scalar_as_float(s); }
bool nir_scalar_is_alu__extern(nir_scalar s) { return nir_scalar_is_alu(s); }
nir_op nir_scalar_alu_op__extern(nir_scalar s) { return nir_scalar_alu_op(s); }
bool nir_scalar_is_intrinsic__extern(nir_scalar s) { return nir_scalar_is_intrinsic(s); }
nir_intrinsic_op nir_scalar_intrinsic_op__extern(nir_scalar s) { return nir_scalar_intrinsic_op(s); }
nir_scalar nir_scalar_chase_alu_src__extern(nir_scalar s, unsigned int alu_src_idx) { return nir_scalar_chase_alu_src(s, alu_src_idx); }
nir_scalar nir_get_scalar__extern(nir_def *def, unsigned int channel) { return nir_get_scalar(def, channel); }
nir_scalar nir_scalar_resolved__extern(nir_def *def, unsigned int channel) { return nir_scalar_resolved(def, channel); }
bool nir_scalar_equal__extern(nir_scalar s1, nir_scalar s2) { return nir_scalar_equal(s1, s2); }
uint64_t nir_alu_src_as_uint__extern(nir_alu_src src) { return nir_alu_src_as_uint(src); }
bool nir_block_is_reachable__extern(nir_block *b) { return nir_block_is_reachable(b); }
nir_instr * nir_block_first_instr__extern(nir_block *block) { return nir_block_first_instr(block); }
nir_instr * nir_block_last_instr__extern(nir_block *block) { return nir_block_last_instr(block); }
bool nir_block_ends_in_jump__extern(nir_block *block) { return nir_block_ends_in_jump(block); }
bool nir_block_ends_in_return_or_halt__extern(nir_block *block) { return nir_block_ends_in_return_or_halt(block); }
bool nir_block_ends_in_break__extern(nir_block *block) { return nir_block_ends_in_break(block); }
nir_phi_instr * nir_first_phi_in_block__extern(nir_block *block) { return nir_first_phi_in_block(block); }
nir_phi_instr * nir_next_phi__extern(nir_phi_instr *phi) { return nir_next_phi(phi); }
nir_phi_instr * nir_block_last_phi_instr__extern(nir_block *block) { return nir_block_last_phi_instr(block); }
nir_block * nir_start_block__extern(nir_function_impl *impl) { return nir_start_block(impl); }
nir_block * nir_impl_last_block__extern(nir_function_impl *impl) { return nir_impl_last_block(impl); }
nir_cf_node * nir_cf_node_next__extern(nir_cf_node *node) { return nir_cf_node_next(node); }
nir_cf_node * nir_cf_node_prev__extern(nir_cf_node *node) { return nir_cf_node_prev(node); }
bool nir_cf_node_is_first__extern(const nir_cf_node *node) { return nir_cf_node_is_first(node); }
bool nir_cf_node_is_last__extern(const nir_cf_node *node) { return nir_cf_node_is_last(node); }
nir_block * nir_cf_node_as_block__extern(const nir_cf_node *parent) { return nir_cf_node_as_block(parent); }
nir_if * nir_cf_node_as_if__extern(const nir_cf_node *parent) { return nir_cf_node_as_if(parent); }
nir_loop * nir_cf_node_as_loop__extern(const nir_cf_node *parent) { return nir_cf_node_as_loop(parent); }
nir_function_impl * nir_cf_node_as_function__extern(const nir_cf_node *parent) { return nir_cf_node_as_function(parent); }
nir_block * nir_if_first_then_block__extern(nir_if *if_stmt) { return nir_if_first_then_block(if_stmt); }
nir_block * nir_if_last_then_block__extern(nir_if *if_stmt) { return nir_if_last_then_block(if_stmt); }
nir_block * nir_if_first_else_block__extern(nir_if *if_stmt) { return nir_if_first_else_block(if_stmt); }
nir_block * nir_if_last_else_block__extern(nir_if *if_stmt) { return nir_if_last_else_block(if_stmt); }
nir_block * nir_loop_first_block__extern(nir_loop *loop) { return nir_loop_first_block(loop); }
nir_block * nir_loop_last_block__extern(nir_loop *loop) { return nir_loop_last_block(loop); }
bool nir_loop_has_continue_construct__extern(const nir_loop *loop) { return nir_loop_has_continue_construct(loop); }
nir_block * nir_loop_first_continue_block__extern(nir_loop *loop) { return nir_loop_first_continue_block(loop); }
nir_block * nir_loop_last_continue_block__extern(nir_loop *loop) { return nir_loop_last_continue_block(loop); }
nir_block * nir_loop_continue_target__extern(nir_loop *loop) { return nir_loop_continue_target(loop); }
bool nir_cf_list_is_empty_block__extern(struct exec_list *cf_list) { return nir_cf_list_is_empty_block(cf_list); }
nir_function * nir_foreach_function_with_impl_first__extern(const nir_shader *shader) { return nir_foreach_function_with_impl_first(shader); }
nir_function_impl * nir_foreach_function_with_impl_next__extern(nir_function **it) { return nir_foreach_function_with_impl_next(it); }
nir_function_impl * nir_shader_get_entrypoint__extern(const nir_shader *shader) { return nir_shader_get_entrypoint(shader); }
nir_function * nir_shader_get_function_for_name__extern(const nir_shader *shader, const char *name) { return nir_shader_get_function_for_name(shader, name); }
void nir_function_impl_add_variable__extern(nir_function_impl *impl, nir_variable *var) { nir_function_impl_add_variable(impl, var); }
void nir_function_set_impl__extern(nir_function *func, nir_function_impl *impl) { nir_function_set_impl(func, impl); }
nir_block * nir_cursor_current_block__extern(nir_cursor cursor) { return nir_cursor_current_block(cursor); }
nir_cursor nir_before_block__extern(nir_block *block) { return nir_before_block(block); }
nir_cursor nir_after_block__extern(nir_block *block) { return nir_after_block(block); }
nir_cursor nir_before_instr__extern(nir_instr *instr) { return nir_before_instr(instr); }
nir_cursor nir_after_instr__extern(nir_instr *instr) { return nir_after_instr(instr); }
nir_cursor nir_before_block_after_phis__extern(nir_block *block) { return nir_before_block_after_phis(block); }
nir_cursor nir_after_block_before_jump__extern(nir_block *block) { return nir_after_block_before_jump(block); }
nir_cursor nir_before_src__extern(nir_src *src) { return nir_before_src(src); }
nir_cursor nir_before_cf_node__extern(nir_cf_node *node) { return nir_before_cf_node(node); }
nir_cursor nir_after_cf_node__extern(nir_cf_node *node) { return nir_after_cf_node(node); }
nir_cursor nir_after_phis__extern(nir_block *block) { return nir_after_phis(block); }
nir_cursor nir_after_instr_and_phis__extern(nir_instr *instr) { return nir_after_instr_and_phis(instr); }
nir_cursor nir_after_cf_node_and_phis__extern(nir_cf_node *node) { return nir_after_cf_node_and_phis(node); }
nir_cursor nir_before_cf_list__extern(struct exec_list *cf_list) { return nir_before_cf_list(cf_list); }
nir_cursor nir_after_cf_list__extern(struct exec_list *cf_list) { return nir_after_cf_list(cf_list); }
nir_cursor nir_before_impl__extern(nir_function_impl *impl) { return nir_before_impl(impl); }
nir_cursor nir_after_impl__extern(nir_function_impl *impl) { return nir_after_impl(impl); }
void nir_instr_insert_before__extern(nir_instr *instr, nir_instr *before) { nir_instr_insert_before(instr, before); }
void nir_instr_insert_after__extern(nir_instr *instr, nir_instr *after) { nir_instr_insert_after(instr, after); }
void nir_instr_insert_before_block__extern(nir_block *block, nir_instr *before) { nir_instr_insert_before_block(block, before); }
void nir_instr_insert_after_block__extern(nir_block *block, nir_instr *after) { nir_instr_insert_after_block(block, after); }
void nir_instr_insert_before_cf__extern(nir_cf_node *node, nir_instr *before) { nir_instr_insert_before_cf(node, before); }
void nir_instr_insert_after_cf__extern(nir_cf_node *node, nir_instr *after) { nir_instr_insert_after_cf(node, after); }
void nir_instr_insert_before_cf_list__extern(struct exec_list *list, nir_instr *before) { nir_instr_insert_before_cf_list(list, before); }
void nir_instr_insert_after_cf_list__extern(struct exec_list *list, nir_instr *after) { nir_instr_insert_after_cf_list(list, after); }
nir_cursor nir_instr_remove__extern(nir_instr *instr) { return nir_instr_remove(instr); }
bool nir_foreach_src__extern(nir_instr *instr, nir_foreach_src_cb cb, void *state) { return nir_foreach_src(instr, cb, state); }
nir_alu_instr * nir_src_as_alu_instr__extern(nir_src src) { return nir_src_as_alu_instr(src); }
nir_intrinsic_instr * nir_src_as_intrinsic__extern(nir_src src) { return nir_src_as_intrinsic(src); }
void nir_src_rewrite__extern(nir_src *src, nir_def *new_ssa) { nir_src_rewrite(src, new_ssa); }
void nir_def_init_for_type__extern(nir_instr *instr, nir_def *def, const struct glsl_type *type) { nir_def_init_for_type(instr, def, type); }
void nir_def_replace__extern(nir_def *def, nir_def *new_ssa) { nir_def_replace(def, new_ssa); }
bool nir_def_is_unused__extern(nir_def *ssa) { return nir_def_is_unused(ssa); }
bool should_skip_nir__extern(const char *name) { return should_skip_nir(name); }
bool should_print_nir__extern(nir_shader *shader) { return should_print_nir(shader); }
const struct glsl_type * nir_address_format_to_glsl_type__extern(nir_address_format addr_format) { return nir_address_format_to_glsl_type(addr_format); }
bool nir_variable_is_in_ubo__extern(const nir_variable *var) { return nir_variable_is_in_ubo(var); }
bool nir_variable_is_in_ssbo__extern(const nir_variable *var) { return nir_variable_is_in_ssbo(var); }
bool nir_variable_is_in_block__extern(const nir_variable *var) { return nir_variable_is_in_block(var); }
unsigned int nir_variable_count_slots__extern(const nir_variable *var, const struct glsl_type *type) { return nir_variable_count_slots(var, type); }
unsigned int nir_deref_count_slots__extern(nir_deref_instr *deref, nir_variable *var) { return nir_deref_count_slots(deref, var); }
nir_intrinsic_instr * nir_reg_get_decl__extern(nir_def *reg) { return nir_reg_get_decl(reg); }
nir_intrinsic_instr * nir_next_decl_reg__extern(nir_intrinsic_instr *prev, nir_function_impl *impl) { return nir_next_decl_reg(prev, impl); }
nir_cursor nir_after_reg_decls__extern(nir_function_impl *impl) { return nir_after_reg_decls(impl); }
bool nir_is_load_reg__extern(nir_intrinsic_instr *intr) { return nir_is_load_reg(intr); }
bool nir_is_store_reg__extern(nir_intrinsic_instr *intr) { return nir_is_store_reg(intr); }
nir_intrinsic_instr * nir_load_reg_for_def__extern(const nir_def *def) { return nir_load_reg_for_def(def); }
nir_intrinsic_instr * nir_store_reg_for_def__extern(const nir_def *def) { return nir_store_reg_for_def(def); }
bool nir_foreach_def__extern(nir_instr *instr, nir_foreach_def_cb cb, void *state) { return nir_foreach_def(instr, cb, state); }
bool disk_cache_get_function_timestamp__extern(void *ptr, uint32_t *timestamp) { return disk_cache_get_function_timestamp(ptr, timestamp); }
bool disk_cache_get_function_identifier__extern(void *ptr, struct _SHA1_CTX *ctx) { return disk_cache_get_function_identifier(ptr, ctx); }
unsigned int u_minify__extern(unsigned int value, unsigned int levels) { return u_minify(value, levels); }
void u_box_1d__extern(unsigned int x, unsigned int w, struct pipe_box *box) { u_box_1d(x, w, box); }
void u_box_2d__extern(unsigned int x, unsigned int y, unsigned int w, unsigned int h, struct pipe_box *box) { u_box_2d(x, y, w, h, box); }
void u_box_origin_2d__extern(unsigned int w, unsigned int h, struct pipe_box *box) { u_box_origin_2d(w, h, box); }
void u_box_2d_zslice__extern(unsigned int x, unsigned int y, unsigned int z, unsigned int w, unsigned int h, struct pipe_box *box) { u_box_2d_zslice(x, y, z, w, h, box); }
void u_box_3d__extern(unsigned int x, unsigned int y, unsigned int z, unsigned int w, unsigned int h, unsigned int d, struct pipe_box *box) { u_box_3d(x, y, z, w, h, d, box); }
int u_box_clip_2d__extern(struct pipe_box *dst, const struct pipe_box *box, int w, int h) { return u_box_clip_2d(dst, box, w, h); }
int64_t u_box_volume_3d__extern(const struct pipe_box *box) { return u_box_volume_3d(box); }
void u_box_union_1d__extern(struct pipe_box *dst, const struct pipe_box *a, const struct pipe_box *b) { u_box_union_1d(dst, a, b); }
void u_box_intersect_1d__extern(struct pipe_box *dst, const struct pipe_box *a, const struct pipe_box *b) { u_box_intersect_1d(dst, a, b); }
void u_box_union_2d__extern(struct pipe_box *dst, const struct pipe_box *a, const struct pipe_box *b) { u_box_union_2d(dst, a, b); }
void u_box_union_3d__extern(struct pipe_box *dst, const struct pipe_box *a, const struct pipe_box *b) { u_box_union_3d(dst, a, b); }
bool u_box_test_intersection_1d__extern(const struct pipe_box *a, const struct pipe_box *b) { return u_box_test_intersection_1d(a, b); }
bool u_box_test_intersection_2d__extern(const struct pipe_box *a, const struct pipe_box *b) { return u_box_test_intersection_2d(a, b); }
bool u_box_test_intersection_3d__extern(const struct pipe_box *a, const struct pipe_box *b) { return u_box_test_intersection_3d(a, b); }
void u_box_minify_2d__extern(struct pipe_box *dst, const struct pipe_box *src, unsigned int l) { u_box_minify_2d(dst, src, l); }
void u_box_minify_3d__extern(struct pipe_box *dst, const struct pipe_box *src, unsigned int l) { u_box_minify_3d(dst, src, l); }
void u_box_pixels_to_blocks__extern(struct pipe_box *blocks, const struct pipe_box *pixels, enum pipe_format format) { u_box_pixels_to_blocks(blocks, pixels, format); }
void pipe_shader_state_from_tgsi__extern(struct pipe_shader_state *state, const struct tgsi_token *tokens) { pipe_shader_state_from_tgsi(state, tokens); }
char * mesa_bytes_to_hex__extern(char *buf, const unsigned char *binary, unsigned int len) { return mesa_bytes_to_hex(buf, binary, len); }
void mesa_hex_to_bytes__extern(unsigned char *buf, const char *hex, unsigned int len) { mesa_hex_to_bytes(buf, hex, len); }
void pipe_reference_init__extern(struct pipe_reference *dst, unsigned int count) { pipe_reference_init(dst, count); }
bool pipe_is_referenced__extern(struct pipe_reference *src) { return pipe_is_referenced(src); }
bool pipe_reference_described__extern(struct pipe_reference *dst, struct pipe_reference *src, debug_reference_descriptor get_desc) { return pipe_reference_described(dst, src, get_desc); }
bool pipe_reference__extern(struct pipe_reference *dst, struct pipe_reference *src) { return pipe_reference(dst, src); }
void pipe_surface_reference__extern(struct pipe_surface **dst, struct pipe_surface *src) { pipe_surface_reference(dst, src); }
void pipe_surface_release__extern(struct pipe_context *pipe, struct pipe_surface **ptr) { pipe_surface_release(pipe, ptr); }
void pipe_resource_destroy__extern(struct pipe_resource *res) { pipe_resource_destroy(res); }
void pipe_resource_reference__extern(struct pipe_resource **dst, struct pipe_resource *src) { pipe_resource_reference(dst, src); }
void pipe_drop_resource_references__extern(struct pipe_resource *dst, int num_refs) { pipe_drop_resource_references(dst, num_refs); }
void pipe_surface_release_no_context__extern(struct pipe_surface **ptr) { pipe_surface_release_no_context(ptr); }
void pipe_sampler_view_reference__extern(struct pipe_sampler_view **dst, struct pipe_sampler_view *src) { pipe_sampler_view_reference(dst, src); }
void pipe_so_target_reference__extern(struct pipe_stream_output_target **dst, struct pipe_stream_output_target *src) { pipe_so_target_reference(dst, src); }
void pipe_vertex_state_reference__extern(struct pipe_vertex_state **dst, struct pipe_vertex_state *src) { pipe_vertex_state_reference(dst, src); }
void pipe_vertex_buffer_unreference__extern(struct pipe_vertex_buffer *dst) { pipe_vertex_buffer_unreference(dst); }
void pipe_vertex_buffer_reference__extern(struct pipe_vertex_buffer *dst, const struct pipe_vertex_buffer *src) { pipe_vertex_buffer_reference(dst, src); }
void pipe_surface_reset__extern(struct pipe_context *ctx, struct pipe_surface *ps, struct pipe_resource *pt, unsigned int level, unsigned int layer) { pipe_surface_reset(ctx, ps, pt, level, layer); }
void pipe_surface_init__extern(struct pipe_context *ctx, struct pipe_surface *ps, struct pipe_resource *pt, unsigned int level, unsigned int layer) { pipe_surface_init(ctx, ps, pt, level, layer); }
bool pipe_surface_equal__extern(struct pipe_surface *s1, struct pipe_surface *s2) { return pipe_surface_equal(s1, s2); }
unsigned int pipe_buffer_size__extern(const struct pipe_resource *buffer) { return pipe_buffer_size(buffer); }
struct pipe_resource * pipe_buffer_create__extern(struct pipe_screen *screen, unsigned int bind, enum pipe_resource_usage usage, unsigned int size) { return pipe_buffer_create(screen, bind, usage, size); }
struct pipe_resource * pipe_buffer_create_const0__extern(struct pipe_screen *screen, unsigned int bind, enum pipe_resource_usage usage, unsigned int size) { return pipe_buffer_create_const0(screen, bind, usage, size); }
void * pipe_buffer_map_range__extern(struct pipe_context *pipe, struct pipe_resource *buffer, unsigned int offset, unsigned int length, unsigned int access, struct pipe_transfer **transfer) { return pipe_buffer_map_range(pipe, buffer, offset, length, access, transfer); }
void * pipe_buffer_map__extern(struct pipe_context *pipe, struct pipe_resource *buffer, unsigned int access, struct pipe_transfer **transfer) { return pipe_buffer_map(pipe, buffer, access, transfer); }
void pipe_buffer_unmap__extern(struct pipe_context *pipe, struct pipe_transfer *transfer) { pipe_buffer_unmap(pipe, transfer); }
void pipe_buffer_flush_mapped_range__extern(struct pipe_context *pipe, struct pipe_transfer *transfer, unsigned int offset, unsigned int length) { pipe_buffer_flush_mapped_range(pipe, transfer, offset, length); }
void pipe_buffer_write__extern(struct pipe_context *pipe, struct pipe_resource *buf, unsigned int offset, unsigned int size, const void *data) { pipe_buffer_write(pipe, buf, offset, size, data); }
void pipe_buffer_write_nooverlap__extern(struct pipe_context *pipe, struct pipe_resource *buf, unsigned int offset, unsigned int size, const void *data) { pipe_buffer_write_nooverlap(pipe, buf, offset, size, data); }
void pipe_buffer_copy__extern(struct pipe_context *pipe, struct pipe_resource *dst, struct pipe_resource *src, unsigned int dst_offset, unsigned int src_offset, unsigned int size) { pipe_buffer_copy(pipe, dst, src, dst_offset, src_offset, size); }
struct pipe_resource * pipe_buffer_create_with_data__extern(struct pipe_context *pipe, unsigned int bind, enum pipe_resource_usage usage, unsigned int size, const void *ptr) { return pipe_buffer_create_with_data(pipe, bind, usage, size, ptr); }
void pipe_buffer_read__extern(struct pipe_context *pipe, struct pipe_resource *buf, unsigned int offset, unsigned int size, void *data) { pipe_buffer_read(pipe, buf, offset, size, data); }
void * pipe_texture_map__extern(struct pipe_context *context, struct pipe_resource *resource, unsigned int level, unsigned int layer, unsigned int access, unsigned int x, unsigned int y, unsigned int w, unsigned int h, struct pipe_transfer **transfer) { return pipe_texture_map(context, resource, level, layer, access, x, y, w, h, transfer); }
void * pipe_texture_map_3d__extern(struct pipe_context *context, struct pipe_resource *resource, unsigned int level, unsigned int access, unsigned int x, unsigned int y, unsigned int z, unsigned int w, unsigned int h, unsigned int d, struct pipe_transfer **transfer) { return pipe_texture_map_3d(context, resource, level, access, x, y, z, w, h, d, transfer); }
void pipe_texture_unmap__extern(struct pipe_context *context, struct pipe_transfer *transfer) { pipe_texture_unmap(context, transfer); }
void pipe_set_constant_buffer__extern(struct pipe_context *pipe, enum pipe_shader_type shader, uint index, struct pipe_resource *buf) { pipe_set_constant_buffer(pipe, shader, index, buf); }
struct pipe_context * pipe_create_multimedia_context__extern(struct pipe_screen *screen) { return pipe_create_multimedia_context(screen); }
