From b8e792e7cc639c33a643d743fee3de1893873f03 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Fri, 28 Oct 2022 10:14:27 -0600 Subject: [PATCH] gallivm: clean-ups in lp_bld_sample.c Formatting/whitespace fixes. Add const qualifiers, move var decls, etc. Signed-off-by: Brian Paul Part-of: --- src/gallium/auxiliary/gallivm/lp_bld_sample.c | 475 +++++++++++++------------- 1 file changed, 247 insertions(+), 228 deletions(-) diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.c b/src/gallium/auxiliary/gallivm/lp_bld_sample.c index 3c2a444..b6be63d 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.c @@ -56,6 +56,7 @@ */ #define BRILINEAR_FACTOR 2 + /** * Does the given texture wrap mode allow sampling the texture border color? * XXX maybe move this into gallium util code. @@ -106,7 +107,7 @@ lp_sampler_static_texture_state(struct lp_static_texture_state *state, const struct pipe_resource *texture = view->texture; state->format = view->format; - state->res_format = view->texture->format; + state->res_format = texture->format; state->swizzle_r = view->swizzle_r; state->swizzle_g = view->swizzle_g; state->swizzle_b = view->swizzle_b; @@ -128,6 +129,7 @@ lp_sampler_static_texture_state(struct lp_static_texture_state *state, */ } + /** * Initialize lp_sampler_static_texture_state object with the gallium * texture/sampler_view state (this contains the parts which are @@ -145,7 +147,7 @@ lp_sampler_static_texture_state_image(struct lp_static_texture_state *state, const struct pipe_resource *resource = view->resource; state->format = view->format; - state->res_format = view->resource->format; + state->res_format = resource->format; state->swizzle_r = PIPE_SWIZZLE_X; state->swizzle_g = PIPE_SWIZZLE_Y; state->swizzle_b = PIPE_SWIZZLE_Z; @@ -155,7 +157,7 @@ lp_sampler_static_texture_state_image(struct lp_static_texture_state *state, assert(state->swizzle_b < PIPE_SWIZZLE_NONE); assert(state->swizzle_a < PIPE_SWIZZLE_NONE); - state->target = view->resource->target; + state->target = resource->target; state->pot_width = util_is_power_of_two_or_zero(resource->width0); state->pot_height = util_is_power_of_two_or_zero(resource->height0); state->pot_depth = util_is_power_of_two_or_zero(resource->depth0); @@ -167,6 +169,7 @@ lp_sampler_static_texture_state_image(struct lp_static_texture_state *state, */ } + /** * Initialize lp_sampler_static_sampler_state object with the gallium sampler * state (this contains the parts which are considered static). @@ -241,6 +244,7 @@ lp_sampler_static_sampler_state(struct lp_static_sampler_state *state, state->normalized_coords = !sampler->unnormalized_coords; } + /* build aniso pmin value */ static LLVMValueRef lp_build_pmin(struct lp_build_sample_context *bld, @@ -260,10 +264,9 @@ lp_build_pmin(struct lp_build_sample_context *bld, LLVMValueRef index1 = LLVMConstInt(i32t, 1, 0); LLVMValueRef ddx_ddy = lp_build_packed_ddx_ddy_twocoord(coord_bld, s, t); LLVMValueRef int_size, float_size; - unsigned length = coord_bld->type.length; - unsigned num_quads = length / 4; - boolean pmin_per_quad = pmin_bld->type.length != length; - unsigned i; + const unsigned length = coord_bld->type.length; + const unsigned num_quads = length / 4; + const boolean pmin_per_quad = pmin_bld->type.length != length; int_size = lp_build_minify(int_size_bld, bld->int_size, first_level, TRUE); float_size = lp_build_int_to_float(float_size_bld, int_size); @@ -280,7 +283,7 @@ lp_build_pmin(struct lp_build_sample_context *bld, }; LLVMValueRef ddx_ddys, ddx_ddyt, floatdim, shuffles[LP_MAX_VECTOR_LENGTH / 4]; - for (i = 0; i < num_quads; i++) { + for (unsigned i = 0; i < num_quads; i++) { shuffles[i*4+0] = shuffles[i*4+1] = index0; shuffles[i*4+2] = shuffles[i*4+3] = index1; } @@ -326,6 +329,7 @@ lp_build_pmin(struct lp_build_sample_context *bld, return pmin2; } + /** * Generate code to compute coordinate gradient (rho). * \param derivs partial derivatives of (s, t, r, q) with respect to X and Y @@ -354,34 +358,35 @@ lp_build_rho(struct lp_build_sample_context *bld, LLVMValueRef index1 = LLVMConstInt(i32t, 1, 0); LLVMValueRef index2 = LLVMConstInt(i32t, 2, 0); LLVMValueRef rho_vec; - LLVMValueRef int_size, float_size; LLVMValueRef rho; unsigned length = coord_bld->type.length; unsigned num_quads = length / 4; boolean rho_per_quad = rho_bld->type.length != length; boolean no_rho_opt = bld->no_rho_approx && (dims > 1); - unsigned i; LLVMValueRef i32undef = LLVMGetUndef(LLVMInt32TypeInContext(gallivm->context)); LLVMValueRef rho_xvec, rho_yvec; - /* Note that all simplified calculations will only work for isotropic filtering */ + /* Note that all simplified calculations will only work for isotropic + * filtering + */ /* * rho calcs are always per quad except for explicit derivs (excluding * the messy cube maps for now) when requested. */ - int_size = lp_build_minify(int_size_bld, bld->int_size, first_level, TRUE); - float_size = lp_build_int_to_float(float_size_bld, int_size); + LLVMValueRef int_size = + lp_build_minify(int_size_bld, bld->int_size, first_level, TRUE); + LLVMValueRef float_size = lp_build_int_to_float(float_size_bld, int_size); if (derivs) { LLVMValueRef ddmax[3] = { NULL }, ddx[3] = { NULL }, ddy[3] = { NULL }; - for (i = 0; i < dims; i++) { - LLVMValueRef floatdim; + for (unsigned i = 0; i < dims; i++) { LLVMValueRef indexi = lp_build_const_int32(gallivm, i); - floatdim = lp_build_extract_broadcast(gallivm, bld->float_size_in_type, - coord_bld->type, float_size, indexi); + LLVMValueRef floatdim = + lp_build_extract_broadcast(gallivm, bld->float_size_in_type, + coord_bld->type, float_size, indexi); /* * note that for rho_per_quad case could reduce math (at some shuffle @@ -392,11 +397,9 @@ lp_build_rho(struct lp_build_sample_context *bld, ddy[i] = lp_build_mul(coord_bld, floatdim, derivs->ddy[i]); ddx[i] = lp_build_mul(coord_bld, ddx[i], ddx[i]); ddy[i] = lp_build_mul(coord_bld, ddy[i], ddy[i]); - } - else { - LLVMValueRef tmpx, tmpy; - tmpx = lp_build_abs(coord_bld, derivs->ddx[i]); - tmpy = lp_build_abs(coord_bld, derivs->ddy[i]); + } else { + LLVMValueRef tmpx = lp_build_abs(coord_bld, derivs->ddx[i]); + LLVMValueRef tmpy = lp_build_abs(coord_bld, derivs->ddy[i]); ddmax[i] = lp_build_max(coord_bld, tmpx, tmpy); ddmax[i] = lp_build_mul(coord_bld, floatdim, ddmax[i]); } @@ -410,8 +413,7 @@ lp_build_rho(struct lp_build_sample_context *bld, } rho = lp_build_max(coord_bld, rho_xvec, rho_yvec); /* skipping sqrt hence returning rho squared */ - } - else { + } else { rho = ddmax[0]; if (dims > 1) { rho = lp_build_max(coord_bld, rho, ddmax[1]); @@ -421,7 +423,8 @@ lp_build_rho(struct lp_build_sample_context *bld, } } - LLVMValueRef rho_is_inf = lp_build_is_inf_or_nan(gallivm, coord_bld->type, rho); + LLVMValueRef rho_is_inf = lp_build_is_inf_or_nan(gallivm, + coord_bld->type, rho); rho = lp_build_select(coord_bld, rho_is_inf, coord_bld->zero, rho); if (rho_per_quad) { @@ -431,8 +434,7 @@ lp_build_rho(struct lp_build_sample_context *bld, rho = lp_build_pack_aos_scalars(bld->gallivm, coord_bld->type, rho_bld->type, rho, 0); } - } - else { + } else { /* * This looks all a bit complex, but it's not that bad * (the shuffle code makes it look worse than it is). @@ -453,8 +455,7 @@ lp_build_rho(struct lp_build_sample_context *bld, if (dims < 2) { ddx_ddy[0] = lp_build_packed_ddx_ddy_onecoord(coord_bld, s); - } - else if (dims >= 2) { + } else if (dims >= 2) { ddx_ddy[0] = lp_build_packed_ddx_ddy_twocoord(coord_bld, s, t); if (dims > 2) { ddx_ddy[1] = lp_build_packed_ddx_ddy_onecoord(coord_bld, r); @@ -470,14 +471,16 @@ lp_build_rho(struct lp_build_sample_context *bld, 2, 3, LP_BLD_SWIZZLE_DONTCARE, LP_BLD_SWIZZLE_DONTCARE }; - LLVMValueRef ddx_ddys, ddx_ddyt, floatdim, shuffles[LP_MAX_VECTOR_LENGTH / 4]; + LLVMValueRef ddx_ddys, ddx_ddyt, floatdim; + LLVMValueRef shuffles[LP_MAX_VECTOR_LENGTH / 4]; - for (i = 0; i < num_quads; i++) { + for (unsigned i = 0; i < num_quads; i++) { shuffles[i*4+0] = shuffles[i*4+1] = index0; shuffles[i*4+2] = shuffles[i*4+3] = index1; } floatdim = LLVMBuildShuffleVector(builder, float_size, float_size, - LLVMConstVector(shuffles, length), ""); + LLVMConstVector(shuffles, length), + ""); ddx_ddy[0] = lp_build_mul(coord_bld, ddx_ddy[0], floatdim); ddx_ddy[0] = lp_build_mul(coord_bld, ddx_ddy[0], ddx_ddy[0]); ddx_ddys = lp_build_swizzle_aos(coord_bld, ddx_ddy[0], swizzle01); @@ -504,26 +507,22 @@ lp_build_rho(struct lp_build_sample_context *bld, if (rho_per_quad) { rho = lp_build_pack_aos_scalars(bld->gallivm, coord_bld->type, rho_bld->type, rho, 0); - } - else { + } else { rho = lp_build_swizzle_scalar_aos(coord_bld, rho, 0, 4); } /* skipping sqrt hence returning rho squared */ - } - else { + } else { ddx_ddy[0] = lp_build_abs(coord_bld, ddx_ddy[0]); if (dims > 2) { ddx_ddy[1] = lp_build_abs(coord_bld, ddx_ddy[1]); - } - else { + } else { ddx_ddy[1] = NULL; /* silence compiler warning */ } if (dims < 2) { rho_xvec = lp_build_swizzle_aos(coord_bld, ddx_ddy[0], swizzle0); rho_yvec = lp_build_swizzle_aos(coord_bld, ddx_ddy[0], swizzle2); - } - else if (dims == 2) { + } else if (dims == 2) { static const unsigned char swizzle02[] = { 0, 2, LP_BLD_SWIZZLE_DONTCARE, LP_BLD_SWIZZLE_DONTCARE @@ -534,12 +533,11 @@ lp_build_rho(struct lp_build_sample_context *bld, }; rho_xvec = lp_build_swizzle_aos(coord_bld, ddx_ddy[0], swizzle02); rho_yvec = lp_build_swizzle_aos(coord_bld, ddx_ddy[0], swizzle13); - } - else { + } else { LLVMValueRef shuffles1[LP_MAX_VECTOR_LENGTH]; LLVMValueRef shuffles2[LP_MAX_VECTOR_LENGTH]; assert(dims == 3); - for (i = 0; i < num_quads; i++) { + for (unsigned i = 0; i < num_quads; i++) { shuffles1[4*i + 0] = lp_build_const_int32(gallivm, 4*i); shuffles1[4*i + 1] = lp_build_const_int32(gallivm, 4*i + 2); shuffles1[4*i + 2] = lp_build_const_int32(gallivm, length + 4*i); @@ -562,20 +560,19 @@ lp_build_rho(struct lp_build_sample_context *bld, if (dims > 1) { /* could use some broadcast_vector helper for this? */ LLVMValueRef src[LP_MAX_VECTOR_LENGTH/4]; - for (i = 0; i < num_quads; i++) { + for (unsigned i = 0; i < num_quads; i++) { src[i] = float_size; } - float_size = lp_build_concat(bld->gallivm, src, float_size_bld->type, num_quads); - } - else { + float_size = lp_build_concat(bld->gallivm, src, + float_size_bld->type, num_quads); + } else { float_size = lp_build_broadcast_scalar(coord_bld, float_size); } rho_vec = lp_build_mul(coord_bld, rho_vec, float_size); if (dims <= 1) { rho = rho_vec; - } - else { + } else { if (dims >= 2) { LLVMValueRef rho_s, rho_t, rho_r; @@ -593,12 +590,10 @@ lp_build_rho(struct lp_build_sample_context *bld, if (rho_per_quad) { rho = lp_build_pack_aos_scalars(bld->gallivm, coord_bld->type, rho_bld->type, rho, 0); - } - else { + } else { rho = lp_build_swizzle_scalar_aos(coord_bld, rho, 0, 4); } - } - else { + } else { if (dims <= 1) { rho_vec = LLVMBuildExtractElement(builder, rho_vec, index0, ""); } @@ -606,8 +601,7 @@ lp_build_rho(struct lp_build_sample_context *bld, if (dims <= 1) { rho = rho_vec; - } - else { + } else { if (dims >= 2) { LLVMValueRef rho_s, rho_t, rho_r; @@ -717,9 +711,6 @@ lp_build_brilinear_rho(struct lp_build_context *bld, LLVMValueRef *out_lod_ipart, LLVMValueRef *out_lod_fpart) { - LLVMValueRef lod_ipart; - LLVMValueRef lod_fpart; - const double pre_factor = (2*factor - 0.5)/(M_SQRT2*factor); const double post_offset = 1 - 2*factor; @@ -736,14 +727,15 @@ lp_build_brilinear_rho(struct lp_build_context *bld, lp_build_const_vec(bld->gallivm, bld->type, pre_factor)); /* ipart = ifloor(log2(rho)) */ - lod_ipart = lp_build_extract_exponent(bld, rho, 0); + LLVMValueRef lod_ipart = lp_build_extract_exponent(bld, rho, 0); /* fpart = rho / 2**ipart */ - lod_fpart = lp_build_extract_mantissa(bld, rho); + LLVMValueRef lod_fpart = lp_build_extract_mantissa(bld, rho); - lod_fpart = lp_build_mad(bld, lod_fpart, - lp_build_const_vec(bld->gallivm, bld->type, factor), - lp_build_const_vec(bld->gallivm, bld->type, post_offset)); + lod_fpart = + lp_build_mad(bld, lod_fpart, + lp_build_const_vec(bld->gallivm, bld->type, factor), + lp_build_const_vec(bld->gallivm, bld->type, post_offset)); /* * Like lp_build_brilinear_lod, it's not necessary to clamp lod_fpart since: @@ -768,7 +760,6 @@ lp_build_ilog2_sqrt(struct lp_build_context *bld, LLVMValueRef x) { LLVMBuilderRef builder = bld->gallivm->builder; - LLVMValueRef ipart; struct lp_type i_type = lp_int_type(bld->type); LLVMValueRef one = lp_build_const_int_vec(bld->gallivm, i_type, 1); @@ -777,7 +768,7 @@ lp_build_ilog2_sqrt(struct lp_build_context *bld, assert(lp_check_value(bld->type, x)); /* ipart = log2(x) + 0.5 = 0.5*(log2(x^2) + 1.0) */ - ipart = lp_build_extract_exponent(bld, x, 1); + LLVMValueRef ipart = lp_build_extract_exponent(bld, x, 1); ipart = LLVMBuildAShr(builder, ipart, one, ""); return ipart; @@ -824,21 +815,21 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, *out_lod_fpart = lodf_bld->zero; /* - * For determining min/mag, we follow GL 4.1 spec, 3.9.12 Texture Magnification: - * "Implementations may either unconditionally assume c = 0 for the minification - * vs. magnification switch-over point, or may choose to make c depend on the - * combination of minification and magnification modes as follows: if the - * magnification filter is given by LINEAR and the minification filter is given - * by NEAREST_MIPMAP_NEAREST or NEAREST_MIPMAP_LINEAR, then c = 0.5. This is - * done to ensure that a minified texture does not appear "sharper" than a - * magnified texture. Otherwise c = 0." - * And 3.9.11 Texture Minification: - * "If lod is less than or equal to the constant c (see section 3.9.12) the - * texture is said to be magnified; if it is greater, the texture is minified." - * So, using 0 as switchover point always, and using magnification for lod == 0. - * Note that the always c = 0 behavior is new (first appearing in GL 3.1 spec), - * old GL versions required 0.5 for the modes listed above. - * I have no clue about the (undocumented) wishes of d3d9/d3d10 here! + * For determining min/mag, we follow GL 4.1 spec, 3.9.12 Texture + * Magnification: "Implementations may either unconditionally assume c = 0 + * for the minification vs. magnification switch-over point, or may choose + * to make c depend on the combination of minification and magnification + * modes as follows: if the magnification filter is given by LINEAR and the + * minification filter is given by NEAREST_MIPMAP_NEAREST or + * NEAREST_MIPMAP_LINEAR, then c = 0.5. This is done to ensure that a + * minified texture does not appear "sharper" than a magnified + * texture. Otherwise c = 0." And 3.9.11 Texture Minification: "If lod is + * less than or equal to the constant c (see section 3.9.12) the texture is + * said to be magnified; if it is greater, the texture is minified." So, + * using 0 as switchover point always, and using magnification for lod == + * 0. Note that the always c = 0 behavior is new (first appearing in GL + * 3.1 spec), old GL versions required 0.5 for the modes listed above. I + * have no clue about the (undocumented) wishes of d3d9/d3d10 here! */ if (bld->static_sampler_state->min_max_lod_equal && !is_lodq) { @@ -850,16 +841,14 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, bld->context_ptr, sampler_unit); lod = lp_build_broadcast_scalar(lodf_bld, min_lod); - } - else { + } else { if (explicit_lod) { if (bld->num_lods != bld->coord_type.length) lod = lp_build_pack_aos_scalars(bld->gallivm, bld->coord_bld.type, lodf_bld->type, explicit_lod, 0); else lod = explicit_lod; - } - else { + } else { LLVMValueRef rho; boolean rho_squared = bld->no_rho_approx && (bld->dims > 1); @@ -867,8 +856,9 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, !explicit_lod) { rho = lp_build_pmin(bld, first_level, s, t, max_aniso); rho_squared = true; - } else + } else { rho = lp_build_rho(bld, first_level, s, t, r, derivs); + } /* * Compute lod = log2(rho) @@ -893,8 +883,7 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, */ if (rho_squared) { *out_lod_ipart = lp_build_ilog2_sqrt(lodf_bld, rho); - } - else { + } else { *out_lod_ipart = lp_build_ilog2(lodf_bld, rho); } *out_lod_positive = lp_build_cmp(lodf_bld, PIPE_FUNC_GREATER, @@ -920,8 +909,7 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, if (0) { lod = lp_build_log2(lodf_bld, rho); - } - else { + } else { /* get more accurate results if we just sqaure rho always */ if (!rho_squared) rho = lp_build_mul(lodf_bld, rho, rho); @@ -930,13 +918,16 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, /* log2(x^2) == 0.5*log2(x) */ lod = lp_build_mul(lodf_bld, lod, - lp_build_const_vec(bld->gallivm, lodf_bld->type, 0.5F)); + lp_build_const_vec(bld->gallivm, + lodf_bld->type, 0.5F)); /* add shader lod bias */ if (lod_bias) { if (bld->num_lods != bld->coord_type.length) - lod_bias = lp_build_pack_aos_scalars(bld->gallivm, bld->coord_bld.type, - lodf_bld->type, lod_bias, 0); + lod_bias = lp_build_pack_aos_scalars(bld->gallivm, + bld->coord_bld.type, + lodf_bld->type, + lod_bias, 0); lod = LLVMBuildFAdd(builder, lod, lod_bias, "shader_lod_bias"); } } @@ -988,14 +979,12 @@ lp_build_lod_selector(struct lp_build_sample_context *bld, if (!bld->no_brilinear) { lp_build_brilinear_lod(lodf_bld, lod, BRILINEAR_FACTOR, out_lod_ipart, out_lod_fpart); - } - else { + } else { lp_build_ifloor_fract(lodf_bld, lod, out_lod_ipart, out_lod_fpart); } lp_build_name(*out_lod_fpart, "lod_fpart"); - } - else { + } else { *out_lod_ipart = lp_build_iround(lodf_bld, lod); } @@ -1022,9 +1011,7 @@ lp_build_nearest_mip_level(struct lp_build_sample_context *bld, LLVMValueRef *out_of_bounds) { struct lp_build_context *leveli_bld = &bld->leveli_bld; - LLVMValueRef level; - - level = lp_build_add(leveli_bld, lod_ipart, first_level); + LLVMValueRef level = lp_build_add(leveli_bld, lod_ipart, first_level); if (out_of_bounds) { LLVMValueRef out, out1; @@ -1033,21 +1020,19 @@ lp_build_nearest_mip_level(struct lp_build_sample_context *bld, out = lp_build_or(leveli_bld, out, out1); if (bld->num_mips == bld->coord_bld.type.length) { *out_of_bounds = out; - } - else if (bld->num_mips == 1) { + } else if (bld->num_mips == 1) { *out_of_bounds = lp_build_broadcast_scalar(&bld->int_coord_bld, out); - } - else { + } else { assert(bld->num_mips == bld->coord_bld.type.length / 4); - *out_of_bounds = lp_build_unpack_broadcast_aos_scalars(bld->gallivm, - leveli_bld->type, - bld->int_coord_bld.type, - out); + *out_of_bounds = + lp_build_unpack_broadcast_aos_scalars(bld->gallivm, + leveli_bld->type, + bld->int_coord_bld.type, + out); } level = lp_build_andnot(&bld->int_coord_bld, level, *out_of_bounds); *level_out = level; - } - else { + } else { /* clamp level to legal range of levels */ *level_out = lp_build_clamp(leveli_bld, level, first_level, last_level); @@ -1059,7 +1044,8 @@ lp_build_nearest_mip_level(struct lp_build_sample_context *bld, * For PIPE_TEX_MIPFILTER_LINEAR, convert per-quad (or per element) int LOD(s) * to two (per-quad) (adjacent) mipmap level indexes, and fix up float lod * part accordingly. - * Later, we'll sample from those two mipmap levels and interpolate between them. + * Later, we'll sample from those two mipmap levels and interpolate between + * them. */ void lp_build_linear_mip_levels(struct lp_build_sample_context *bld, @@ -1083,9 +1069,9 @@ lp_build_linear_mip_levels(struct lp_build_sample_context *bld, *level1_out = lp_build_add(leveli_bld, *level0_out, leveli_bld->one); /* - * Clamp both *level0_out and *level1_out to [first_level, last_level], with - * the minimum number of comparisons, and zeroing lod_fpart in the extreme - * ends in the process. + * Clamp both *level0_out and *level1_out to [first_level, last_level], + * with the minimum number of comparisons, and zeroing lod_fpart in the + * extreme ends in the process. */ /* *level0_out < first_level */ @@ -1121,18 +1107,25 @@ lp_build_linear_mip_levels(struct lp_build_sample_context *bld, lp_build_name(*lod_fpart_inout, "texture%u_mipweight", texture_unit); } + /** * A helper function that factorizes this common pattern. */ static LLVMValueRef load_mip(struct gallivm_state *gallivm, - LLVMTypeRef ptr_type, LLVMValueRef offsets, LLVMValueRef index1) { + LLVMTypeRef ptr_type, + LLVMValueRef offsets, + LLVMValueRef index1) +{ LLVMValueRef zero = lp_build_const_int32(gallivm, 0); LLVMValueRef indexes[2] = {zero, index1}; - LLVMValueRef ptr = LLVMBuildGEP2(gallivm->builder, ptr_type, offsets, indexes, ARRAY_SIZE(indexes), ""); - return LLVMBuildLoad2(gallivm->builder, LLVMInt32TypeInContext(gallivm->context), ptr, ""); + LLVMValueRef ptr = LLVMBuildGEP2(gallivm->builder, ptr_type, offsets, + indexes, ARRAY_SIZE(indexes), ""); + return LLVMBuildLoad2(gallivm->builder, + LLVMInt32TypeInContext(gallivm->context), ptr, ""); } + /** * Return pointer to a single mipmap level. * \param level integer mipmap level @@ -1141,14 +1134,17 @@ LLVMValueRef lp_build_get_mipmap_level(struct lp_build_sample_context *bld, LLVMValueRef level) { - LLVMValueRef mip_offset = load_mip(bld->gallivm, bld->mip_offsets_type, bld->mip_offsets, level); + LLVMValueRef mip_offset = load_mip(bld->gallivm, bld->mip_offsets_type, + bld->mip_offsets, level); LLVMBuilderRef builder = bld->gallivm->builder; - LLVMValueRef data_ptr = LLVMBuildGEP2(builder, - LLVMInt8TypeInContext(bld->gallivm->context), - bld->base_ptr, &mip_offset, 1, ""); + LLVMValueRef data_ptr = + LLVMBuildGEP2(builder, + LLVMInt8TypeInContext(bld->gallivm->context), + bld->base_ptr, &mip_offset, 1, ""); return data_ptr; } + /** * Return (per-pixel) offsets to mip levels. * \param level integer mipmap level @@ -1163,29 +1159,32 @@ lp_build_get_mip_offsets(struct lp_build_sample_context *bld, if (bld->num_mips == 1) { offset1 = load_mip(bld->gallivm, bld->mip_offsets_type, bld->mip_offsets, level); offsets = lp_build_broadcast_scalar(&bld->int_coord_bld, offset1); - } - else if (bld->num_mips == bld->coord_bld.type.length / 4) { - unsigned i; - + } else if (bld->num_mips == bld->coord_bld.type.length / 4) { offsets = bld->int_coord_bld.undef; - for (i = 0; i < bld->num_mips; i++) { + for (unsigned i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - offset1 = load_mip(bld->gallivm, bld->mip_offsets_type, bld->mip_offsets, LLVMBuildExtractElement(builder, level, indexi, "")); + offset1 = load_mip(bld->gallivm, bld->mip_offsets_type, + bld->mip_offsets, + LLVMBuildExtractElement(builder, level, + indexi, "")); LLVMValueRef indexo = lp_build_const_int32(bld->gallivm, 4 * i); - offsets = LLVMBuildInsertElement(builder, offsets, offset1, indexo, ""); + offsets = LLVMBuildInsertElement(builder, offsets, offset1, + indexo, ""); } - offsets = lp_build_swizzle_scalar_aos(&bld->int_coord_bld, offsets, 0, 4); - } - else { - unsigned i; - + offsets = lp_build_swizzle_scalar_aos(&bld->int_coord_bld, + offsets, 0, 4); + } else { assert (bld->num_mips == bld->coord_bld.type.length); offsets = bld->int_coord_bld.undef; - for (i = 0; i < bld->num_mips; i++) { + for (unsigned i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - offset1 = load_mip(bld->gallivm, bld->mip_offsets_type, bld->mip_offsets, LLVMBuildExtractElement(builder, level, indexi, "")); - offsets = LLVMBuildInsertElement(builder, offsets, offset1, indexi, ""); + offset1 = load_mip(bld->gallivm, bld->mip_offsets_type, + bld->mip_offsets, + LLVMBuildExtractElement(builder, level, + indexi, "")); + offsets = LLVMBuildInsertElement(builder, offsets, offset1, + indexi, ""); } } return offsets; @@ -1210,16 +1209,14 @@ lp_build_minify(struct lp_build_context *bld, if (level == bld->zero) { /* if we're using mipmap level zero, no minification is needed */ return base_size; - } - else { + } else { LLVMValueRef size; assert(bld->type.sign); if (lod_scalar || (util_get_cpu_caps()->has_avx2 || !util_get_cpu_caps()->has_sse)) { size = LLVMBuildLShr(builder, base_size, level, "minify"); size = lp_build_max(bld, size, bld->one); - } - else { + } else { /* * emulate shift with float mul, since intel "forgot" shifts with * per-element shift count until avx2, which results in terrible @@ -1259,6 +1256,7 @@ lp_build_minify(struct lp_build_context *bld, } } + /* * Scale image dimensions with block sizes. * @@ -1278,14 +1276,18 @@ lp_build_scale_view_dims(struct lp_build_context *bld, LLVMValueRef size, LLVMValueRef view_blocksize) { LLVMBuilderRef builder = bld->gallivm->builder; - LLVMValueRef ret; - - ret = LLVMBuildAdd(builder, size, LLVMBuildSub(builder, tex_blocksize, lp_build_const_int_vec(bld->gallivm, bld->type, 1), ""), ""); + LLVMValueRef ret = + LLVMBuildAdd(builder, size, + LLVMBuildSub(builder, tex_blocksize, + lp_build_const_int_vec(bld->gallivm, + bld->type, 1), ""), + ""); ret = LLVMBuildLShr(builder, ret, tex_blocksize_log2, ""); ret = LLVMBuildMul(builder, ret, view_blocksize, ""); return ret; } + /* * Scale a single image dimension. * @@ -1296,18 +1298,22 @@ LLVMValueRef lp_build_scale_view_dim(struct gallivm_state *gallivm, LLVMValueRef size, unsigned tex_blocksize, unsigned view_blocksize) { - LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef ret; - if (tex_blocksize == view_blocksize) return size; - ret = LLVMBuildAdd(builder, size, lp_build_const_int32(gallivm, tex_blocksize - 1), ""); - ret = LLVMBuildLShr(builder, ret, lp_build_const_int32(gallivm, util_logbase2(tex_blocksize)), ""); - ret = LLVMBuildMul(builder, ret, lp_build_const_int32(gallivm, view_blocksize), ""); + LLVMBuilderRef builder = gallivm->builder; + LLVMValueRef ret = + LLVMBuildAdd(builder, size, + lp_build_const_int32(gallivm, tex_blocksize - 1), ""); + ret = LLVMBuildLShr(builder, ret, + lp_build_const_int32(gallivm, + util_logbase2(tex_blocksize)), ""); + ret = LLVMBuildMul(builder, ret, + lp_build_const_int32(gallivm, view_blocksize), ""); return ret; } + /** * Dereference stride_array[mipmap_level] array to get a stride. * Return stride as a vector. @@ -1319,33 +1325,34 @@ lp_build_get_level_stride_vec(struct lp_build_sample_context *bld, { LLVMBuilderRef builder = bld->gallivm->builder; LLVMValueRef stride, stride1; + if (bld->num_mips == 1) { stride1 = load_mip(bld->gallivm, stride_type, stride_array, level); stride = lp_build_broadcast_scalar(&bld->int_coord_bld, stride1); - } - else if (bld->num_mips == bld->coord_bld.type.length / 4) { + } else if (bld->num_mips == bld->coord_bld.type.length / 4) { LLVMValueRef stride1; - unsigned i; stride = bld->int_coord_bld.undef; - for (i = 0; i < bld->num_mips; i++) { + for (unsigned i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - stride1 = load_mip(bld->gallivm, stride_type, stride_array, LLVMBuildExtractElement(builder, level, indexi, "")); + stride1 = load_mip(bld->gallivm, stride_type, stride_array, + LLVMBuildExtractElement(builder, level, + indexi, "")); LLVMValueRef indexo = lp_build_const_int32(bld->gallivm, 4 * i); stride = LLVMBuildInsertElement(builder, stride, stride1, indexo, ""); } stride = lp_build_swizzle_scalar_aos(&bld->int_coord_bld, stride, 0, 4); - } - else { + } else { LLVMValueRef stride1; - unsigned i; assert (bld->num_mips == bld->coord_bld.type.length); stride = bld->int_coord_bld.undef; - for (i = 0; i < bld->coord_bld.type.length; i++) { + for (unsigned i = 0; i < bld->coord_bld.type.length; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - stride1 = load_mip(bld->gallivm, stride_type, stride_array, LLVMBuildExtractElement(builder, level, indexi, "")); + stride1 = load_mip(bld->gallivm, stride_type, stride_array, + LLVMBuildExtractElement(builder, level, + indexi, "")); stride = LLVMBuildInsertElement(builder, stride, stride1, indexi, ""); } } @@ -1373,19 +1380,18 @@ lp_build_mipmap_level_sizes(struct lp_build_sample_context *bld, */ if (bld->num_mips == 1) { ilevel_vec = lp_build_broadcast_scalar(&bld->int_size_bld, ilevel); - *out_size = lp_build_minify(&bld->int_size_bld, bld->int_size, ilevel_vec, TRUE); + *out_size = lp_build_minify(&bld->int_size_bld, bld->int_size, + ilevel_vec, TRUE); *out_size = lp_build_scale_view_dims(&bld->int_size_bld, *out_size, bld->int_tex_blocksize, bld->int_tex_blocksize_log2, bld->int_view_blocksize); - } - else { + } else { LLVMValueRef int_size_vec; LLVMValueRef int_tex_blocksize_vec, int_tex_blocksize_log2_vec; LLVMValueRef int_view_blocksize_vec; LLVMValueRef tmp[LP_MAX_VECTOR_LENGTH]; - unsigned num_quads = bld->coord_bld.type.length / 4; - unsigned i; + const unsigned num_quads = bld->coord_bld.type.length / 4; if (bld->num_mips == num_quads) { /* @@ -1408,14 +1414,13 @@ lp_build_mipmap_level_sizes(struct lp_build_sample_context *bld, assert(bld->int_size_in_bld.type.length == 1); int_size_vec = lp_build_broadcast_scalar(&bld4, bld->int_size); - int_tex_blocksize_vec = lp_build_broadcast_scalar(&bld4, - bld->int_tex_blocksize); - int_tex_blocksize_log2_vec = lp_build_broadcast_scalar(&bld4, - bld->int_tex_blocksize_log2); - int_view_blocksize_vec = lp_build_broadcast_scalar(&bld4, - bld->int_view_blocksize); - } - else { + int_tex_blocksize_vec = + lp_build_broadcast_scalar(&bld4, bld->int_tex_blocksize); + int_tex_blocksize_log2_vec = + lp_build_broadcast_scalar(&bld4, bld->int_tex_blocksize_log2); + int_view_blocksize_vec = + lp_build_broadcast_scalar(&bld4, bld->int_view_blocksize); + } else { assert(bld->int_size_in_bld.type.length == 4); int_size_vec = bld->int_size; int_tex_blocksize_vec = bld->int_tex_blocksize; @@ -1423,7 +1428,7 @@ lp_build_mipmap_level_sizes(struct lp_build_sample_context *bld, int_view_blocksize_vec = bld->int_view_blocksize; } - for (i = 0; i < num_quads; i++) { + for (unsigned i = 0; i < num_quads; i++) { LLVMValueRef ileveli; LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); @@ -1439,51 +1444,59 @@ lp_build_mipmap_level_sizes(struct lp_build_sample_context *bld, int_view_blocksize_vec); } /* - * out_size is [w0, h0, d0, _, w1, h1, d1, _, ...] vector for dims > 1, - * [w0, w0, w0, w0, w1, w1, w1, w1, ...] otherwise. + * out_size is [w0, h0, d0, _, w1, h1, d1, _, ...] vector for + * dims > 1, [w0, w0, w0, w0, w1, w1, w1, w1, ...] otherwise. */ *out_size = lp_build_concat(bld->gallivm, tmp, bld4.type, num_quads); - } - else { - /* FIXME: this is terrible and results in _huge_ vector - * (for the dims > 1 case). - * Should refactor this (together with extract_image_sizes) and do - * something more useful. Could for instance if we have width,height - * with 4-wide vector pack all elements into a 8xi16 vector - * (on which we can still do useful math) instead of using a 16xi32 - * vector. - * For dims == 1 this will create [w0, w1, w2, w3, ...] vector. - * For dims > 1 this will create [w0, h0, d0, _, w1, h1, d1, _, ...] vector. - */ + } else { + /* FIXME: this is terrible and results in _huge_ vector + * (for the dims > 1 case). + * Should refactor this (together with extract_image_sizes) and do + * something more useful. Could for instance if we have width,height + * with 4-wide vector pack all elements into a 8xi16 vector + * (on which we can still do useful math) instead of using a 16xi32 + * vector. + * For dims == 1 this will create [w0, w1, w2, w3, ...] vector. + * For dims > 1 this will create [w0, h0, d0, _, w1, h1, d1, _, ...] + * vector. + */ assert(bld->num_mips == bld->coord_bld.type.length); if (bld->dims == 1) { assert(bld->int_size_in_bld.type.length == 1); int_size_vec = lp_build_broadcast_scalar(&bld->int_coord_bld, bld->int_size); - int_tex_blocksize_vec = lp_build_broadcast_scalar(&bld->int_coord_bld, - bld->int_tex_blocksize); - int_tex_blocksize_log2_vec = lp_build_broadcast_scalar(&bld->int_coord_bld, - bld->int_tex_blocksize_log2); - int_view_blocksize_vec = lp_build_broadcast_scalar(&bld->int_coord_bld, - bld->int_view_blocksize); - *out_size = lp_build_minify(&bld->int_coord_bld, int_size_vec, ilevel, FALSE); - *out_size = lp_build_scale_view_dims(&bld->int_coord_bld, *out_size, + int_tex_blocksize_vec = + lp_build_broadcast_scalar(&bld->int_coord_bld, + bld->int_tex_blocksize); + int_tex_blocksize_log2_vec = + lp_build_broadcast_scalar(&bld->int_coord_bld, + bld->int_tex_blocksize_log2); + int_view_blocksize_vec = + lp_build_broadcast_scalar(&bld->int_coord_bld, + bld->int_view_blocksize); + *out_size = lp_build_minify(&bld->int_coord_bld, int_size_vec, + ilevel, FALSE); + *out_size = lp_build_scale_view_dims(&bld->int_coord_bld, + *out_size, int_tex_blocksize_vec, int_tex_blocksize_log2_vec, int_view_blocksize_vec); - } - else { + } else { LLVMValueRef ilevel1; - for (i = 0; i < bld->num_mips; i++) { + for (unsigned i = 0; i < bld->num_mips; i++) { LLVMValueRef indexi = lp_build_const_int32(bld->gallivm, i); - ilevel1 = lp_build_extract_broadcast(bld->gallivm, bld->int_coord_type, - bld->int_size_in_bld.type, ilevel, indexi); + ilevel1 = lp_build_extract_broadcast(bld->gallivm, + bld->int_coord_type, + bld->int_size_in_bld.type, + ilevel, indexi); tmp[i] = bld->int_size; - tmp[i] = lp_build_minify(&bld->int_size_in_bld, tmp[i], ilevel1, TRUE); - tmp[i] = lp_build_scale_view_dims(&bld->int_size_in_bld, tmp[i], + tmp[i] = lp_build_minify(&bld->int_size_in_bld, tmp[i], + ilevel1, TRUE); + tmp[i] = lp_build_scale_view_dims(&bld->int_size_in_bld, + tmp[i], bld->int_tex_blocksize, bld->int_tex_blocksize_log2, bld->int_view_blocksize); @@ -1552,14 +1565,12 @@ lp_build_extract_image_sizes(struct lp_build_sample_context *bld, LLVMConstInt(i32t, 2, 0)); } } - } - else { + } else { unsigned num_quads = bld->coord_bld.type.length / 4; if (dims == 1) { *out_width = size; - } - else if (bld->num_mips == num_quads) { + } else if (bld->num_mips == num_quads) { *out_width = lp_build_swizzle_scalar_aos(size_bld, size, 0, 4); if (dims >= 2) { *out_height = lp_build_swizzle_scalar_aos(size_bld, size, 1, 4); @@ -1567,8 +1578,7 @@ lp_build_extract_image_sizes(struct lp_build_sample_context *bld, *out_depth = lp_build_swizzle_scalar_aos(size_bld, size, 2, 4); } } - } - else { + } else { assert(bld->num_mips == bld->coord_type.length); *out_width = lp_build_pack_aos_scalars(bld->gallivm, size_type, coord_type, size, 0); @@ -1620,6 +1630,7 @@ lp_build_unnormalized_coords(struct lp_build_sample_context *bld, } } + /** * Generate new coords and faces for cubemap texels falling off the face. * @@ -1785,8 +1796,7 @@ lp_build_select3(struct lp_build_context *sel_bld, LLVMValueRef val1, LLVMValueRef val2) { - LLVMValueRef tmp; - tmp = lp_build_select(sel_bld, sel0, val0, val1); + LLVMValueRef tmp = lp_build_select(sel_bld, sel0, val0, val1); return lp_build_select(sel_bld, sel1, val2, tmp); } @@ -1874,8 +1884,8 @@ lp_build_cube_lookup(struct lp_build_sample_context *bld, LLVMValueRef sdynewx, sdynewy, sdynewz, tdynewx, tdynewy, tdynewz; LLVMValueRef face_sdx, face_tdx, face_sdy, face_tdy; /* - * s = 1/2 * ( sc / ma + 1) - * t = 1/2 * ( tc / ma + 1) + * s = 1/2 * (sc / ma + 1) + * t = 1/2 * (tc / ma + 1) * * s' = 1/2 * (sc' * ma - sc * ma') / ma^2 * t' = 1/2 * (tc' * ma - tc * ma') / ma^2 @@ -1901,8 +1911,7 @@ lp_build_cube_lookup(struct lp_build_sample_context *bld, ddy[0] = lp_build_ddy(coord_bld, s); ddy[1] = lp_build_ddy(coord_bld, t); ddy[2] = lp_build_ddy(coord_bld, r); - } - else { + } else { ddx[0] = derivs_in->ddx[0]; ddx[1] = derivs_in->ddx[1]; ddx[2] = derivs_in->ddx[2]; @@ -2095,8 +2104,7 @@ lp_build_sample_partial_offset(struct lp_build_context *bld, if (block_length == 1) { subcoord = bld->zero; - } - else { + } else { /* * Pixel blocks have power of two dimensions. LLVM should convert the * rem/div to bit arithmetic. @@ -2165,8 +2173,7 @@ lp_build_sample_offset(struct lp_build_context *bld, y, y_stride, &y_offset, out_j); offset = lp_build_add(bld, offset, y_offset); - } - else { + } else { *out_j = bld->zero; } @@ -2183,6 +2190,7 @@ lp_build_sample_offset(struct lp_build_context *bld, *out_offset = offset; } + static LLVMValueRef lp_build_sample_min(struct lp_build_context *bld, LLVMValueRef x, @@ -2200,6 +2208,7 @@ lp_build_sample_min(struct lp_build_context *bld, return lp_build_select(bld, mask, min, v0); } + static LLVMValueRef lp_build_sample_max(struct lp_build_context *bld, LLVMValueRef x, @@ -2217,6 +2226,7 @@ lp_build_sample_max(struct lp_build_context *bld, return lp_build_select(bld, mask, max, v0); } + static LLVMValueRef lp_build_sample_min_2d(struct lp_build_context *bld, LLVMValueRef x, @@ -2231,6 +2241,7 @@ lp_build_sample_min_2d(struct lp_build_context *bld, return lp_build_sample_min(bld, y, v0, v1); } + static LLVMValueRef lp_build_sample_max_2d(struct lp_build_context *bld, LLVMValueRef x, @@ -2245,6 +2256,7 @@ lp_build_sample_max_2d(struct lp_build_context *bld, return lp_build_sample_max(bld, y, v0, v1); } + static LLVMValueRef lp_build_sample_min_3d(struct lp_build_context *bld, LLVMValueRef x, @@ -2260,6 +2272,7 @@ lp_build_sample_min_3d(struct lp_build_context *bld, return lp_build_sample_min(bld, z, v0, v1); } + static LLVMValueRef lp_build_sample_max_3d(struct lp_build_context *bld, LLVMValueRef x, @@ -2275,6 +2288,7 @@ lp_build_sample_max_3d(struct lp_build_context *bld, return lp_build_sample_max(bld, z, v0, v1); } + void lp_build_reduce_filter(struct lp_build_context *bld, enum pipe_tex_reduction_mode mode, @@ -2303,6 +2317,7 @@ lp_build_reduce_filter(struct lp_build_context *bld, } } + void lp_build_reduce_filter_2d(struct lp_build_context *bld, enum pipe_tex_reduction_mode mode, @@ -2316,24 +2331,27 @@ lp_build_reduce_filter_2d(struct lp_build_context *bld, LLVMValueRef *v11, LLVMValueRef *out) { - unsigned chan; switch (mode) { case PIPE_TEX_REDUCTION_MIN: - for (chan = 0; chan < num_chan; chan++) - out[chan] = lp_build_sample_min_2d(bld, x, y, v00[chan], v01[chan], v10[chan], v11[chan]); + for (unsigned chan = 0; chan < num_chan; chan++) + out[chan] = lp_build_sample_min_2d(bld, x, y, v00[chan], v01[chan], + v10[chan], v11[chan]); break; case PIPE_TEX_REDUCTION_MAX: - for (chan = 0; chan < num_chan; chan++) - out[chan] = lp_build_sample_max_2d(bld, x, y, v00[chan], v01[chan], v10[chan], v11[chan]); + for (unsigned chan = 0; chan < num_chan; chan++) + out[chan] = lp_build_sample_max_2d(bld, x, y, v00[chan], v01[chan], + v10[chan], v11[chan]); break; case PIPE_TEX_REDUCTION_WEIGHTED_AVERAGE: default: - for (chan = 0; chan < num_chan; chan++) - out[chan] = lp_build_lerp_2d(bld, x, y, v00[chan], v01[chan], v10[chan], v11[chan], flags); + for (unsigned chan = 0; chan < num_chan; chan++) + out[chan] = lp_build_lerp_2d(bld, x, y, v00[chan], v01[chan], + v10[chan], v11[chan], flags); break; } } + void lp_build_reduce_filter_3d(struct lp_build_context *bld, enum pipe_tex_reduction_mode mode, @@ -2352,23 +2370,22 @@ lp_build_reduce_filter_3d(struct lp_build_context *bld, LLVMValueRef *v111, LLVMValueRef *out) { - unsigned chan; switch (mode) { case PIPE_TEX_REDUCTION_MIN: - for (chan = 0; chan < num_chan; chan++) + for (unsigned chan = 0; chan < num_chan; chan++) out[chan] = lp_build_sample_min_3d(bld, x, y, z, v000[chan], v001[chan], v010[chan], v011[chan], v100[chan], v101[chan], v110[chan], v111[chan]); break; case PIPE_TEX_REDUCTION_MAX: - for (chan = 0; chan < num_chan; chan++) + for (unsigned chan = 0; chan < num_chan; chan++) out[chan] = lp_build_sample_max_3d(bld, x, y, z, v000[chan], v001[chan], v010[chan], v011[chan], v100[chan], v101[chan], v110[chan], v111[chan]); break; case PIPE_TEX_REDUCTION_WEIGHTED_AVERAGE: default: - for (chan = 0; chan < num_chan; chan++) + for (unsigned chan = 0; chan < num_chan; chan++) out[chan] = lp_build_lerp_3d(bld, x, y, z, v000[chan], v001[chan], v010[chan], v011[chan], v100[chan], v101[chan], v110[chan], v111[chan], @@ -2377,6 +2394,7 @@ lp_build_reduce_filter_3d(struct lp_build_context *bld, } } + /* * generated from * const float alpha = 2; @@ -2515,6 +2533,7 @@ static const float aniso_filter_table[1024] = { 0.137200, 0.136932, 0.136665, 0.136398, 0.136131, 0.135865, 0.135600, 0.135335, }; + const float * lp_build_sample_aniso_filter_table(void) { -- 2.7.4