X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fauxiliary%2Fdraw%2Fdraw_llvm.c;h=d4c89a851461823dbae5be20e9a2a05a9be2b0da;hb=16fcbb2eba95d0ec04c775894165e964b63d8e6f;hp=b9e55af42c76c77ff6946b1c4cf91f1441f8daa6;hpb=b8a1495106a8b70e9026b7798a5df2fb9737c55e;p=mesa.git diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c index b9e55af42c7..d4c89a85146 100644 --- a/src/gallium/auxiliary/draw/draw_llvm.c +++ b/src/gallium/auxiliary/draw/draw_llvm.c @@ -33,6 +33,8 @@ #include "gallivm/lp_bld_arit.h" #include "gallivm/lp_bld_arit_overflow.h" +#include "gallivm/lp_bld_bitarit.h" +#include "gallivm/lp_bld_gather.h" #include "gallivm/lp_bld_logic.h" #include "gallivm/lp_bld_const.h" #include "gallivm/lp_bld_swizzle.h" @@ -61,8 +63,7 @@ static void -draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *var, - boolean elts); +draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *var); struct draw_gs_llvm_iface { @@ -72,7 +73,7 @@ struct draw_gs_llvm_iface { LLVMValueRef input; }; -static INLINE const struct draw_gs_llvm_iface * +static inline const struct draw_gs_llvm_iface * draw_gs_llvm_iface(const struct lp_build_tgsi_gs_iface *iface) { return (const struct draw_gs_llvm_iface *)iface; @@ -95,8 +96,9 @@ create_jit_dvbuffer_type(struct gallivm_state *gallivm, elem_types[DRAW_JIT_DVBUFFER_SIZE] = int32_type; dvbuffer_type = LLVMStructTypeInContext(gallivm->context, elem_types, - Elements(elem_types), 0); + ARRAY_SIZE(elem_types), 0); + (void) target; /* silence unused var warning for non-debug build */ LP_CHECK_MEMBER_OFFSET(struct draw_vertex_buffer, map, target, dvbuffer_type, DRAW_JIT_DVBUFFER_MAP); @@ -131,8 +133,9 @@ create_jit_texture_type(struct gallivm_state *gallivm, const char *struct_name) LLVMArrayType(int32_type, PIPE_MAX_TEXTURE_LEVELS); texture_type = LLVMStructTypeInContext(gallivm->context, elem_types, - Elements(elem_types), 0); + ARRAY_SIZE(elem_types), 0); + (void) target; /* silence unused var warning for non-debug build */ LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, width, target, texture_type, DRAW_JIT_TEXTURE_WIDTH); @@ -184,8 +187,9 @@ create_jit_sampler_type(struct gallivm_state *gallivm, const char *struct_name) LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4); sampler_type = LLVMStructTypeInContext(gallivm->context, elem_types, - Elements(elem_types), 0); + ARRAY_SIZE(elem_types), 0); + (void) target; /* silence unused var warning for non-debug build */ LP_CHECK_MEMBER_OFFSET(struct draw_jit_sampler, min_lod, target, sampler_type, DRAW_JIT_SAMPLER_MIN_LOD); @@ -230,8 +234,14 @@ create_jit_context_type(struct gallivm_state *gallivm, PIPE_MAX_SHADER_SAMPLER_VIEWS); /* textures */ elem_types[5] = LLVMArrayType(sampler_type, PIPE_MAX_SAMPLERS); /* samplers */ + elem_types[6] = LLVMArrayType(LLVMPointerType(int_type, 0), /* vs_ssbo */ + LP_MAX_TGSI_SHADER_BUFFERS); + elem_types[7] = LLVMArrayType(int_type, /* num_vs_ssbos */ + LP_MAX_TGSI_SHADER_BUFFERS); context_type = LLVMStructTypeInContext(gallivm->context, elem_types, - Elements(elem_types), 0); + ARRAY_SIZE(elem_types), 0); + + (void) target; /* silence unused var warning for non-debug build */ LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, vs_constants, target, context_type, DRAW_JIT_CTX_CONSTANTS); LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, num_vs_constants, @@ -246,6 +256,10 @@ create_jit_context_type(struct gallivm_state *gallivm, LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, samplers, target, context_type, DRAW_JIT_CTX_SAMPLERS); + LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, vs_ssbos, + target, context_type, DRAW_JIT_CTX_SSBOS); + LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, num_vs_ssbos, + target, context_type, DRAW_JIT_CTX_NUM_SSBOS); LP_CHECK_STRUCT_SIZE(struct draw_jit_context, target, context_type); @@ -287,9 +301,14 @@ create_gs_jit_context_type(struct gallivm_state *gallivm, elem_types[8] = LLVMPointerType(LLVMVectorType(int_type, vector_length), 0); + elem_types[9] = LLVMArrayType(LLVMPointerType(int_type, 0), /* ssbos */ + LP_MAX_TGSI_SHADER_BUFFERS); + elem_types[10] = LLVMArrayType(int_type, /* num_ssbos */ + LP_MAX_TGSI_SHADER_BUFFERS); context_type = LLVMStructTypeInContext(gallivm->context, elem_types, - Elements(elem_types), 0); + ARRAY_SIZE(elem_types), 0); + (void) target; /* silence unused var warning for non-debug build */ LP_CHECK_MEMBER_OFFSET(struct draw_gs_jit_context, constants, target, context_type, DRAW_GS_JIT_CTX_CONSTANTS); LP_CHECK_MEMBER_OFFSET(struct draw_gs_jit_context, num_constants, @@ -313,6 +332,10 @@ create_gs_jit_context_type(struct gallivm_state *gallivm, LP_CHECK_MEMBER_OFFSET(struct draw_gs_jit_context, emitted_prims, target, context_type, DRAW_GS_JIT_CTX_EMITTED_PRIMS); + LP_CHECK_MEMBER_OFFSET(struct draw_gs_jit_context, ssbos, + target, context_type, DRAW_GS_JIT_CTX_SSBOS); + LP_CHECK_MEMBER_OFFSET(struct draw_gs_jit_context, num_ssbos, + target, context_type, DRAW_GS_JIT_CTX_NUM_SSBOS); LP_CHECK_STRUCT_SIZE(struct draw_gs_jit_context, target, context_type); @@ -345,18 +368,23 @@ create_jit_vertex_buffer_type(struct gallivm_state *gallivm, LLVMTypeRef elem_types[4]; LLVMTypeRef vb_type; - elem_types[0] = - elem_types[1] = LLVMInt32TypeInContext(gallivm->context); - elem_types[2] = + elem_types[0] = LLVMInt16TypeInContext(gallivm->context); + elem_types[1] = LLVMInt8TypeInContext(gallivm->context); + elem_types[2] = LLVMInt32TypeInContext(gallivm->context); elem_types[3] = LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0); vb_type = LLVMStructTypeInContext(gallivm->context, elem_types, - Elements(elem_types), 0); + ARRAY_SIZE(elem_types), 0); + (void) target; /* silence unused var warning for non-debug build */ LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, stride, target, vb_type, 0); - LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, buffer_offset, + LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, is_user_buffer, target, vb_type, 1); + LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, buffer_offset, + target, vb_type, 2); + LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, buffer.resource, + target, vb_type, 3); LP_CHECK_STRUCT_SIZE(struct pipe_vertex_buffer, target, vb_type); @@ -371,19 +399,18 @@ static LLVMTypeRef create_jit_vertex_header(struct gallivm_state *gallivm, int data_elems) { LLVMTargetDataRef target = gallivm->target; - LLVMTypeRef elem_types[4]; + LLVMTypeRef elem_types[3]; LLVMTypeRef vertex_header; char struct_name[24]; - util_snprintf(struct_name, 23, "vertex_header%d", data_elems); + snprintf(struct_name, 23, "vertex_header%d", data_elems); elem_types[DRAW_JIT_VERTEX_VERTEX_ID] = LLVMIntTypeInContext(gallivm->context, 32); - elem_types[DRAW_JIT_VERTEX_CLIP] = LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4); - elem_types[DRAW_JIT_VERTEX_PRE_CLIP_POS] = LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4); + elem_types[DRAW_JIT_VERTEX_CLIP_POS] = LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4); elem_types[DRAW_JIT_VERTEX_DATA] = LLVMArrayType(elem_types[1], data_elems); vertex_header = LLVMStructTypeInContext(gallivm->context, elem_types, - Elements(elem_types), 0); + ARRAY_SIZE(elem_types), 0); /* these are bit-fields and we can't take address of them LP_CHECK_MEMBER_OFFSET(struct vertex_header, clipmask, @@ -399,12 +426,10 @@ create_jit_vertex_header(struct gallivm_state *gallivm, int data_elems) target, vertex_header, DRAW_JIT_VERTEX_VERTEX_ID); */ - LP_CHECK_MEMBER_OFFSET(struct vertex_header, clip, - target, vertex_header, - DRAW_JIT_VERTEX_CLIP); - LP_CHECK_MEMBER_OFFSET(struct vertex_header, pre_clip_pos, + (void) target; /* silence unused var warning for non-debug build */ + LP_CHECK_MEMBER_OFFSET(struct vertex_header, clip_pos, target, vertex_header, - DRAW_JIT_VERTEX_PRE_CLIP_POS); + DRAW_JIT_VERTEX_CLIP_POS); LP_CHECK_MEMBER_OFFSET(struct vertex_header, data, target, vertex_header, DRAW_JIT_VERTEX_DATA); @@ -547,14 +572,14 @@ draw_llvm_create_variant(struct draw_llvm *llvm, variant = MALLOC(sizeof *variant + shader->variant_key_size - sizeof variant->key); - if (variant == NULL) + if (!variant) return NULL; variant->llvm = llvm; variant->shader = shader; - util_snprintf(module_name, sizeof(module_name), "draw_llvm_vs_variant%u", - variant->shader->variants_cached); + snprintf(module_name, sizeof(module_name), "draw_llvm_vs_variant%u", + variant->shader->variants_cached); variant->gallivm = gallivm_create(module_name, llvm->context); @@ -571,17 +596,13 @@ draw_llvm_create_variant(struct draw_llvm *llvm, variant->vertex_header_ptr_type = LLVMPointerType(vertex_header, 0); - draw_llvm_generate(llvm, variant, FALSE); /* linear */ - draw_llvm_generate(llvm, variant, TRUE); /* elts */ + draw_llvm_generate(llvm, variant); gallivm_compile_module(variant->gallivm); variant->jit_func = (draw_jit_vert_func) gallivm_jit_function(variant->gallivm, variant->function); - variant->jit_func_elts = (draw_jit_vert_func_elts) - gallivm_jit_function(variant->gallivm, variant->function_elts); - gallivm_free_ir(variant->gallivm); variant->list_item_global.base = variant; @@ -601,8 +622,9 @@ generate_vs(struct draw_llvm_variant *variant, const LLVMValueRef (*inputs)[TGSI_NUM_CHANNELS], const struct lp_bld_tgsi_system_values *system_values, LLVMValueRef context_ptr, - struct lp_build_sampler_soa *draw_sampler, - boolean clamp_vertex_color) + const struct lp_build_sampler_soa *draw_sampler, + boolean clamp_vertex_color, + struct lp_build_mask_context *bld_mask) { struct draw_llvm *llvm = variant->llvm; const struct tgsi_token *tokens = llvm->draw->vs.vertex_shader->state.tokens; @@ -610,20 +632,30 @@ generate_vs(struct draw_llvm_variant *variant, draw_jit_context_vs_constants(variant->gallivm, context_ptr); LLVMValueRef num_consts_ptr = draw_jit_context_num_vs_constants(variant->gallivm, context_ptr); + LLVMValueRef ssbos_ptr = + draw_jit_context_vs_ssbos(variant->gallivm, context_ptr); + LLVMValueRef num_ssbos_ptr = + draw_jit_context_num_vs_ssbos(variant->gallivm, context_ptr); + + struct lp_build_tgsi_params params; + memset(¶ms, 0, sizeof(params)); + + params.type = vs_type; + params.mask = bld_mask; + params.consts_ptr = consts_ptr; + params.const_sizes_ptr = num_consts_ptr; + params.system_values = system_values; + params.inputs = inputs; + params.context_ptr = context_ptr; + params.sampler = draw_sampler; + params.info = &llvm->draw->vs.vertex_shader->info; + params.ssbo_ptr = ssbos_ptr; + params.ssbo_sizes_ptr = num_ssbos_ptr; lp_build_tgsi_soa(variant->gallivm, tokens, - vs_type, - NULL /*struct lp_build_mask_context *mask*/, - consts_ptr, - num_consts_ptr, - system_values, - inputs, - outputs, - context_ptr, - draw_sampler, - &llvm->draw->vs.vertex_shader->info, - NULL); + ¶ms, + outputs); { LLVMValueRef out; @@ -651,139 +683,133 @@ generate_vs(struct draw_llvm_variant *variant, } } + static void -generate_fetch(struct gallivm_state *gallivm, - struct draw_context *draw, - LLVMValueRef vbuffers_ptr, - LLVMValueRef *res, - struct pipe_vertex_element *velem, - LLVMValueRef vbuf, - LLVMValueRef index, - LLVMValueRef instance_id, - LLVMValueRef start_instance) +fetch_instanced(struct gallivm_state *gallivm, + const struct util_format_description *format_desc, + struct lp_type vs_type, + LLVMValueRef vb_stride, + LLVMValueRef map_ptr, + LLVMValueRef buffer_size_adj, + LLVMValueRef *inputs, + LLVMValueRef index) { - const struct util_format_description *format_desc = - util_format_description(velem->src_format); - LLVMValueRef zero = LLVMConstNull(LLVMInt32TypeInContext(gallivm->context)); + LLVMTypeRef i32_t = LLVMInt32TypeInContext(gallivm->context); + LLVMTypeRef aosf_t, aosi_t; + LLVMValueRef zero = LLVMConstNull(i32_t); LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef indices = - LLVMConstInt(LLVMInt64TypeInContext(gallivm->context), - velem->vertex_buffer_index, 0); - LLVMValueRef vbuffer_ptr = LLVMBuildGEP(builder, vbuffers_ptr, - &indices, 1, ""); - LLVMValueRef vb_stride = draw_jit_vbuffer_stride(gallivm, vbuf); - LLVMValueRef vb_buffer_offset = draw_jit_vbuffer_offset(gallivm, vbuf); - LLVMValueRef map_ptr = draw_jit_dvbuffer_map(gallivm, vbuffer_ptr); - LLVMValueRef buffer_size = draw_jit_dvbuffer_size(gallivm, vbuffer_ptr); - LLVMValueRef stride; - LLVMValueRef buffer_overflowed; - LLVMValueRef needed_buffer_size; - LLVMValueRef temp_ptr = - lp_build_alloca(gallivm, - lp_build_vec_type(gallivm, lp_float32_vec4_type()), ""); - LLVMValueRef ofbit = NULL; - struct lp_build_if_state if_ctx; + LLVMValueRef stride, buffer_overflowed, aos, index_valid; + unsigned i; - if (velem->instance_divisor) { - /* Index is equal to the start instance plus the number of current - * instance divided by the divisor. In this case we compute it as: - * index = start_instance + (instance_id / divisor) - */ - LLVMValueRef current_instance; - current_instance = LLVMBuildUDiv(builder, instance_id, - lp_build_const_int32(gallivm, velem->instance_divisor), - "instance_divisor"); - index = lp_build_uadd_overflow(gallivm, start_instance, - current_instance, &ofbit); - } + aosf_t = lp_build_vec_type(gallivm, lp_float32_vec4_type()); + aosi_t = lp_build_vec_type(gallivm, lp_int32_vec4_type()); - stride = lp_build_umul_overflow(gallivm, vb_stride, index, &ofbit); - stride = lp_build_uadd_overflow(gallivm, stride, vb_buffer_offset, &ofbit); - stride = lp_build_uadd_overflow( - gallivm, stride, - lp_build_const_int32(gallivm, velem->src_offset), &ofbit); - needed_buffer_size = lp_build_uadd_overflow( - gallivm, stride, - lp_build_const_int32(gallivm, - util_format_get_blocksize(velem->src_format)), - &ofbit); - - buffer_overflowed = LLVMBuildICmp(builder, LLVMIntUGT, - needed_buffer_size, buffer_size, + /* This mul can overflow. Wraparound is ok. */ + stride = LLVMBuildMul(builder, vb_stride, index, ""); + + buffer_overflowed = LLVMBuildICmp(builder, LLVMIntUGE, + stride, buffer_size_adj, "buffer_overflowed"); - buffer_overflowed = LLVMBuildOr(builder, buffer_overflowed, ofbit, ""); -#if 0 - lp_build_printf(gallivm, "vbuf index = %u, vb_stride is %u\n", - index, vb_stride); - lp_build_printf(gallivm, " vb_buffer_offset = %u, src_offset is %u\n", - vb_buffer_offset, - lp_build_const_int32(gallivm, velem->src_offset)); - lp_build_print_value(gallivm, " blocksize = ", - lp_build_const_int32( - gallivm, - util_format_get_blocksize(velem->src_format))); - lp_build_printf(gallivm, " instance_id = %u\n", instance_id); - lp_build_printf(gallivm, " stride = %u\n", stride); - lp_build_printf(gallivm, " buffer size = %u\n", buffer_size); - lp_build_printf(gallivm, " needed_buffer_size = %u\n", needed_buffer_size); - lp_build_print_value(gallivm, " buffer overflowed = ", buffer_overflowed); -#endif - lp_build_if(&if_ctx, gallivm, buffer_overflowed); - { - LLVMValueRef val = - lp_build_const_vec(gallivm, lp_float32_vec4_type(), 0); - LLVMBuildStore(builder, val, temp_ptr); - } - lp_build_else(&if_ctx); - { - LLVMValueRef val; - map_ptr = LLVMBuildGEP(builder, map_ptr, &stride, 1, ""); - - val = lp_build_fetch_rgba_aos(gallivm, - format_desc, - lp_float32_vec4_type(), - FALSE, - map_ptr, - zero, zero, zero); - LLVMBuildStore(builder, val, temp_ptr); + if (0) { + lp_build_print_value(gallivm, " instance index = ", index); + lp_build_print_value(gallivm, " buffer overflowed = ", buffer_overflowed); } - lp_build_endif(&if_ctx); - *res = LLVMBuildLoad(builder, temp_ptr, "aos"); + index_valid = LLVMBuildNot(builder, buffer_overflowed, ""); + index_valid = LLVMBuildSExt(builder, index_valid, i32_t, ""); + stride = LLVMBuildAnd(builder, stride, index_valid, ""); + + aos = lp_build_fetch_rgba_aos(gallivm, + format_desc, + lp_float32_vec4_type(), + FALSE, + map_ptr, + stride, zero, zero, + NULL); + + index_valid = lp_build_broadcast(gallivm, aosi_t, index_valid); + aos = LLVMBuildBitCast(builder, aos, aosi_t, ""); + aos = LLVMBuildAnd(builder, aos, index_valid, ""); + aos = LLVMBuildBitCast(builder, aos, aosf_t, ""); + + for (i = 0; i < TGSI_NUM_CHANNELS; i++) { + LLVMValueRef index = lp_build_const_int32(gallivm, i); + inputs[i] = lp_build_extract_broadcast(gallivm, + lp_float32_vec4_type(), + vs_type, aos, index); + } } + static void -convert_to_soa(struct gallivm_state *gallivm, - LLVMValueRef (*src_aos)[LP_MAX_VECTOR_WIDTH / 32], - LLVMValueRef (*dst_soa)[TGSI_NUM_CHANNELS], - unsigned num_attribs, const struct lp_type soa_type) +fetch_vector(struct gallivm_state *gallivm, + const struct util_format_description *format_desc, + struct lp_type vs_type, + LLVMValueRef vb_stride, + LLVMValueRef map_ptr, + LLVMValueRef buffer_size_adj, + LLVMValueRef *inputs, + LLVMValueRef indices) { - unsigned i, j, k; - struct lp_type aos_channel_type = soa_type; + LLVMBuilderRef builder = gallivm->builder; + struct lp_build_context blduivec; + struct lp_type fetch_type = vs_type; + LLVMValueRef offset, valid_mask; + unsigned i; - debug_assert(TGSI_NUM_CHANNELS == 4); - debug_assert((soa_type.length % TGSI_NUM_CHANNELS) == 0); + lp_build_context_init(&blduivec, gallivm, lp_uint_type(vs_type)); - aos_channel_type.length >>= 1; + vb_stride = lp_build_broadcast_scalar(&blduivec, vb_stride); + buffer_size_adj = lp_build_broadcast_scalar(&blduivec, buffer_size_adj); - for (i = 0; i < num_attribs; ++i) { - LLVMValueRef aos_channels[TGSI_NUM_CHANNELS]; - unsigned pixels_per_channel = soa_type.length / TGSI_NUM_CHANNELS; + /* This mul can overflow. Wraparound is ok. */ + offset = lp_build_mul(&blduivec, vb_stride, indices); - for (j = 0; j < TGSI_NUM_CHANNELS; ++j) { - LLVMValueRef channel[LP_MAX_VECTOR_LENGTH] = { 0 }; + valid_mask = lp_build_compare(gallivm, blduivec.type, + PIPE_FUNC_LESS, offset, buffer_size_adj); - assert(pixels_per_channel <= LP_MAX_VECTOR_LENGTH); + /* not valid elements use offset 0 */ + offset = LLVMBuildAnd(builder, offset, valid_mask, ""); - for (k = 0; k < pixels_per_channel; ++k) { - channel[k] = src_aos[i][j + TGSI_NUM_CHANNELS * k]; - } + if (0) { + lp_build_print_value(gallivm, " indices = ", indices); + lp_build_print_value(gallivm, " offsets = ", offset); + lp_build_print_value(gallivm, " valid_mask = ", valid_mask); + } + + /* + * Unlike fetch_instanced, use SoA fetch instead of multiple AoS fetches. + * This should always produce better code. + */ - aos_channels[j] = lp_build_concat(gallivm, channel, aos_channel_type, pixels_per_channel); + /* The type handling is annoying here... */ + if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB && + format_desc->channel[0].pure_integer) { + if (format_desc->channel[0].type == UTIL_FORMAT_TYPE_SIGNED) { + fetch_type = lp_type_int_vec(vs_type.width, vs_type.width * vs_type.length); } + else if (format_desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED) { + fetch_type = lp_type_uint_vec(vs_type.width, vs_type.width * vs_type.length); + } + } + + lp_build_fetch_rgba_soa(gallivm, format_desc, + fetch_type, FALSE, map_ptr, offset, + blduivec.zero, blduivec.zero, + NULL, inputs); + + for (i = 0; i < TGSI_NUM_CHANNELS; i++) { + inputs[i] = LLVMBuildBitCast(builder, inputs[i], + lp_build_vec_type(gallivm, vs_type), ""); + } - lp_build_transpose_aos(gallivm, soa_type, aos_channels, dst_soa[i]); + /* out-of-bound fetches return all zeros */ + for (i = 0; i < TGSI_NUM_CHANNELS; i++) { + inputs[i] = LLVMBuildBitCast(builder, inputs[i], blduivec.vec_type, ""); + inputs[i] = LLVMBuildAnd(builder, inputs[i], valid_mask, ""); + inputs[i] = LLVMBuildBitCast(builder, inputs[i], + lp_build_vec_type(gallivm, vs_type), ""); } } @@ -811,7 +837,7 @@ store_aos(struct gallivm_state *gallivm, #endif /* Unaligned store due to the vertex header */ - lp_set_store_alignment(LLVMBuildStore(builder, value, data_ptr), sizeof(float)); + LLVMSetAlignment(LLVMBuildStore(builder, value, data_ptr), sizeof(float)); } /** @@ -820,7 +846,7 @@ store_aos(struct gallivm_state *gallivm, * struct vertex_header { * unsigned clipmask:DRAW_TOTAL_CLIP_PLANES; * unsigned edgeflag:1; - * unsigned have_clipdist:1; + * unsigned pad:1; * unsigned vertex_id:16; * [...] * } @@ -832,7 +858,7 @@ store_aos(struct gallivm_state *gallivm, * { * return (x >> 16) | // vertex_id * ((x & 0x3fff) << 18) | // clipmask - * ((x & 0x4000) << 3) | // have_clipdist + * ((x & 0x4000) << 3) | // pad * ((x & 0x8000) << 1); // edgeflag * } */ @@ -844,19 +870,23 @@ adjust_mask(struct gallivm_state *gallivm, LLVMBuilderRef builder = gallivm->builder; LLVMValueRef vertex_id; LLVMValueRef clipmask; - LLVMValueRef have_clipdist; + LLVMValueRef pad; LLVMValueRef edgeflag; vertex_id = LLVMBuildLShr(builder, mask, lp_build_const_int32(gallivm, 16), ""); clipmask = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x3fff), ""); clipmask = LLVMBuildShl(builder, clipmask, lp_build_const_int32(gallivm, 18), ""); - have_clipdist = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x4000), ""); - have_clipdist = LLVMBuildShl(builder, have_clipdist, lp_build_const_int32(gallivm, 3), ""); + if (0) { + pad = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x4000), ""); + pad = LLVMBuildShl(builder, pad, lp_build_const_int32(gallivm, 3), ""); + } edgeflag = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x8000), ""); edgeflag = LLVMBuildShl(builder, edgeflag, lp_build_const_int32(gallivm, 1), ""); mask = LLVMBuildOr(builder, vertex_id, clipmask, ""); - mask = LLVMBuildOr(builder, mask, have_clipdist, ""); + if (0) { + mask = LLVMBuildOr(builder, mask, pad, ""); + } mask = LLVMBuildOr(builder, mask, edgeflag, ""); #endif return mask; @@ -871,7 +901,7 @@ store_aos_array(struct gallivm_state *gallivm, int attrib, int num_outputs, LLVMValueRef clipmask, - boolean have_clipdist) + boolean need_edgeflag) { LLVMBuilderRef builder = gallivm->builder; LLVMValueRef attr_index = lp_build_const_int32(gallivm, attrib); @@ -902,11 +932,15 @@ store_aos_array(struct gallivm_state *gallivm, * code here. See struct vertex_header in draw_private.h. */ assert(DRAW_TOTAL_CLIP_PLANES==14); - /* initialize vertex id:16 = 0xffff, have_clipdist:1 = 0, edgeflag:1 = 1 */ - vertex_id_pad_edgeflag = (0xffff << 16) | (1 << DRAW_TOTAL_CLIP_PLANES); - if (have_clipdist) - vertex_id_pad_edgeflag |= 1 << (DRAW_TOTAL_CLIP_PLANES+1); - val = lp_build_const_int_vec(gallivm, lp_int_type(soa_type), vertex_id_pad_edgeflag); + /* initialize vertex id:16 = 0xffff, pad:1 = 0, edgeflag:1 = 1 */ + if (!need_edgeflag) { + vertex_id_pad_edgeflag = (0xffff << 16) | (1 << DRAW_TOTAL_CLIP_PLANES); + } + else { + vertex_id_pad_edgeflag = (0xffff << 16); + } + val = lp_build_const_int_vec(gallivm, lp_int_type(soa_type), + vertex_id_pad_edgeflag); /* OR with the clipmask */ cliptmp = LLVMBuildOr(builder, val, clipmask, ""); for (i = 0; i < vector_length; i++) { @@ -936,7 +970,7 @@ convert_to_aos(struct gallivm_state *gallivm, LLVMValueRef clipmask, int num_outputs, struct lp_type soa_type, - boolean have_clipdist) + boolean need_edgeflag) { LLVMBuilderRef builder = gallivm->builder; unsigned chan, attrib, i; @@ -992,7 +1026,8 @@ convert_to_aos(struct gallivm_state *gallivm, aos, attrib, num_outputs, - clipmask, have_clipdist); + clipmask, + need_edgeflag); } #if DEBUG_STORE lp_build_printf(gallivm, " # storing end\n"); @@ -1008,7 +1043,7 @@ store_clip(struct gallivm_state *gallivm, const struct lp_type vs_type, LLVMValueRef io_ptr, LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS], - boolean pre_clip_pos, int idx) + int idx) { LLVMBuilderRef builder = gallivm->builder; LLVMValueRef soa[4]; @@ -1035,14 +1070,8 @@ store_clip(struct gallivm_state *gallivm, soa[2] = LLVMBuildLoad(builder, outputs[idx][2], ""); /*z0 z1 .. zn*/ soa[3] = LLVMBuildLoad(builder, outputs[idx][3], ""); /*w0 w1 .. wn*/ - if (!pre_clip_pos) { - for (i = 0; i < vs_type.length; i++) { - clip_ptrs[i] = draw_jit_header_clip(gallivm, io_ptrs[i]); - } - } else { - for (i = 0; i < vs_type.length; i++) { - clip_ptrs[i] = draw_jit_header_pre_clip_pos(gallivm, io_ptrs[i]); - } + for (i = 0; i < vs_type.length; i++) { + clip_ptrs[i] = draw_jit_header_clip_pos(gallivm, io_ptrs[i]); } lp_build_transpose_aos(gallivm, vs_type, soa, soa); @@ -1060,7 +1089,7 @@ store_clip(struct gallivm_state *gallivm, clip_ptr = LLVMBuildPointerCast(builder, clip_ptr, clip_ptr_type, ""); /* Unaligned store */ - lp_set_store_alignment(LLVMBuildStore(builder, aos[j], clip_ptr), sizeof(float)); + LLVMSetAlignment(LLVMBuildStore(builder, aos[j], clip_ptr), sizeof(float)); } } @@ -1114,10 +1143,8 @@ generate_viewport(struct draw_llvm_variant *variant, /* divide by w */ out = LLVMBuildFMul(builder, out, out3, ""); - /* mult by scale */ - out = LLVMBuildFMul(builder, out, scale, ""); - /* add translation */ - out = LLVMBuildFAdd(builder, out, trans, ""); + /* mult by scale, add translation */ + out = lp_build_fmuladd(builder, out, scale, trans); /* store transformed outputs */ LLVMBuildStore(builder, out, outputs[pos][i]); @@ -1134,11 +1161,7 @@ generate_clipmask(struct draw_llvm *llvm, struct gallivm_state *gallivm, struct lp_type vs_type, LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS], - boolean clip_xy, - boolean clip_z, - boolean clip_user, - boolean clip_halfz, - unsigned ucp_enable, + struct draw_llvm_variant_key *key, LLVMValueRef context_ptr, boolean *have_clipdist) { @@ -1154,11 +1177,13 @@ generate_clipmask(struct draw_llvm *llvm, const unsigned pos = llvm->draw->vs.position_output; const unsigned cv = llvm->draw->vs.clipvertex_output; int num_written_clipdistance = llvm->draw->vs.vertex_shader->info.num_written_clipdistance; - bool have_cd = false; + boolean have_cd = false; + boolean clip_user = key->clip_user; + unsigned ucp_enable = key->ucp_enable; unsigned cd[2]; - cd[0] = llvm->draw->vs.clipdistance_output[0]; - cd[1] = llvm->draw->vs.clipdistance_output[1]; + cd[0] = llvm->draw->vs.ccdistance_output[0]; + cd[1] = llvm->draw->vs.ccdistance_output[1]; if (cd[0] != pos || cd[1] != pos) have_cd = true; @@ -1194,8 +1219,16 @@ generate_clipmask(struct draw_llvm *llvm, cv_w = pos_w; } + /* + * Be careful with the comparisons and NaNs (using llvm's unordered + * comparisons here). + */ /* Cliptest, for hardwired planes */ - if (clip_xy) { + /* + * XXX should take guardband into account (currently not in key). + * Otherwise might run the draw pipeline stages for nothing. + */ + if (key->clip_xy) { /* plane 1 */ test = lp_build_compare(gallivm, f32_type, PIPE_FUNC_GREATER, pos_x , pos_w); temp = shift; @@ -1223,9 +1256,9 @@ generate_clipmask(struct draw_llvm *llvm, mask = LLVMBuildOr(builder, mask, test, ""); } - if (clip_z) { + if (key->clip_z) { temp = lp_build_const_int_vec(gallivm, i32_type, 16); - if (clip_halfz) { + if (key->clip_halfz) { /* plane 5 */ test = lp_build_compare(gallivm, f32_type, PIPE_FUNC_GREATER, zero, pos_z); test = LLVMBuildAnd(builder, test, temp, ""); @@ -1288,22 +1321,19 @@ generate_clipmask(struct draw_llvm *llvm, plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); plane1 = LLVMBuildLoad(builder, plane_ptr, "plane_y"); planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); - test = LLVMBuildFMul(builder, planes, cv_y, ""); - sum = LLVMBuildFAdd(builder, sum, test, ""); + sum = lp_build_fmuladd(builder, planes, cv_y, sum); indices[2] = lp_build_const_int32(gallivm, 2); plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); plane1 = LLVMBuildLoad(builder, plane_ptr, "plane_z"); planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); - test = LLVMBuildFMul(builder, planes, cv_z, ""); - sum = LLVMBuildFAdd(builder, sum, test, ""); + sum = lp_build_fmuladd(builder, planes, cv_z, sum); indices[2] = lp_build_const_int32(gallivm, 3); plane_ptr = LLVMBuildGEP(builder, planes_ptr, indices, 3, ""); plane1 = LLVMBuildLoad(builder, plane_ptr, "plane_w"); planes = lp_build_broadcast(gallivm, vs_type_llvm, plane1); - test = LLVMBuildFMul(builder, planes, cv_w, ""); - sum = LLVMBuildFAdd(builder, sum, test, ""); + sum = lp_build_fmuladd(builder, planes, cv_w, sum); test = lp_build_compare(gallivm, f32_type, PIPE_FUNC_GREATER, zero, sum); temp = lp_build_const_int_vec(gallivm, i32_type, 1LL << plane_idx); @@ -1312,35 +1342,62 @@ generate_clipmask(struct draw_llvm *llvm, } } } + if (key->need_edgeflags) { + /* + * This isn't really part of clipmask but stored the same in vertex + * header later, so do it here. + */ + unsigned edge_attr = llvm->draw->vs.edgeflag_output; + LLVMValueRef one = lp_build_const_vec(gallivm, f32_type, 1.0); + LLVMValueRef edgeflag = LLVMBuildLoad(builder, outputs[edge_attr][0], ""); + test = lp_build_compare(gallivm, f32_type, PIPE_FUNC_EQUAL, one, edgeflag); + temp = lp_build_const_int_vec(gallivm, i32_type, + 1LL << DRAW_TOTAL_CLIP_PLANES); + test = LLVMBuildAnd(builder, test, temp, ""); + mask = LLVMBuildOr(builder, mask, test, ""); + } return mask; } /** * Returns boolean if any clipping has occurred - * Used zero/non-zero i32 value to represent boolean + * Used zero/one i8 value to represent boolean */ static LLVMValueRef -clipmask_booli32(struct gallivm_state *gallivm, - const struct lp_type vs_type, - LLVMValueRef clipmask_bool_ptr) +clipmask_booli8(struct gallivm_state *gallivm, + const struct lp_type vs_type, + LLVMValueRef clipmask_bool_ptr, + boolean edgeflag_in_clipmask) { LLVMBuilderRef builder = gallivm->builder; - LLVMTypeRef int32_type = LLVMInt32TypeInContext(gallivm->context); + LLVMTypeRef int8_type = LLVMInt8TypeInContext(gallivm->context); LLVMValueRef clipmask_bool = LLVMBuildLoad(builder, clipmask_bool_ptr, ""); - LLVMValueRef ret = LLVMConstNull(int32_type); - LLVMValueRef temp; - int i; + LLVMValueRef ret; + struct lp_build_context bldivec; + + lp_build_context_init(&bldivec, gallivm, lp_int_type(vs_type)); /* - * Can do this with log2(vector length) pack instructions and one extract - * (as we don't actually need a or) with sse2 which would be way better. + * We need to invert the edgeflag bit from the clipmask here + * (because the result is really if we want to run the pipeline or not + * and we (may) need it if edgeflag was 0). */ - for (i=0; i < vs_type.length; i++) { - temp = LLVMBuildExtractElement(builder, clipmask_bool, - lp_build_const_int32(gallivm, i) , ""); - ret = LLVMBuildOr(builder, ret, temp, ""); + if (edgeflag_in_clipmask) { + LLVMValueRef edge = lp_build_const_int_vec(gallivm, bldivec.type, + 1LL << DRAW_TOTAL_CLIP_PLANES); + clipmask_bool = LLVMBuildXor(builder, clipmask_bool, edge, ""); } + + /* + * XXX: probably should mask off bits from the mask which come from + * vertices which were beyond the count (i.e. indices_valid for + * linear fetches, for elts ones we don't have the correct mask + * right now). Otherwise might run the pipeline for nothing, + * though everything should still work. + */ + ret = lp_build_any_true_range(&bldivec, vs_type.length, clipmask_bool); + ret = LLVMBuildZExt(builder, ret, int8_type, ""); return ret; } @@ -1487,36 +1544,38 @@ draw_gs_llvm_epilogue(const struct lp_build_tgsi_gs_iface *gs_base, } static void -draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, - boolean elts) +draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) { struct gallivm_state *gallivm = variant->gallivm; LLVMContextRef context = gallivm->context; LLVMTypeRef int32_type = LLVMInt32TypeInContext(context); LLVMTypeRef arg_types[11]; - unsigned num_arg_types = - elts ? Elements(arg_types) : Elements(arg_types) - 1; + unsigned num_arg_types = ARRAY_SIZE(arg_types); LLVMTypeRef func_type; LLVMValueRef context_ptr; LLVMBasicBlockRef block; LLVMBuilderRef builder; char func_name[64]; struct lp_type vs_type; - LLVMValueRef end, start; - LLVMValueRef count, fetch_elts, fetch_elt_max, fetch_count; + LLVMValueRef count, fetch_elts, start_or_maxelt; LLVMValueRef vertex_id_offset, start_instance; LLVMValueRef stride, step, io_itr; + LLVMValueRef ind_vec, start_vec, have_elts, fetch_max, tmp; LLVMValueRef io_ptr, vbuffers_ptr, vb_ptr; - LLVMValueRef zero = lp_build_const_int32(gallivm, 0); - LLVMValueRef one = lp_build_const_int32(gallivm, 1); + LLVMValueRef vb_stride[PIPE_MAX_ATTRIBS]; + LLVMValueRef map_ptr[PIPE_MAX_ATTRIBS]; + LLVMValueRef buffer_size_adj[PIPE_MAX_ATTRIBS]; + LLVMValueRef instance_index[PIPE_MAX_ATTRIBS]; + LLVMValueRef fake_buf_ptr, fake_buf; + struct draw_context *draw = llvm->draw; const struct tgsi_shader_info *vs_info = &draw->vs.vertex_shader->info; unsigned i, j; - struct lp_build_context bld; + struct lp_build_context bld, blduivec; struct lp_build_loop_state lp_loop; + struct lp_build_if_state if_ctx; const int vector_length = lp_native_vector_width / 32; LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][TGSI_NUM_CHANNELS]; - LLVMValueRef fetch_max; struct lp_build_sampler_soa *sampler = 0; LLVMValueRef ret, clipmask_bool_ptr; struct draw_llvm_variant_key *key = &variant->key; @@ -1528,86 +1587,80 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, * the values). */ const boolean bypass_viewport = key->has_gs || key->bypass_viewport || - llvm->draw->vs.vertex_shader->info.writes_viewport_index; + vs_info->writes_viewport_index; const boolean enable_cliptest = !key->has_gs && (key->clip_xy || - key->clip_z || - key->clip_user); + key->clip_z || + key->clip_user || + key->need_edgeflags); LLVMValueRef variant_func; - const unsigned pos = llvm->draw->vs.position_output; - const unsigned cv = llvm->draw->vs.clipvertex_output; + const unsigned pos = draw->vs.position_output; + const unsigned cv = draw->vs.clipvertex_output; boolean have_clipdist = FALSE; struct lp_bld_tgsi_system_values system_values; memset(&system_values, 0, sizeof(system_values)); - util_snprintf(func_name, sizeof(func_name), "draw_llvm_vs_variant%u_%s", - variant->shader->variants_cached, elts ? "elts" : "linear"); + snprintf(func_name, sizeof(func_name), "draw_llvm_vs_variant%u", + variant->shader->variants_cached); i = 0; arg_types[i++] = get_context_ptr_type(variant); /* context */ arg_types[i++] = get_vertex_header_ptr_type(variant); /* vertex_header */ arg_types[i++] = get_buffer_ptr_type(variant); /* vbuffers */ - if (elts) { - arg_types[i++] = LLVMPointerType(int32_type, 0);/* fetch_elts */ - arg_types[i++] = int32_type; /* fetch_elt_max */ - } else - arg_types[i++] = int32_type; /* start */ - arg_types[i++] = int32_type; /* fetch_count / count */ - arg_types[i++] = int32_type; /* stride */ - arg_types[i++] = get_vb_ptr_type(variant); /* pipe_vertex_buffer's */ - arg_types[i++] = int32_type; /* instance_id */ - arg_types[i++] = int32_type; /* vertex_id_offset */ - arg_types[i++] = int32_type; /* start_instance */ - - func_type = LLVMFunctionType(int32_type, arg_types, num_arg_types, 0); + arg_types[i++] = int32_type; /* count */ + arg_types[i++] = int32_type; /* start/fetch_elt_max */ + arg_types[i++] = int32_type; /* stride */ + arg_types[i++] = get_vb_ptr_type(variant); /* pipe_vertex_buffer's */ + arg_types[i++] = int32_type; /* instance_id */ + arg_types[i++] = int32_type; /* vertex_id_offset */ + arg_types[i++] = int32_type; /* start_instance */ + arg_types[i++] = LLVMPointerType(int32_type, 0); /* fetch_elts */ + + func_type = LLVMFunctionType(LLVMInt8TypeInContext(context), + arg_types, num_arg_types, 0); variant_func = LLVMAddFunction(gallivm->module, func_name, func_type); - - if (elts) - variant->function_elts = variant_func; - else - variant->function = variant_func; + variant->function = variant_func; LLVMSetFunctionCallConv(variant_func, LLVMCCallConv); for (i = 0; i < num_arg_types; ++i) if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) - LLVMAddAttribute(LLVMGetParam(variant_func, i), - LLVMNoAliasAttribute); + lp_add_function_attr(variant_func, i + 1, LP_FUNC_ATTR_NOALIAS); context_ptr = LLVMGetParam(variant_func, 0); io_ptr = LLVMGetParam(variant_func, 1); vbuffers_ptr = LLVMGetParam(variant_func, 2); - stride = LLVMGetParam(variant_func, 5 + (elts ? 1 : 0)); - vb_ptr = LLVMGetParam(variant_func, 6 + (elts ? 1 : 0)); - system_values.instance_id = LLVMGetParam(variant_func, 7 + (elts ? 1 : 0)); - vertex_id_offset = LLVMGetParam(variant_func, 8 + (elts ? 1 : 0)); - start_instance = LLVMGetParam(variant_func, 9 + (elts ? 1 : 0)); + count = LLVMGetParam(variant_func, 3); + /* + * XXX: the maxelt part is unused. Not really useful, since we cannot + * get index buffer overflows due to vsplit (which provides its own + * elts buffer, with a different size than what's passed in here). + */ + start_or_maxelt = LLVMGetParam(variant_func, 4); + /* + * XXX: stride is actually unused. The stride we use is strictly calculated + * from the number of outputs (including the draw_extra outputs). + * Should probably fix some day (we need a new vs just because of extra + * outputs which the generated vs won't touch). + */ + stride = LLVMGetParam(variant_func, 5); + vb_ptr = LLVMGetParam(variant_func, 6); + system_values.instance_id = LLVMGetParam(variant_func, 7); + vertex_id_offset = LLVMGetParam(variant_func, 8); + start_instance = LLVMGetParam(variant_func, 9); + fetch_elts = LLVMGetParam(variant_func, 10); lp_build_name(context_ptr, "context"); lp_build_name(io_ptr, "io"); lp_build_name(vbuffers_ptr, "vbuffers"); + lp_build_name(count, "count"); + lp_build_name(start_or_maxelt, "start_or_maxelt"); lp_build_name(stride, "stride"); lp_build_name(vb_ptr, "vb"); lp_build_name(system_values.instance_id, "instance_id"); lp_build_name(vertex_id_offset, "vertex_id_offset"); lp_build_name(start_instance, "start_instance"); - - if (elts) { - fetch_elts = LLVMGetParam(variant_func, 3); - fetch_elt_max = LLVMGetParam(variant_func, 4); - fetch_count = LLVMGetParam(variant_func, 5); - lp_build_name(fetch_elts, "fetch_elts"); - lp_build_name(fetch_elt_max, "fetch_elt_max"); - lp_build_name(fetch_count, "fetch_count"); - start = count = NULL; - } - else { - start = LLVMGetParam(variant_func, 3); - count = LLVMGetParam(variant_func, 4); - lp_build_name(start, "start"); - lp_build_name(count, "count"); - fetch_elts = fetch_count = NULL; - } + lp_build_name(fetch_elts, "fetch_elts"); /* * Function body @@ -1617,8 +1670,6 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, builder = gallivm->builder; LLVMPositionBuilderAtEnd(builder, block); - lp_build_context_init(&bld, gallivm, lp_type_int(32)); - memset(&vs_type, 0, sizeof vs_type); vs_type.floating = TRUE; /* floating point values */ vs_type.sign = TRUE; /* values are signed */ @@ -1626,34 +1677,143 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, vs_type.width = 32; /* 32-bit float */ vs_type.length = vector_length; + lp_build_context_init(&bld, gallivm, lp_type_uint(32)); + lp_build_context_init(&blduivec, gallivm, lp_uint_type(vs_type)); + /* hold temporary "bool" clipmask */ - clipmask_bool_ptr = lp_build_alloca(gallivm, lp_build_int_vec_type(gallivm, vs_type), ""); - LLVMBuildStore(builder, lp_build_zero(gallivm, lp_int_type(vs_type)), clipmask_bool_ptr); + clipmask_bool_ptr = lp_build_alloca(gallivm, blduivec.vec_type, ""); + + fake_buf = lp_build_alloca_undef(gallivm, + LLVMVectorType(LLVMInt64TypeInContext(context), 4), ""); + fake_buf = LLVMBuildBitCast(builder, fake_buf, + LLVMPointerType(LLVMInt8TypeInContext(context), 0), ""); + fake_buf_ptr = LLVMBuildGEP(builder, fake_buf, &bld.zero, 1, ""); /* code generated texture sampling */ sampler = draw_llvm_sampler_soa_create(draw_llvm_variant_key_samplers(key)); - if (elts) { - start = zero; - end = fetch_count; - count = fetch_count; - } - else { - end = lp_build_add(&bld, start, count); + step = lp_build_const_int32(gallivm, vector_length); + + ind_vec = blduivec.undef; + for (i = 0; i < vs_type.length; i++) { + LLVMValueRef index = lp_build_const_int32(gallivm, i); + ind_vec = LLVMBuildInsertElement(builder, ind_vec, index, index, ""); } - step = lp_build_const_int32(gallivm, vector_length); + have_elts = LLVMBuildICmp(builder, LLVMIntNE, + LLVMConstPointerNull(arg_types[10]), fetch_elts, ""); + + fetch_max = LLVMBuildSub(builder, count, bld.one, "fetch_max"); + fetch_max = lp_build_broadcast_scalar(&blduivec, fetch_max); + /* + * Only needed for non-indexed path. + */ + start_vec = lp_build_broadcast_scalar(&blduivec, start_or_maxelt); + + /* + * Pre-calculate everything which is constant per shader invocation. + */ + for (j = 0; j < key->nr_vertex_elements; ++j) { + LLVMValueRef vb_buffer_offset, buffer_size, temp_ptr; + LLVMValueRef vb_info, vbuffer_ptr, buf_offset, ofbit; + struct pipe_vertex_element *velem = &key->vertex_element[j]; + LLVMValueRef vb_index = + lp_build_const_int32(gallivm, velem->vertex_buffer_index); + LLVMValueRef bsize = lp_build_const_int32(gallivm, + util_format_get_blocksize(velem->src_format)); + LLVMValueRef src_offset = lp_build_const_int32(gallivm, + velem->src_offset); + struct lp_build_if_state if_ctx; + + if (velem->src_format != PIPE_FORMAT_NONE) { + vbuffer_ptr = LLVMBuildGEP(builder, vbuffers_ptr, &vb_index, 1, ""); + vb_info = LLVMBuildGEP(builder, vb_ptr, &vb_index, 1, ""); + vb_stride[j] = draw_jit_vbuffer_stride(gallivm, vb_info); + vb_stride[j] = LLVMBuildZExt(gallivm->builder, vb_stride[j], + LLVMInt32TypeInContext(context), ""); + vb_buffer_offset = draw_jit_vbuffer_offset(gallivm, vb_info); + map_ptr[j] = draw_jit_dvbuffer_map(gallivm, vbuffer_ptr); + buffer_size = draw_jit_dvbuffer_size(gallivm, vbuffer_ptr); + + ofbit = NULL; + /* + * We'll set buffer_size_adj to zero if we have of, so it will + * always overflow later automatically without having to keep ofbit. + * Overflows (with normal wraparound) doing the actual offset + * calculation should be ok, just not for the buffer size calc. + * It would also be possible to detect such overflows and return + * zeros if that happens, but this would be more complex. + */ + buf_offset = lp_build_add(&bld, vb_buffer_offset, src_offset); + tmp = lp_build_sub(&bld, bsize, bld.one); + buffer_size_adj[j] = lp_build_usub_overflow(gallivm, buffer_size, tmp, + &ofbit); + buffer_size_adj[j] = lp_build_usub_overflow(gallivm, buffer_size_adj[j], + buf_offset, &ofbit); + + /* + * We can't easily set fake vertex buffers outside the generated code. + * Hence, set fake vertex buffers here instead basically, so fetch + * code can always fetch using offset 0, eliminating all control flow + * inside the main loop. + * (Alternatively, could have control flow per vector skipping fetch + * if ofbit is true.) + */ + if (velem->instance_divisor) { + /* + * Index is equal to the start instance plus the number of current + * instance divided by the divisor. In this case we compute it as: + * index = start_instance + (instance_id / divisor). + * Note we could actually do the fetch here, outside the loop - + * it's all constant, hopefully llvm recognizes this. + */ + LLVMValueRef current_instance; + current_instance = LLVMBuildUDiv(builder, system_values.instance_id, + lp_build_const_int32(gallivm, + velem->instance_divisor), + "instance_divisor"); + instance_index[j] = lp_build_uadd_overflow(gallivm, start_instance, + current_instance, &ofbit); + } + + buffer_size_adj[j] = LLVMBuildSelect(builder, ofbit, bld.zero, + buffer_size_adj[j], ""); - fetch_max = LLVMBuildSub(builder, end, one, "fetch_max"); + temp_ptr = lp_build_alloca_undef(gallivm, + LLVMPointerType(LLVMInt8TypeInContext(context), 0), ""); + + lp_build_if(&if_ctx, gallivm, ofbit); + { + LLVMBuildStore(builder, fake_buf_ptr, temp_ptr); + } + lp_build_else(&if_ctx); + { + map_ptr[j] = LLVMBuildGEP(builder, map_ptr[j], &buf_offset, 1, ""); + LLVMBuildStore(builder, map_ptr[j], temp_ptr); + } + lp_build_endif(&if_ctx); + map_ptr[j] = LLVMBuildLoad(builder, temp_ptr, "map_ptr"); + + if (0) { + lp_build_printf(gallivm, "velem %d, vbuf index = %u, vb_stride = %u\n", + lp_build_const_int32(gallivm, j), + vb_index, vb_stride[j]); + lp_build_printf(gallivm, + " vb_buffer_offset = %u, src_offset = %u, buf_offset = %u\n", + vb_buffer_offset, src_offset, buf_offset); + lp_build_printf(gallivm, " buffer size = %u, blocksize = %u\n", + buffer_size, bsize); + lp_build_printf(gallivm, " instance_id = %u\n", system_values.instance_id); + } + } + } - lp_build_loop_begin(&lp_loop, gallivm, zero); + lp_build_loop_begin(&lp_loop, gallivm, bld.zero); { LLVMValueRef inputs[PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS]; - LLVMValueRef aos_attribs[PIPE_MAX_SHADER_INPUTS][LP_MAX_VECTOR_WIDTH / 32] = { { 0 } }; LLVMValueRef io; LLVMValueRef clipmask; /* holds the clipmask value */ - LLVMValueRef true_index_array = lp_build_zero(gallivm, - lp_type_uint_vec(32, 32*vector_length)); + LLVMValueRef true_index_array, index_store; const LLVMValueRef (*ptr_aos)[TGSI_NUM_CHANNELS]; io_itr = lp_loop.counter; @@ -1663,72 +1823,93 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, lp_build_printf(gallivm, " --- io %d = %p, loop counter %d\n", io_itr, io, lp_loop.counter); #endif - for (i = 0; i < vector_length; ++i) { - LLVMValueRef vert_index = - LLVMBuildAdd(builder, - lp_loop.counter, - lp_build_const_int32(gallivm, i), ""); - LLVMValueRef true_index = - LLVMBuildAdd(builder, start, vert_index, ""); - - /* make sure we're not out of bounds which can happen - * if fetch_count % 4 != 0, because on the last iteration - * a few of the 4 vertex fetches will be out of bounds */ - true_index = lp_build_min(&bld, true_index, fetch_max); - - if (elts) { - LLVMValueRef fetch_ptr; - LLVMValueRef index_overflowed; - LLVMValueRef index_ptr = - lp_build_alloca( - gallivm, - lp_build_vec_type(gallivm, lp_type_int(32)), ""); - struct lp_build_if_state if_ctx; - index_overflowed = LLVMBuildICmp(builder, LLVMIntUGT, - true_index, fetch_elt_max, - "index_overflowed"); - - lp_build_if(&if_ctx, gallivm, index_overflowed); - { - /* Generate maximum possible index so that - * generate_fetch can treat it just like - * any other overflow and return zeros. - * We don't have to worry about the restart - * primitive index because it has already been - * handled - */ - LLVMValueRef val = - lp_build_const_int32(gallivm, 0xffffffff); - LLVMBuildStore(builder, val, index_ptr); - } - lp_build_else(&if_ctx); - { - LLVMValueRef val; - fetch_ptr = LLVMBuildGEP(builder, fetch_elts, - &true_index, 1, ""); - val = LLVMBuildLoad(builder, fetch_ptr, ""); - LLVMBuildStore(builder, val, index_ptr); + + true_index_array = lp_build_broadcast_scalar(&blduivec, lp_loop.counter); + true_index_array = LLVMBuildAdd(builder, true_index_array, ind_vec, ""); + + LLVMValueRef exec_mask = lp_build_cmp(&blduivec, PIPE_FUNC_LEQUAL, true_index_array, fetch_max); + /* + * Limit indices to fetch_max, otherwise might try to access indices + * beyond index buffer (or rather vsplit elt buffer) size. + * Could probably safely (?) skip this for non-indexed draws and + * simplify things minimally (by removing it could combine the ind_vec + * and start_vec adds). I think the only effect for non-indexed draws will + * be that for the invalid elements they will be all fetched from the + * same location as the last valid one, but noone should really care. + */ + true_index_array = lp_build_min(&blduivec, true_index_array, fetch_max); + + index_store = lp_build_alloca_undef(gallivm, blduivec.vec_type, "index_store"); + + lp_build_if(&if_ctx, gallivm, have_elts); + { + /* + * Note: you'd expect some comparison/clamp against fetch_elt_max + * here. + * There used to be one here but it was incorrect: overflow was + * detected if index > fetch_elt_max - but the correct condition + * would be index >= fetch_elt_max (since this is just size of elts + * buffer / element size). + * Using the correct condition however will cause failures - due to + * vsplit/vcache code which rebases indices. So, as an example, if + * fetch_elt_max is just 1 and fetch_count 2, vsplit cache will + * replace all invalid indices with 0 - which in case of elt_bias + * not being zero will get a different fetch index than the valid + * index 0. So, just rely on vsplit code preventing out-of-bounds + * fetches. This is also why it's safe to do elts fetch even if there + * was no index buffer bound - the real buffer is never seen here, at + * least not if there are index buffer overflows... + */ + + /* + * XXX should not have to do this, as scale can be handled + * natively by loads (hits asserts though). + */ + tmp = lp_build_shl_imm(&blduivec, true_index_array, 2); + fetch_elts = LLVMBuildBitCast(builder, fetch_elts, + LLVMPointerType(LLVMInt8TypeInContext(context), + 0), ""); + tmp = lp_build_gather(gallivm, vs_type.length, + 32, bld.type, TRUE, + fetch_elts, tmp, FALSE); + LLVMBuildStore(builder, tmp, index_store); + } + lp_build_else(&if_ctx); + { + tmp = LLVMBuildAdd(builder, true_index_array, start_vec, ""); + LLVMBuildStore(builder, tmp, index_store); + } + lp_build_endif(&if_ctx); + + true_index_array = LLVMBuildLoad(builder, index_store, ""); + + for (j = 0; j < key->nr_vertex_elements; ++j) { + struct pipe_vertex_element *velem = &key->vertex_element[j]; + const struct util_format_description *format_desc = + util_format_description(velem->src_format); + + if (format_desc->format == PIPE_FORMAT_NONE) { + for (i = 0; i < TGSI_NUM_CHANNELS; i++) { + inputs[j][i] = lp_build_zero(gallivm, vs_type); } - lp_build_endif(&if_ctx); - true_index = LLVMBuildLoad(builder, index_ptr, "true_index"); } - true_index_array = LLVMBuildInsertElement( - gallivm->builder, true_index_array, true_index, - lp_build_const_int32(gallivm, i), ""); - - for (j = 0; j < draw->pt.nr_vertex_elements; ++j) { - struct pipe_vertex_element *velem = &draw->pt.vertex_element[j]; - LLVMValueRef vb_index = - lp_build_const_int32(gallivm, velem->vertex_buffer_index); - LLVMValueRef vb = LLVMBuildGEP(builder, vb_ptr, &vb_index, 1, ""); - generate_fetch(gallivm, draw, vbuffers_ptr, - &aos_attribs[j][i], velem, vb, true_index, - system_values.instance_id, start_instance); + else if (velem->instance_divisor) { + fetch_instanced(gallivm, format_desc, vs_type, + vb_stride[j], map_ptr[j], + buffer_size_adj[j], + inputs[j], instance_index[j]); + } + else { + fetch_vector(gallivm, format_desc, vs_type, + vb_stride[j], map_ptr[j], + buffer_size_adj[j], + inputs[j], true_index_array); } } - convert_to_soa(gallivm, aos_attribs, inputs, - draw->pt.nr_vertex_elements, vs_type); + struct lp_build_mask_context mask; + + lp_build_mask_begin(&mask, gallivm, vs_type, exec_mask); /* In the paths with elts vertex id has to be unaffected by the * index bias and because indices inside our elements array have * already had index bias applied we need to subtract it here to @@ -1740,9 +1921,8 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, * most 4095-vertices) we need to back out the original start * index out of our vertex id here. */ - system_values.basevertex = lp_build_broadcast(gallivm, lp_build_vec_type(gallivm, - lp_type_uint_vec(32, 32*vector_length)), - vertex_id_offset); + system_values.basevertex = lp_build_broadcast_scalar(&blduivec, + vertex_id_offset); system_values.vertex_id = true_index_array; system_values.vertex_id_nobase = LLVMBuildSub(builder, true_index_array, system_values.basevertex, ""); @@ -1756,12 +1936,13 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, &system_values, context_ptr, sampler, - key->clamp_vertex_color); + key->clamp_vertex_color, + &mask); + lp_build_mask_end(&mask); if (pos != -1 && cv != -1) { /* store original positions in clip before further manipulation */ - store_clip(gallivm, vs_type, io, outputs, FALSE, key->clip_user ? cv : pos); - store_clip(gallivm, vs_type, io, outputs, TRUE, pos); + store_clip(gallivm, vs_type, io, outputs, pos); /* do cliptest */ if (enable_cliptest) { @@ -1771,18 +1952,14 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, gallivm, vs_type, outputs, - key->clip_xy, - key->clip_z, - key->clip_user, - key->clip_halfz, - key->ucp_enable, + key, context_ptr, &have_clipdist); temp = LLVMBuildOr(builder, clipmask, temp, ""); /* store temporary clipping boolean value */ LLVMBuildStore(builder, temp, clipmask_bool_ptr); } else { - clipmask = lp_build_const_int_vec(gallivm, lp_int_type(vs_type), 0); + clipmask = blduivec.zero; } /* do viewport mapping */ @@ -1791,7 +1968,7 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, } } else { - clipmask = lp_build_const_int_vec(gallivm, lp_int_type(vs_type), 0); + clipmask = blduivec.zero; } /* store clipmask in vertex header, @@ -1800,14 +1977,15 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant, */ convert_to_aos(gallivm, io, NULL, outputs, clipmask, vs_info->num_outputs, vs_type, - have_clipdist); + enable_cliptest && key->need_edgeflags); } lp_build_loop_end_cond(&lp_loop, count, step, LLVMIntUGE); sampler->destroy(sampler); /* return clipping boolean value for function */ - ret = clipmask_booli32(gallivm, vs_type, clipmask_bool_ptr); + ret = clipmask_booli8(gallivm, vs_type, clipmask_bool_ptr, + enable_cliptest && key->need_edgeflags); LLVMBuildRet(builder, ret); @@ -1824,16 +2002,9 @@ draw_llvm_make_variant_key(struct draw_llvm *llvm, char *store) key = (struct draw_llvm_variant_key *)store; - key->clamp_vertex_color = llvm->draw->rasterizer->clamp_vertex_color; /**/ + memset(key, 0, offsetof(struct draw_llvm_variant_key, vertex_element[0])); - /* Presumably all variants of the shader should have the same - * number of vertex elements - ie the number of shader inputs. - * NOTE: we NEED to store the needed number of needed inputs - * here, not the number of provided elements to match keysize - * (and the offset of sampler state in the key). - */ - key->nr_vertex_elements = llvm->draw->vs.vertex_shader->info.file_max[TGSI_FILE_INPUT] + 1; - assert(key->nr_vertex_elements <= llvm->draw->pt.nr_vertex_elements); + key->clamp_vertex_color = llvm->draw->rasterizer->clamp_vertex_color; /**/ /* will have to rig this up properly later */ key->clip_xy = llvm->draw->clip_xy; @@ -1841,11 +2012,11 @@ draw_llvm_make_variant_key(struct draw_llvm *llvm, char *store) key->clip_user = llvm->draw->clip_user; key->bypass_viewport = llvm->draw->bypass_viewport; key->clip_halfz = llvm->draw->rasterizer->clip_halfz; + /* XXX assumes edgeflag output not at 0 */ key->need_edgeflags = (llvm->draw->vs.edgeflag_output ? TRUE : FALSE); key->ucp_enable = llvm->draw->rasterizer->clip_plane_enable; key->has_gs = llvm->draw->gs.geometry_shader != NULL; key->num_outputs = draw_total_vs_outputs(llvm->draw); - key->pad1 = 0; /* All variants of this shader will have the same value for * nr_samplers. Not yet trying to compact away holes in the @@ -1860,13 +2031,34 @@ draw_llvm_make_variant_key(struct draw_llvm *llvm, char *store) key->nr_sampler_views = key->nr_samplers; } - draw_sampler = draw_llvm_variant_key_samplers(key); - + /* Presumably all variants of the shader should have the same + * number of vertex elements - ie the number of shader inputs. + * NOTE: we NEED to store the needed number of needed inputs + * here, not the number of provided elements to match keysize + * (and the offset of sampler state in the key). + * If we have excess number of vertex elements, this is valid, + * but the excess ones don't matter. + * If we don't have enough vertex elements (which looks not really + * valid but we'll handle it gracefully) fill out missing ones with + * zero (we'll recognize these later by PIPE_FORMAT_NONE). + */ + key->nr_vertex_elements = + llvm->draw->vs.vertex_shader->info.file_max[TGSI_FILE_INPUT] + 1; + + if (llvm->draw->pt.nr_vertex_elements < key->nr_vertex_elements) { + debug_printf("draw: vs with %d inputs but only have %d vertex elements\n", + key->nr_vertex_elements, llvm->draw->pt.nr_vertex_elements); + memset(key->vertex_element, 0, + sizeof(struct pipe_vertex_element) * key->nr_vertex_elements); + } memcpy(key->vertex_element, llvm->draw->pt.vertex_element, - sizeof(struct pipe_vertex_element) * key->nr_vertex_elements); + sizeof(struct pipe_vertex_element) * + MIN2(key->nr_vertex_elements, llvm->draw->pt.nr_vertex_elements)); - memset(draw_sampler, 0, MAX2(key->nr_samplers, key->nr_sampler_views) * sizeof *draw_sampler); + draw_sampler = draw_llvm_variant_key_samplers(key); + memset(draw_sampler, 0, + MAX2(key->nr_samplers, key->nr_sampler_views) * sizeof *draw_sampler); for (i = 0 ; i < key->nr_samplers; i++) { lp_sampler_static_sampler_state(&draw_sampler[i].sampler_state, @@ -1912,7 +2104,7 @@ draw_llvm_dump_variant_key(struct draw_llvm_variant_key *key) void draw_llvm_set_mapped_texture(struct draw_context *draw, - unsigned shader_stage, + enum pipe_shader_type shader_stage, unsigned sview_idx, uint32_t width, uint32_t height, uint32_t depth, uint32_t first_level, uint32_t last_level, @@ -1928,11 +2120,11 @@ draw_llvm_set_mapped_texture(struct draw_context *draw, shader_stage == PIPE_SHADER_GEOMETRY); if (shader_stage == PIPE_SHADER_VERTEX) { - assert(sview_idx < Elements(draw->llvm->jit_context.textures)); + assert(sview_idx < ARRAY_SIZE(draw->llvm->jit_context.textures)); jit_tex = &draw->llvm->jit_context.textures[sview_idx]; } else if (shader_stage == PIPE_SHADER_GEOMETRY) { - assert(sview_idx < Elements(draw->llvm->gs_jit_context.textures)); + assert(sview_idx < ARRAY_SIZE(draw->llvm->gs_jit_context.textures)); jit_tex = &draw->llvm->gs_jit_context.textures[sview_idx]; } else { @@ -1957,7 +2149,7 @@ draw_llvm_set_mapped_texture(struct draw_context *draw, void draw_llvm_set_sampler_state(struct draw_context *draw, - unsigned shader_type) + enum pipe_shader_type shader_type) { unsigned i; @@ -1965,7 +2157,7 @@ draw_llvm_set_sampler_state(struct draw_context *draw, for (i = 0; i < draw->num_samplers[PIPE_SHADER_VERTEX]; i++) { struct draw_jit_sampler *jit_sam = &draw->llvm->jit_context.samplers[i]; - if (draw->samplers[i]) { + if (draw->samplers[PIPE_SHADER_VERTEX][i]) { const struct pipe_sampler_state *s = draw->samplers[PIPE_SHADER_VERTEX][i]; jit_sam->min_lod = s->min_lod; @@ -1978,7 +2170,7 @@ draw_llvm_set_sampler_state(struct draw_context *draw, for (i = 0; i < draw->num_samplers[PIPE_SHADER_GEOMETRY]; i++) { struct draw_jit_sampler *jit_sam = &draw->llvm->gs_jit_context.samplers[i]; - if (draw->samplers[i]) { + if (draw->samplers[PIPE_SHADER_GEOMETRY][i]) { const struct pipe_sampler_state *s = draw->samplers[PIPE_SHADER_GEOMETRY][i]; jit_sam->min_lod = s->min_lod; @@ -1996,6 +2188,11 @@ draw_llvm_destroy_variant(struct draw_llvm_variant *variant) { struct draw_llvm *llvm = variant->llvm; + if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) { + debug_printf("Deleting VS variant: %u vs variants,\t%u total variants\n", + variant->shader->variants_cached, llvm->nr_variants); + } + gallivm_destroy(variant->gallivm); remove_from_list(&variant->list_item_local); @@ -2065,7 +2262,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, struct gallivm_state *gallivm = variant->gallivm; LLVMContextRef context = gallivm->context; LLVMTypeRef int32_type = LLVMInt32TypeInContext(context); - LLVMTypeRef arg_types[6]; + LLVMTypeRef arg_types[7]; LLVMTypeRef func_type; LLVMValueRef variant_func; LLVMValueRef context_ptr; @@ -2082,6 +2279,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, struct draw_gs_llvm_iface gs_iface; const struct tgsi_token *tokens = variant->shader->base.state.tokens; LLVMValueRef consts_ptr, num_consts_ptr; + LLVMValueRef ssbos_ptr, num_ssbos_ptr; LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][TGSI_NUM_CHANNELS]; struct lp_build_mask_context mask; const struct tgsi_shader_info *gs_info = &variant->shader->base.info; @@ -2089,8 +2287,8 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, memset(&system_values, 0, sizeof(system_values)); - util_snprintf(func_name, sizeof(func_name), "draw_llvm_gs_variant%u", - variant->shader->variants_cached); + snprintf(func_name, sizeof(func_name), "draw_llvm_gs_variant%u", + variant->shader->variants_cached); assert(variant->vertex_header_ptr_type); @@ -2101,8 +2299,9 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, arg_types[4] = int32_type; /* instance_id */ arg_types[5] = LLVMPointerType( LLVMVectorType(int32_type, vector_length), 0); /* prim_id_ptr */ + arg_types[6] = int32_type; - func_type = LLVMFunctionType(int32_type, arg_types, Elements(arg_types), 0); + func_type = LLVMFunctionType(int32_type, arg_types, ARRAY_SIZE(arg_types), 0); variant_func = LLVMAddFunction(gallivm->module, func_name, func_type); @@ -2110,10 +2309,9 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, LLVMSetFunctionCallConv(variant_func, LLVMCCallConv); - for (i = 0; i < Elements(arg_types); ++i) + for (i = 0; i < ARRAY_SIZE(arg_types); ++i) if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) - LLVMAddAttribute(LLVMGetParam(variant_func, i), - LLVMNoAliasAttribute); + lp_add_function_attr(variant_func, i + 1, LP_FUNC_ATTR_NOALIAS); context_ptr = LLVMGetParam(variant_func, 0); input_array = LLVMGetParam(variant_func, 1); @@ -2121,6 +2319,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, num_prims = LLVMGetParam(variant_func, 3); system_values.instance_id = LLVMGetParam(variant_func, 4); prim_id_ptr = LLVMGetParam(variant_func, 5); + system_values.invocation_id = LLVMGetParam(variant_func, 6); lp_build_name(context_ptr, "context"); lp_build_name(input_array, "input"); @@ -2128,6 +2327,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, lp_build_name(num_prims, "num_prims"); lp_build_name(system_values.instance_id, "instance_id"); lp_build_name(prim_id_ptr, "prim_id_ptr"); + lp_build_name(system_values.invocation_id, "invocation_id"); variant->context_ptr = context_ptr; variant->io_ptr = io_ptr; @@ -2161,6 +2361,10 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, num_consts_ptr = draw_gs_jit_context_num_constants(variant->gallivm, context_ptr); + ssbos_ptr = draw_gs_jit_context_ssbos(variant->gallivm, context_ptr); + num_ssbos_ptr = + draw_gs_jit_context_num_ssbos(variant->gallivm, context_ptr); + /* code generated texture sampling */ sampler = draw_llvm_sampler_soa_create(variant->key.samplers); @@ -2176,19 +2380,25 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, draw_gs_llvm_dump_variant_key(&variant->key); } + struct lp_build_tgsi_params params; + memset(¶ms, 0, sizeof(params)); + + params.type = gs_type; + params.mask = &mask; + params.consts_ptr = consts_ptr; + params.const_sizes_ptr = num_consts_ptr; + params.system_values = &system_values; + params.context_ptr = context_ptr; + params.sampler = sampler; + params.info = &llvm->draw->gs.geometry_shader->info; + params.gs_iface = (const struct lp_build_tgsi_gs_iface *)&gs_iface; + params.ssbo_ptr = ssbos_ptr; + params.ssbo_sizes_ptr = num_ssbos_ptr; + lp_build_tgsi_soa(variant->gallivm, tokens, - gs_type, - &mask, - consts_ptr, - num_consts_ptr, - &system_values, - NULL, - outputs, - context_ptr, - sampler, - &llvm->draw->gs.geometry_shader->info, - (const struct lp_build_tgsi_gs_iface *)&gs_iface); + ¶ms, + outputs); sampler->destroy(sampler); @@ -2214,14 +2424,14 @@ draw_gs_llvm_create_variant(struct draw_llvm *llvm, variant = MALLOC(sizeof *variant + shader->variant_key_size - sizeof variant->key); - if (variant == NULL) + if (!variant) return NULL; variant->llvm = llvm; variant->shader = shader; - util_snprintf(module_name, sizeof(module_name), "draw_llvm_gs_variant%u", - variant->shader->variants_cached); + snprintf(module_name, sizeof(module_name), "draw_llvm_gs_variant%u", + variant->shader->variants_cached); variant->gallivm = gallivm_create(module_name, llvm->context); @@ -2255,6 +2465,11 @@ draw_gs_llvm_destroy_variant(struct draw_gs_llvm_variant *variant) { struct draw_llvm *llvm = variant->llvm; + if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) { + debug_printf("Deleting GS variant: %u gs variants,\t%u total variants\n", + variant->shader->variants_cached, llvm->nr_gs_variants); + } + gallivm_destroy(variant->gallivm); remove_from_list(&variant->list_item_local); @@ -2273,6 +2488,8 @@ draw_gs_llvm_make_variant_key(struct draw_llvm *llvm, char *store) key = (struct draw_gs_llvm_variant_key *)store; + memset(key, 0, offsetof(struct draw_gs_llvm_variant_key, samplers[0])); + key->num_outputs = draw_total_gs_outputs(llvm->draw); /* All variants of this shader will have the same value for