diff --git a/src/amd/vulkan/meta/radv_meta_resolve_cs.c b/src/amd/vulkan/meta/radv_meta_resolve_cs.c
index 744486f0f09..f95419db311 100644
--- a/src/amd/vulkan/meta/radv_meta_resolve_cs.c
+++ b/src/amd/vulkan/meta/radv_meta_resolve_cs.c
@@ -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));
    }
 
diff --git a/src/broadcom/compiler/v3d_nir_lower_line_smooth.c b/src/broadcom/compiler/v3d_nir_lower_line_smooth.c
index b8d71b4c5e7..123a899fe4d 100644
--- a/src/broadcom/compiler/v3d_nir_lower_line_smooth.c
+++ b/src/broadcom/compiler/v3d_nir_lower_line_smooth.c
@@ -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);
diff --git a/src/broadcom/vulkan/v3dv_meta_copy.c b/src/broadcom/vulkan/v3dv_meta_copy.c
index 7cb30888447..34310b76762 100644
--- a/src/broadcom/vulkan/v3dv_meta_copy.c
+++ b/src/broadcom/vulkan/v3dv_meta_copy.c
@@ -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 */
diff --git a/src/compiler/nir/nir_builtin_builder.c b/src/compiler/nir/nir_builtin_builder.c
index 07fd444603c..d3ad4de027a 100644
--- a/src/compiler/nir/nir_builtin_builder.c
+++ b/src/compiler/nir/nir_builtin_builder.c
@@ -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 */
diff --git a/src/compiler/nir/nir_format_convert.h b/src/compiler/nir/nir_format_convert.h
index 11765ae07d1..77a3477c0d1 100644
--- a/src/compiler/nir/nir_format_convert.h
+++ b/src/compiler/nir/nir_format_convert.h
@@ -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),
diff --git a/src/gallium/drivers/r600/sfn/sfn_nir_lower_tex.cpp b/src/gallium/drivers/r600/sfn/sfn_nir_lower_tex.cpp
index daddf926a3d..be69457a864 100644
--- a/src/gallium/drivers/r600/sfn/sfn_nir_lower_tex.cpp
+++ b/src/gallium/drivers/r600/sfn/sfn_nir_lower_tex.cpp
@@ -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);
diff --git a/src/gallium/drivers/radeonsi/si_shaderlib_nir.c b/src/gallium/drivers/radeonsi/si_shaderlib_nir.c
index 5db414123f7..feaa94b2ca5 100644
--- a/src/gallium/drivers/radeonsi/si_shaderlib_nir.c
+++ b/src/gallium/drivers/radeonsi/si_shaderlib_nir.c
@@ -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));
    }
 
diff --git a/src/gallium/drivers/vc4/vc4_nir_lower_io.c b/src/gallium/drivers/vc4/vc4_nir_lower_io.c
index 74e1e1abbf0..d7d89b7e889 100644
--- a/src/gallium/drivers/vc4/vc4_nir_lower_io.c
+++ b/src/gallium/drivers/vc4/vc4_nir_lower_io.c
@@ -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;
                         }
diff --git a/src/gallium/drivers/zink/zink_compiler.c b/src/gallium/drivers/zink/zink_compiler.c
index 769a5b58337..11409fd4378 100644
--- a/src/gallium/drivers/zink/zink_compiler.c
+++ b/src/gallium/drivers/zink/zink_compiler.c
@@ -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) },
diff --git a/src/gallium/drivers/zink/zink_lower_cubemap_to_array.c b/src/gallium/drivers/zink/zink_lower_cubemap_to_array.c
index d897f72f357..ce05c3f56c2 100644
--- a/src/gallium/drivers/zink/zink_lower_cubemap_to_array.c
+++ b/src/gallium/drivers/zink/zink_lower_cubemap_to_array.c
@@ -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),
diff --git a/src/intel/blorp/blorp_blit.c b/src/intel/blorp/blorp_blit.c
index 85092f095b8..ebf71ce89e5 100644
--- a/src/intel/blorp/blorp_blit.c
+++ b/src/intel/blorp/blorp_blit.c
@@ -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) {
diff --git a/src/intel/compiler/brw_nir.c b/src/intel/compiler/brw_nir.c
index 436a0881d46..c266ca08261 100644
--- a/src/intel/compiler/brw_nir.c
+++ b/src/intel/compiler/brw_nir.c
@@ -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));
 
diff --git a/src/intel/compiler/brw_nir_attribute_workarounds.c b/src/intel/compiler/brw_nir_attribute_workarounds.c
index 655bd949bc9..54eed63d0c5 100644
--- a/src/intel/compiler/brw_nir_attribute_workarounds.c
+++ b/src/intel/compiler/brw_nir_attribute_workarounds.c
@@ -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);
diff --git a/src/microsoft/compiler/dxil_nir_lower_int_cubemaps.c b/src/microsoft/compiler/dxil_nir_lower_int_cubemaps.c
index 4f5a4e38000..032d58188bc 100644
--- a/src/microsoft/compiler/dxil_nir_lower_int_cubemaps.c
+++ b/src/microsoft/compiler/dxil_nir_lower_int_cubemaps.c
@@ -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),
diff --git a/src/microsoft/compiler/dxil_nir_lower_int_samplers.c b/src/microsoft/compiler/dxil_nir_lower_int_samplers.c
index ccb5a3a06d0..515fd5bf7d1 100644
--- a/src/microsoft/compiler/dxil_nir_lower_int_samplers.c
+++ b/src/microsoft/compiler/dxil_nir_lower_int_samplers.c
@@ -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 */
diff --git a/src/microsoft/vulkan/dzn_nir.c b/src/microsoft/vulkan/dzn_nir.c
index b1d8f09e022..013d22ccc1a 100644
--- a/src/microsoft/vulkan/dzn_nir.c
+++ b/src/microsoft/vulkan/dzn_nir.c
@@ -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);
diff --git a/src/panfrost/lib/pan_blitter.c b/src/panfrost/lib/pan_blitter.c
index 1efaa57346e..14b470af9c1 100644
--- a/src/panfrost/lib/pan_blitter.c
+++ b/src/panfrost/lib/pan_blitter.c
@@ -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);
 
diff --git a/src/panfrost/vulkan/panvk_vX_meta_copy.c b/src/panfrost/vulkan/panvk_vX_meta_copy.c
index 1a3a3de285d..5982bd0d572 100644
--- a/src/panfrost/vulkan/panvk_vX_meta_copy.c
+++ b/src/panfrost/vulkan/panvk_vX_meta_copy.c
@@ -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);