KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

llvmpipe: asst. clean-ups in lp_state_fs.c 

Signed-off-by: Brian Paul <brianp@vmware.com>
Acked-by: Dave Airlie <airlied@redhat.com>
Reviewed-by: Roland Scheidegger <sroland@vmware.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17064>
This commit is contained in:
Brian Paul 2022-06-09 11:59:42 -06:00 committed by Marge Bot
parent c5521d5af1
commit e20664cbc3
1 changed files with 44 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
src/gallium/drivers/llvmpipe/lp_state_fs.c
View File

@ -199,7 +199,7 @@ lp_mem_type_from_format_desc(const struct util_format_description *format_desc,
type->width = 0;
type->length = 1;
for (i = 0; i < format_desc->nr_channels; ++i) {
for (unsigned i = 0; i < format_desc->nr_channels; ++i) {
type->width += format_desc->channel[i].size;
}
} else {
@ -306,8 +306,8 @@ generate_quad_mask(struct gallivm_state *gallivm,
static int
find_output_by_semantic(const struct tgsi_shader_info *info,
unsigned semantic,
unsigned index )
enum tgsi_semantic semantic,
unsigned index)
{
for (int i = 0; i < info->num_outputs; i++)
if (info->output_semantic_name[i] == semantic &&
@ -2355,7 +2355,6 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
unsigned dst_channels;
unsigned dst_count;
unsigned src_count;
unsigned i, j;
const struct util_format_description* out_format_desc = util_format_description(out_format);
@ -2395,7 +2394,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
mask_type = lp_int32_vec4_type();
mask_type.length = fs_type.length;
for (i = num_fs; i < num_fullblock_fs; i++) {
for (unsigned i = num_fs; i < num_fullblock_fs; i++) {
fs_mask[i] = lp_build_zero(gallivm, mask_type);
}
@ -2403,7 +2402,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
if (do_branch) {
check_mask = LLVMConstNull(lp_build_int_vec_type(gallivm, mask_type));
for (i = 0; i < num_fullblock_fs; ++i) {
for (unsigned i = 0; i < num_fullblock_fs; ++i) {
check_mask = LLVMBuildOr(builder, check_mask, fs_mask[i], "");
}
@ -2423,7 +2422,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
memset(swizzle, LP_BLD_SWIZZLE_DONTCARE, TGSI_NUM_CHANNELS);
dst_channels = 0;
for (i = 0; i < TGSI_NUM_CHANNELS; ++i) {
for (unsigned i = 0; i < TGSI_NUM_CHANNELS; ++i) {
/* Ensure channel is used */
if (out_format_desc->swizzle[i] >= TGSI_NUM_CHANNELS) {
continue;
@ -2465,7 +2464,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
/* If 3 channels then pad to include alpha for 4 element transpose */
if (dst_channels == 3) {
assert (!has_alpha);
for (i = 0; i < TGSI_NUM_CHANNELS; i++) {
for (unsigned i = 0; i < TGSI_NUM_CHANNELS; i++) {
if (swizzle[i] > TGSI_NUM_CHANNELS)
swizzle[i] = 3;
}
@ -2486,7 +2485,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
/*
* Load shader output
*/
for (i = 0; i < num_fullblock_fs; ++i) {
for (unsigned i = 0; i < num_fullblock_fs; ++i) {
/* Always load alpha for use in blending */
LLVMValueRef alpha;
if (i < num_fs) {
@ -2497,7 +2496,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
}
/* Load each channel */
for (j = 0; j < dst_channels; ++j) {
for (unsigned j = 0; j < dst_channels; ++j) {
assert(swizzle[j] < 4);
if (i < num_fs) {
fs_src[i][j] = LLVMBuildLoad(builder, fs_out_color[rt][swizzle[j]][i], "");
@ -2534,7 +2533,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
}
if (dual_source_blend) {
/* same as above except different src/dst, skip masks and comments... */
for (i = 0; i < num_fullblock_fs; ++i) {
for (unsigned i = 0; i < num_fullblock_fs; ++i) {
LLVMValueRef alpha;
if (i < num_fs) {
alpha = LLVMBuildLoad(builder, fs_out_color[1][alpha_channel][i], "");
@ -2543,7 +2542,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
alpha = undef_src_val;
}
for (j = 0; j < dst_channels; ++j) {
for (unsigned j = 0; j < dst_channels; ++j) {
assert(swizzle[j] < 4);
if (i < num_fs) {
fs_src1[i][j] = LLVMBuildLoad(builder, fs_out_color[1][swizzle[j]][i], "");
@ -2572,8 +2571,8 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
*/
fs_type.floating = 0;
fs_type.sign = dst_type.sign;
for (i = 0; i < num_fullblock_fs; ++i) {
for (j = 0; j < dst_channels; ++j) {
for (unsigned i = 0; i < num_fullblock_fs; ++i) {
for (unsigned j = 0; j < dst_channels; ++j) {
fs_src[i][j] = LLVMBuildBitCast(builder, fs_src[i][j],
lp_build_vec_type(gallivm, fs_type), "");
}
@ -2615,8 +2614,8 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
* for true AVX2 path untwiddle needs to be different).
* For now just order by colors first (so we can use unpack later).
*/
for (j = 0; j < num_fullblock_fs; j++) {
for (i = 0; i < dst_channels; i++) {
for (unsigned j = 0; j < num_fullblock_fs; j++) {
for (unsigned i = 0; i < dst_channels; i++) {
src[i*num_fullblock_fs + j] = fs_src[j][i];
if (dual_source_blend) {
src1[i*num_fullblock_fs + j] = fs_src1[j][i];
@ -2694,18 +2693,18 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
* force has_alpha to be true.)
* TODO: should skip this with "fake" blend, since post-blend conversion
* will clamp anyway.
* TODO: could also skip this if fragment color clamping is enabled. We
* don't support it natively so it gets baked into the shader however, so
* can't really tell here.
* TODO: could also skip this if fragment color clamping is enabled.
* We don't support it natively so it gets baked into the shader
* however, so can't really tell here.
*/
struct lp_build_context f32_bld;
assert(row_type.floating);
lp_build_context_init(&f32_bld, gallivm, row_type);
for (i = 0; i < src_count; i++) {
for (unsigned i = 0; i < src_count; i++) {
src[i] = lp_build_clamp_zero_one_nanzero(&f32_bld, src[i]);
}
if (dual_source_blend) {
for (i = 0; i < src_count; i++) {
for (unsigned i = 0; i < src_count; i++) {
src1[i] = lp_build_clamp_zero_one_nanzero(&f32_bld, src1[i]);
}
}
@ -2735,7 +2734,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
if (src_count < block_height) {
lp_build_concat_n(gallivm, mask_type, src_mask, 4, src_mask, src_count);
} else if (src_count > block_height) {
for (i = src_count; i > 0; --i) {
for (unsigned i = src_count; i > 0; --i) {
unsigned pixels = block_size / src_count;
unsigned idx = i - 1;
@ -2746,7 +2745,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
assert(mask_type.width == 32);
for (i = 0; i < src_count; ++i) {
for (unsigned i = 0; i < src_count; ++i) {
unsigned pixels = block_size / src_count;
unsigned pixel_width = row_type.width * dst_channels;
@ -2861,7 +2860,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
if (is_1d) {
load_unswizzled_block(gallivm, color_ptr, stride, block_width, 1,
dst, ls_type, dst_count / 4, dst_alignment);
for (i = dst_count / 4; i < dst_count; i++) {
for (unsigned i = dst_count / 4; i < dst_count; i++) {
dst[i] = lp_build_undef(gallivm, ls_type);
}
@ -2878,15 +2877,15 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
* This is necessary as we can only read 1 row from memory at a time,
* so the minimum dst_count will ever be at this point is 4.
*
* With, for example, R8 format you can have all 16 pixels in a 128 bit vector,
* this will take the 4 dsts and combine them into 1 src so we can perform blending
* on all 16 pixels in that single vector at once.
* With, for example, R8 format you can have all 16 pixels in a 128 bit
* vector, this will take the 4 dsts and combine them into 1 src so we can
* perform blending on all 16 pixels in that single vector at once.
*/
if (dst_count > src_count) {
if (ls_type.length != dst_type.length && ls_type.length == 1) {
LLVMTypeRef elem_type = lp_build_elem_type(gallivm, ls_type);
LLVMTypeRef ls_vec_type = LLVMVectorType(elem_type, 1);
for (i = 0; i < dst_count; i++) {
for (unsigned i = 0; i < dst_count; i++) {
dst[i] = LLVMBuildBitCast(builder, dst[i], ls_vec_type, "");
}
}
@ -2896,7 +2895,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
if (ls_type.length != dst_type.length) {
struct lp_type tmp_type = dst_type;
tmp_type.length = dst_type.length * 4 / src_count;
for (i = 0; i < src_count; i++) {
for (unsigned i = 0; i < src_count; i++) {
dst[i] = LLVMBuildBitCast(builder, dst[i],
lp_build_vec_type(gallivm, tmp_type), "");
}
@ -2924,7 +2923,7 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
* used for SRGB here and I think OpenGL expects this to work as expected
* (that is incoming values converted to srgb then logic op applied).
*/
for (i = 0; i < src_count; ++i) {
for (unsigned i = 0; i < src_count; ++i) {
dst[i] = lp_build_blend_aos(gallivm,
&variant->key.blend,
out_format,
@ -3030,7 +3029,6 @@ generate_fragment(struct llvmpipe_context *lp,
LLVMValueRef fs_out_color[LP_MAX_SAMPLES][PIPE_MAX_COLOR_BUFS][TGSI_NUM_CHANNELS][16 / 4];
LLVMValueRef function;
LLVMValueRef facing;
unsigned i;
boolean cbuf0_write_all;
const boolean dual_source_blend = key->blend.rt[0].blend_enable &&
util_blend_state_is_dual(&key->blend, 0);
@ -3040,7 +3038,7 @@ generate_fragment(struct llvmpipe_context *lp,
/* Adjust color input interpolation according to flatshade state:
*/
memcpy(inputs, shader->inputs, shader->info.base.num_inputs * sizeof inputs[0]);
for (i = 0; i < shader->info.base.num_inputs; i++) {
for (unsigned i = 0; i < shader->info.base.num_inputs; i++) {
if (inputs[i].interp == LP_INTERP_COLOR) {
if (key->flatshade)
inputs[i].interp = LP_INTERP_CONSTANT;
@ -3112,7 +3110,7 @@ generate_fragment(struct llvmpipe_context *lp,
/* XXX: need to propagate noalias down into color param now we are
* passing a pointer-to-pointer?
*/
for (i = 0; i < ARRAY_SIZE(arg_types); ++i)
for (unsigned i = 0; i < ARRAY_SIZE(arg_types); ++i)
if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
lp_add_function_attr(function, i + 1, LP_FUNC_ATTR_NOALIAS);
@ -3241,15 +3239,16 @@ generate_fragment(struct llvmpipe_context *lp,
a0_ptr, dadx_ptr, dady_ptr,
x, y);
for (i = 0; i < num_fs; i++) {
for (unsigned i = 0; i < num_fs; i++) {
if (key->multisample) {
LLVMValueRef smask_val = LLVMBuildLoad(builder, lp_jit_context_sample_mask(gallivm, context_ptr), "");
/*
* For multisampling, extract the per-sample mask from the incoming 64-bit mask,
* store to the per sample mask storage. Or all of them together to generate
* the fragment shader mask. (sample shading TODO).
* Take the incoming state coverage mask into account.
* For multisampling, extract the per-sample mask from the
* incoming 64-bit mask, store to the per sample mask storage. Or
* all of them together to generate the fragment shader
* mask. (sample shading TODO). Take the incoming state coverage
* mask into account.
*/
for (unsigned s = 0; s < key->coverage_samples; s++) {
LLVMValueRef sindexi = lp_build_const_int32(gallivm, i + (s * num_fs));
@ -3304,7 +3303,7 @@ generate_fragment(struct llvmpipe_context *lp,
facing,
thread_data_ptr);
for (i = 0; i < num_fs; i++) {
for (unsigned i = 0; i < num_fs; i++) {
LLVMValueRef ptr;
for (unsigned s = 0; s < key->coverage_samples; s++) {
int idx = (i + (s * num_fs));
@ -3526,7 +3525,7 @@ dump_fs_variant_key(struct lp_fragment_shader_variant_key *key)
const char *
lp_debug_fs_kind(enum lp_fs_kind kind)
{
switch(kind) {
switch (kind) {
case LP_FS_KIND_GENERAL:
return "GENERAL";
case LP_FS_KIND_BLIT_RGBA:
@ -4165,10 +4164,10 @@ llvmpipe_set_shader_images(struct pipe_context *pipe,
/**
* Return the blend factor equivalent to a destination alpha of one.
*/
static inline unsigned
force_dst_alpha_one(unsigned factor, boolean clamped_zero)
static inline enum pipe_blendfactor
force_dst_alpha_one(enum pipe_blendfactor factor, boolean clamped_zero)
{
switch(factor) {
switch (factor) {
case PIPE_BLENDFACTOR_DST_ALPHA:
return PIPE_BLENDFACTOR_ONE;
case PIPE_BLENDFACTOR_INV_DST_ALPHA:
@ -4178,9 +4177,9 @@ force_dst_alpha_one(unsigned factor, boolean clamped_zero)
return PIPE_BLENDFACTOR_ZERO;
else
return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE;
default:
return factor;
}
return factor;
}