OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

nir: use more nir_fmul_imm

Browse Source 
This simplifies things a bit. Note that in some cases, the arguments are
swapped, because multiplications are commutative, and nir_fmul_imm only
allows the second operand to be an immediate.

Reviewed-by: Faith Ekstrand <faith.ekstrand@collabora.com>
Reviewed-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/23179>
This commit is contained in:
Erik Faye-Lund
2023-05-06 08:49:32 +02:00
committed by Marge Bot
parent ea2eade57b
commit 20d619cd84
18 changed files with 43 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/amd/vulkan/meta/radv_meta_resolve_cs.c
View File

@@ -41,13 +41,13 @@ radv_meta_build_resolve_srgb_conversion(nir_builder *b, nir_ssa_def *input)
nir_ssa_def *ltvals[3];
for (i = 0; i < 3; i++)
ltvals[i] = nir_fmul(b, nir_channel(b, input, i), nir_imm_float(b, 12.92));
ltvals[i] = nir_fmul_imm(b, nir_channel(b, input, i), 12.92);
nir_ssa_def *gtvals[3];
for (i = 0; i < 3; i++) {
gtvals[i] = nir_fpow(b, nir_channel(b, input, i), nir_imm_float(b, 1.0 / 2.4));
gtvals[i] = nir_fmul(b, gtvals[i], nir_imm_float(b, 1.055));
gtvals[i] = nir_fmul_imm(b, gtvals[i], 1.055);
gtvals[i] = nir_fsub(b, gtvals[i], nir_imm_float(b, 0.055));
}

6
src/broadcom/compiler/v3d_nir_lower_line_smooth.c
View File

@@ -116,9 +116,9 @@ initialise_coverage_var(struct lower_line_smooth_state *state,
nir_fmul(&b,
nir_imm_float(&b, 1.0f / M_SQRT2),
nir_fsub(&b, pixels_from_center,
nir_fmul(&b,
line_width,
nir_imm_float(&b, 0.5f)))));
nir_fmul_imm(&b,
line_width,
0.5f))));
/* Discard fragments that aren’t covered at all by the line */
nir_ssa_def *outside = nir_fge(&b, nir_imm_float(&b, 0.0f), coverage);

2
src/broadcom/vulkan/v3dv_meta_copy.c
View File

@@ -3436,7 +3436,7 @@ build_nir_tex_op_ms_resolve(struct nir_builder *b,
}
assert(!is_int);
return nir_fmul(b, tmp, nir_imm_float(b, 1.0f / src_samples));
return nir_fmul_imm(b, tmp, 1.0f / src_samples);
}
/* Fetches the current sample (gl_SampleID) at the given position */

2
src/compiler/nir/nir_builtin_builder.c
View File

@@ -84,7 +84,7 @@ nir_nextafter(nir_builder *b, nir_ssa_def *x, nir_ssa_def *y)
}
/* Flush denorm to zero to avoid returning a denorm when condeq is true. */
x = nir_fmul(b, x, nir_imm_floatN_t(b, 1.0, x->bit_size));
x = nir_fmul_imm(b, x, 1.0);
}
/* beware of: +/-0.0 - 1 == NaN */

10
src/compiler/nir/nir_format_convert.h
View File

@@ -301,10 +301,10 @@ nir_format_float_to_half(nir_builder *b, nir_ssa_def *f)
static inline nir_ssa_def *
nir_format_linear_to_srgb(nir_builder *b, nir_ssa_def *c)
{
nir_ssa_def *linear = nir_fmul(b, c, nir_imm_float(b, 12.92f));
nir_ssa_def *linear = nir_fmul_imm(b, c, 12.92f);
nir_ssa_def *curved =
nir_fsub(b, nir_fmul(b, nir_imm_float(b, 1.055f),
nir_fpow(b, c, nir_imm_float(b, 1.0 / 2.4))),
nir_fsub(b, nir_fmul_imm(b, nir_fpow(b, c, nir_imm_float(b, 1.0 / 2.4)),
1.055f),
nir_imm_float(b, 0.055f));
return nir_fsat(b, nir_bcsel(b, nir_flt(b, c, nir_imm_float(b, 0.0031308f)),
@@ -316,8 +316,8 @@ nir_format_srgb_to_linear(nir_builder *b, nir_ssa_def *c)
{
nir_ssa_def *linear = nir_fdiv(b, c, nir_imm_float(b, 12.92f));
nir_ssa_def *curved =
nir_fpow(b, nir_fdiv(b, nir_fadd(b, c, nir_imm_float(b, 0.055f)),
nir_imm_float(b, 1.055f)),
nir_fpow(b, nir_fmul_imm(b, nir_fadd_imm(b, c, 0.055f),
1.0 / 1.055f),
nir_imm_float(b, 2.4f));
return nir_fsat(b, nir_bcsel(b, nir_fge(b, nir_imm_float(b, 0.04045f), c),

9
src/gallium/drivers/r600/sfn/sfn_nir_lower_tex.cpp
View File

@@ -43,14 +43,14 @@ lower_coord_shift_normalized(nir_builder *b, nir_tex_instr *tex)
if (unlikely(tex->array_is_lowered_cube)) {
auto corr2 = nir_fadd(b,
nir_channels(b, tex->src[coord_index].src.ssa, 3),
nir_fmul(b, nir_imm_float(b, -0.5f), scale));
nir_fmul_imm(b, scale, -0.5f));
corr = nir_vec3(b,
nir_channel(b, corr2, 0),
nir_channel(b, corr2, 1),
nir_channel(b, tex->src[coord_index].src.ssa, 2));
} else {
corr = nir_fadd(b,
nir_fmul(b, nir_imm_float(b, -0.5f), scale),
nir_fmul_imm(b, scale, -0.5f),
tex->src[coord_index].src.ssa);
}
@@ -282,19 +282,18 @@ r600_nir_lower_cube_to_2darray_impl(nir_builder *b, nir_instr *instr, void *_opt
if (tex->op == nir_texop_txd) {
int ddx_idx = nir_tex_instr_src_index(tex, nir_tex_src_ddx);
auto zero_dot_5 = nir_imm_float(b, 0.5);
nir_instr_rewrite_src(
&tex->instr,
&tex->src[ddx_idx].src,
nir_src_for_ssa(
nir_fmul(b, nir_ssa_for_src(b, tex->src[ddx_idx].src, 3), zero_dot_5)));
nir_fmul_imm(b, nir_ssa_for_src(b, tex->src[ddx_idx].src, 3), 0.5)));
int ddy_idx = nir_tex_instr_src_index(tex, nir_tex_src_ddy);
nir_instr_rewrite_src(
&tex->instr,
&tex->src[ddy_idx].src,
nir_src_for_ssa(
nir_fmul(b, nir_ssa_for_src(b, tex->src[ddy_idx].src, 3), zero_dot_5)));
nir_fmul_imm(b, nir_ssa_for_src(b, tex->src[ddy_idx].src, 3), 0.5)));
}
auto new_coord = nir_vec3(b, nir_channel(b, xy, 0), nir_channel(b, xy, 1), z);

4
src/gallium/drivers/radeonsi/si_shaderlib_nir.c
View File

@@ -291,13 +291,13 @@ static nir_ssa_def *convert_linear_to_srgb(nir_builder *b, nir_ssa_def *input)
nir_ssa_def *ltvals[3];
for (unsigned i = 0; i < 3; i++)
ltvals[i] = nir_fmul(b, nir_channel(b, input, i), nir_imm_float(b, 12.92));
ltvals[i] = nir_fmul_imm(b, nir_channel(b, input, i), 12.92);
nir_ssa_def *gtvals[3];
for (unsigned i = 0; i < 3; i++) {
gtvals[i] = nir_fpow(b, nir_channel(b, input, i), nir_imm_float(b, 1.0/2.4));
gtvals[i] = nir_fmul(b, gtvals[i], nir_imm_float(b, 1.055));
gtvals[i] = nir_fmul_imm(b, gtvals[i], 1.055);
gtvals[i] = nir_fsub(b, gtvals[i], nir_imm_float(b, 0.055));
}

19
src/gallium/drivers/vc4/vc4_nir_lower_io.c
View File

@@ -106,10 +106,9 @@ vc4_nir_get_vattr_channel_vpm(struct vc4_compile *c,
return vc4_nir_get_swizzled_channel(b, vpm_reads, swiz);
} else if (chan->size == 32 && chan->type == UTIL_FORMAT_TYPE_SIGNED) {
if (chan->normalized) {
return nir_fmul(b,
nir_i2f32(b, vpm_reads[swiz]),
nir_imm_float(b,
1.0 / 0x7fffffff));
return nir_fmul_imm(b,
nir_i2f32(b, vpm_reads[swiz]),
1.0 / 0x7fffffff);
} else {
return nir_i2f32(b, vpm_reads[swiz]);
}
@@ -120,9 +119,9 @@ vc4_nir_get_vattr_channel_vpm(struct vc4_compile *c,
if (chan->type == UTIL_FORMAT_TYPE_SIGNED) {
temp = nir_ixor(b, vpm, nir_imm_int(b, 0x80808080));
if (chan->normalized) {
return nir_fsub(b, nir_fmul(b,
vc4_nir_unpack_8f(b, temp, swiz),
nir_imm_float(b, 2.0)),
return nir_fsub(b, nir_fmul_imm(b,
vc4_nir_unpack_8f(b, temp, swiz),
2.0),
nir_imm_float(b, 1.0));
} else {
return nir_fadd(b,
@@ -149,16 +148,14 @@ vc4_nir_get_vattr_channel_vpm(struct vc4_compile *c,
if (chan->type == UTIL_FORMAT_TYPE_SIGNED) {
temp = nir_i2f32(b, vc4_nir_unpack_16i(b, vpm, swiz & 1));
if (chan->normalized) {
return nir_fmul(b, temp,
nir_imm_float(b, 1/32768.0f));
return nir_fmul_imm(b, temp, 1 / 32768.0f);
} else {
return temp;
}
} else {
temp = nir_i2f32(b, vc4_nir_unpack_16u(b, vpm, swiz & 1));
if (chan->normalized) {
return nir_fmul(b, temp,
nir_imm_float(b, 1 / 65535.0));
return nir_fmul_imm(b, temp, 1 / 65535.0);
} else {
return temp;
}

4
src/gallium/drivers/zink/zink_compiler.c
View File

@@ -340,13 +340,13 @@ lower_gl_point_gs_instr(nir_builder *b, nir_instr *instr, void *data)
nir_ssa_def *w_delta = nir_fdiv(b, point_size, nir_channel(b, vp_scale, 0));
w_delta = nir_fmul(b, w_delta, nir_channel(b, point_pos, 3));
// halt_w_delta = w_delta / 2
nir_ssa_def *half_w_delta = nir_fmul(b, w_delta, nir_imm_float(b, 0.5));
nir_ssa_def *half_w_delta = nir_fmul_imm(b, w_delta, 0.5);
// h_delta = gl_point_size / height_viewport_size_scale * gl_Position.w
nir_ssa_def *h_delta = nir_fdiv(b, point_size, nir_channel(b, vp_scale, 1));
h_delta = nir_fmul(b, h_delta, nir_channel(b, point_pos, 3));
// halt_h_delta = h_delta / 2
nir_ssa_def *half_h_delta = nir_fmul(b, h_delta, nir_imm_float(b, 0.5));
nir_ssa_def *half_h_delta = nir_fmul_imm(b, h_delta, 0.5);
nir_ssa_def *point_dir[4][2] = {
{ nir_imm_float(b, -1), nir_imm_float(b, -1) },

2
src/gallium/drivers/zink/zink_lower_cubemap_to_array.c
View File

@@ -353,7 +353,7 @@ lower_cube_coords(nir_builder *b, nir_ssa_def *coord, bool is_array)
coords.arz = nir_fabs(b, coords.rz);
coords.array = NULL;
if (is_array)
coords.array = nir_fmul(b, nir_channel(b, coord, 3), nir_imm_float(b, 6.0f));
coords.array = nir_fmul_imm(b, nir_channel(b, coord, 3), 6.0f);
nir_ssa_def *use_face_x = nir_iand(b,
nir_fge(b, coords.arx, coords.ary),

6
src/intel/blorp/blorp_blit.c
View File

@@ -704,8 +704,8 @@ blorp_nir_combine_samples(nir_builder *b, struct brw_blorp_blit_vars *v,
if (filter == BLORP_FILTER_AVERAGE) {
assert(dst_type == nir_type_float);
texture_data[0] = nir_fmul(b, texture_data[0],
nir_imm_float(b, 1.0 / tex_samples));
texture_data[0] = nir_fmul_imm(b, texture_data[0],
1.0 / tex_samples);
}
nir_store_var(b, color, texture_data[0], 0xf);
@@ -1005,7 +1005,7 @@ convert_color(struct nir_builder *b, nir_ssa_def *color,
*/
unsigned factor = (1 << 24) - 1;
value = nir_fsat(b, nir_channel(b, color, 0));
value = nir_f2i32(b, nir_fmul(b, value, nir_imm_float(b, factor)));
value = nir_f2i32(b, nir_fmul_imm(b, value, factor));
} else if (key->dst_format == ISL_FORMAT_L8_UNORM_SRGB) {
value = nir_format_linear_to_srgb(b, nir_channel(b, color, 0));
} else if (key->dst_format == ISL_FORMAT_R8G8B8_UNORM_SRGB) {

3
src/intel/compiler/brw_nir.c
View File

@@ -504,8 +504,7 @@ lower_barycentric_at_offset(nir_builder *b, nir_instr *instr, void *data)
assert(intrin->src[0].ssa);
nir_ssa_def *offset =
nir_imin(b, nir_imm_int(b, 7),
nir_f2i32(b, nir_fmul(b, nir_imm_float(b, 16),
intrin->src[0].ssa)));
nir_f2i32(b, nir_fmul_imm(b, intrin->src[0].ssa, 16)));
nir_instr_rewrite_src(instr, &intrin->src[0], nir_src_for_ssa(offset));

2
src/intel/compiler/brw_nir_attribute_workarounds.c
View File

@@ -55,7 +55,7 @@ apply_attr_wa_instr(nir_builder *b, nir_instr *instr, void *cb_data)
*/
if (wa_flags & BRW_ATTRIB_WA_COMPONENT_MASK) {
nir_ssa_def *scaled =
nir_fmul(b, val, nir_imm_float(b, 1.0f / 65536.0f));
nir_fmul_imm(b, val, 1.0f / 65536.0f);
nir_ssa_def *comps[4];
for (int i = 0; i < val->num_components; i++) {
bool rescale = i < (wa_flags & BRW_ATTRIB_WA_COMPONENT_MASK);

2
src/microsoft/compiler/dxil_nir_lower_int_cubemaps.c
View File

@@ -365,7 +365,7 @@ lower_cube_coords(nir_builder *b, nir_ssa_def *coord, bool is_array, bool is_ima
coords.arz = nir_fabs(b, coords.rz);
coords.array = NULL;
if (is_array)
coords.array = nir_fmul(b, nir_channel(b, coord, 3), nir_imm_float(b, 6.0f));
coords.array = nir_fmul_imm(b, nir_channel(b, coord, 3), 6.0f);
nir_ssa_def *use_face_x = nir_iand(b,
nir_fge(b, coords.arx, coords.ary),

6
src/microsoft/compiler/dxil_nir_lower_int_samplers.c
View File

@@ -154,7 +154,7 @@ static void
wrap_mirror_repeat(nir_builder *b, wrap_result_t *wrap_params, nir_ssa_def *size)
{
/* (size − 1) − mirror(mod(coord, 2 * size) − size) */
nir_ssa_def *coord_mod2size = nir_fmod(b, wrap_params->coords, nir_fmul(b, nir_imm_float(b, 2.0f), size));
nir_ssa_def *coord_mod2size = nir_fmod(b, wrap_params->coords, nir_fmul_imm(b, size, 2.0f));
nir_instr_as_alu(coord_mod2size->parent_instr)->exact = true;
nir_ssa_def *a = nir_fsub(b, coord_mod2size, size);
wrap_params->coords = nir_fsub(b, nir_fsub(b, size, nir_imm_float(b, 1.0f)), mirror(b, a));
@@ -180,8 +180,8 @@ static void
wrap_mirror_clamp(nir_builder *b, wrap_result_t *wrap_params, nir_ssa_def *size)
{
/* We have to take care of the boundaries */
nir_ssa_def *is_low = nir_flt(b, wrap_params->coords, nir_fmul(b, size, nir_imm_float(b, -1.0)));
nir_ssa_def *is_high = nir_flt(b, nir_fmul(b, size, nir_imm_float(b, 2.0)), wrap_params->coords);
nir_ssa_def *is_low = nir_flt(b, wrap_params->coords, nir_fmul_imm(b, size, -1.0));
nir_ssa_def *is_high = nir_flt(b, nir_fmul_imm(b, size, 2.0), wrap_params->coords);
wrap_params->use_border_color = nir_ior(b, is_low, is_high);
/* Within the boundaries this acts like mirror_repeat */

6
src/microsoft/vulkan/dzn_nir.c
View File

@@ -723,10 +723,8 @@ dzn_nir_blit_fs(const struct dzn_nir_blit_info *info)
res = res ? nir_build_alu2(&b, resolve_op, res, &tex->dest.ssa) : &tex->dest.ssa;
}
if (resolve_mode == dzn_blit_resolve_average) {
unsigned type_sz = nir_alu_type_get_type_size(nir_out_type);
res = nir_fmul(&b, res, nir_imm_floatN_t(&b, 1.0f / nsamples, type_sz));
}
if (resolve_mode == dzn_blit_resolve_average)
res = nir_fmul_imm(&b, res, 1.0f / nsamples);
} else {
nir_tex_instr *tex =
nir_tex_instr_create(b.shader, ms ? 4 : 3);

8
src/panfrost/lib/pan_blitter.c
View File

@@ -564,12 +564,8 @@ pan_blitter_get_blit_shader(struct panfrost_device *dev,
res = res ? nir_fadd(&b, res, &tex->dest.ssa) : &tex->dest.ssa;
}
if (base_type == nir_type_float) {
unsigned type_sz =
nir_alu_type_get_type_size(key->surfaces[i].type);
res = nir_fmul(&b, res,
nir_imm_floatN_t(&b, 1.0f / nsamples, type_sz));
}
if (base_type == nir_type_float)
res = nir_fmul_imm(&b, res, 1.0f / nsamples);
} else {
nir_tex_instr *tex = nir_tex_instr_create(b.shader, ms ? 3 : 1);

2
src/panfrost/vulkan/panvk_vX_meta_copy.c
View File

@@ -920,7 +920,7 @@ panvk_meta_copy_buf2img_shader(struct panfrost_device *pdev,
/* Blendable formats are unorm and the fixed-function blend unit
* takes float values.
*/
texel = nir_fmul(&b, nir_u2f32(&b, texel), nir_imm_float(&b, 1.0f / 255));
texel = nir_fmul_imm(&b, nir_u2f32(&b, texel), 1.0f / 255);
basetype = GLSL_TYPE_FLOAT;
} else {
texel = nir_u2uN(&b, texel, imgcompsz * 8);