diff options
Diffstat (limited to 'lib/mesa/src/gallium/auxiliary/draw')
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_context.c | 134 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_context.h | 28 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_gs_tmp.h | 1 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_llvm.c | 1399 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_llvm.h | 302 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_pipe_user_cull.c | 197 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_pipe_validate.c | 11 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_private.h | 41 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_pt.c | 21 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c | 264 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_tess.c | 644 | ||||
| -rw-r--r-- | lib/mesa/src/gallium/auxiliary/draw/draw_tess.h | 130 |
12 files changed, 63 insertions, 3109 deletions
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_context.c b/lib/mesa/src/gallium/auxiliary/draw/draw_context.c index 3b2b2d030..fb0b22eae 100644 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_context.c +++ b/lib/mesa/src/gallium/auxiliary/draw/draw_context.c @@ -44,7 +44,6 @@ #include "draw_prim_assembler.h" #include "draw_vs.h" #include "draw_gs.h" -#include "draw_tess.h" #ifdef LLVM_AVAILABLE #include "gallivm/lp_bld_init.h" @@ -455,9 +454,7 @@ draw_set_mapped_constant_buffer(struct draw_context *draw, unsigned size ) { debug_assert(shader_type == PIPE_SHADER_VERTEX || - shader_type == PIPE_SHADER_GEOMETRY || - shader_type == PIPE_SHADER_TESS_CTRL || - shader_type == PIPE_SHADER_TESS_EVAL); + shader_type == PIPE_SHADER_GEOMETRY); debug_assert(slot < PIPE_MAX_CONSTANT_BUFFERS); draw_do_flush(draw, DRAW_FLUSH_PARAMETER_CHANGE); @@ -471,14 +468,6 @@ draw_set_mapped_constant_buffer(struct draw_context *draw, draw->pt.user.gs_constants[slot] = buffer; draw->pt.user.gs_constants_size[slot] = size; break; - case PIPE_SHADER_TESS_CTRL: - draw->pt.user.tcs_constants[slot] = buffer; - draw->pt.user.tcs_constants_size[slot] = size; - break; - case PIPE_SHADER_TESS_EVAL: - draw->pt.user.tes_constants[slot] = buffer; - draw->pt.user.tes_constants_size[slot] = size; - break; default: assert(0 && "invalid shader type in draw_set_mapped_constant_buffer"); } @@ -492,9 +481,7 @@ draw_set_mapped_shader_buffer(struct draw_context *draw, unsigned size ) { debug_assert(shader_type == PIPE_SHADER_VERTEX || - shader_type == PIPE_SHADER_GEOMETRY || - shader_type == PIPE_SHADER_TESS_CTRL || - shader_type == PIPE_SHADER_TESS_EVAL); + shader_type == PIPE_SHADER_GEOMETRY); debug_assert(slot < PIPE_MAX_SHADER_BUFFERS); draw_do_flush(draw, DRAW_FLUSH_PARAMETER_CHANGE); @@ -508,14 +495,6 @@ draw_set_mapped_shader_buffer(struct draw_context *draw, draw->pt.user.gs_ssbos[slot] = buffer; draw->pt.user.gs_ssbos_size[slot] = size; break; - case PIPE_SHADER_TESS_CTRL: - draw->pt.user.tcs_ssbos[slot] = buffer; - draw->pt.user.tcs_ssbos_size[slot] = size; - break; - case PIPE_SHADER_TESS_EVAL: - draw->pt.user.tes_ssbos[slot] = buffer; - draw->pt.user.tes_ssbos_size[slot] = size; - break; default: assert(0 && "invalid shader type in draw_set_mapped_shader_buffer"); } @@ -643,8 +622,6 @@ draw_get_shader_info(const struct draw_context *draw) if (draw->gs.geometry_shader) { return &draw->gs.geometry_shader->info; - } else if (draw->tes.tess_eval_shader) { - return &draw->tes.tess_eval_shader->info; } else { return &draw->vs.vertex_shader->info; } @@ -769,37 +746,6 @@ draw_total_gs_outputs(const struct draw_context *draw) return info->num_outputs + draw->extra_shader_outputs.num; } -/** - * Return total number of the tess ctrl shader outputs. - */ -uint -draw_total_tcs_outputs(const struct draw_context *draw) -{ - const struct tgsi_shader_info *info; - - if (!draw->tcs.tess_ctrl_shader) - return 0; - - info = &draw->tcs.tess_ctrl_shader->info; - - return info->num_outputs; -} - -/** - * Return total number of the tess eval shader outputs. - */ -uint -draw_total_tes_outputs(const struct draw_context *draw) -{ - const struct tgsi_shader_info *info; - - if (!draw->tes.tess_eval_shader) - return 0; - - info = &draw->tes.tess_eval_shader->info; - - return info->num_outputs + draw->extra_shader_outputs.num; -} /** * Provide TGSI sampler objects for vertex/geometry shaders that use @@ -811,22 +757,11 @@ draw_texture_sampler(struct draw_context *draw, enum pipe_shader_type shader, struct tgsi_sampler *sampler) { - switch (shader) { - case PIPE_SHADER_VERTEX: + if (shader == PIPE_SHADER_VERTEX) { draw->vs.tgsi.sampler = sampler; - break; - case PIPE_SHADER_GEOMETRY: + } else { + debug_assert(shader == PIPE_SHADER_GEOMETRY); draw->gs.tgsi.sampler = sampler; - break; - case PIPE_SHADER_TESS_CTRL: - draw->tcs.tgsi.sampler = sampler; - break; - case PIPE_SHADER_TESS_EVAL: - draw->tes.tgsi.sampler = sampler; - break; - default: - assert(0); - break; } } @@ -840,22 +775,11 @@ draw_image(struct draw_context *draw, enum pipe_shader_type shader, struct tgsi_image *image) { - switch (shader) { - case PIPE_SHADER_VERTEX: + if (shader == PIPE_SHADER_VERTEX) { draw->vs.tgsi.image = image; - break; - case PIPE_SHADER_GEOMETRY: + } else { + debug_assert(shader == PIPE_SHADER_GEOMETRY); draw->gs.tgsi.image = image; - break; - case PIPE_SHADER_TESS_CTRL: - draw->tcs.tgsi.image = image; - break; - case PIPE_SHADER_TESS_EVAL: - draw->tes.tgsi.image = image; - break; - default: - assert(0); - break; } } @@ -869,22 +793,11 @@ draw_buffer(struct draw_context *draw, enum pipe_shader_type shader, struct tgsi_buffer *buffer) { - switch (shader) { - case PIPE_SHADER_VERTEX: + if (shader == PIPE_SHADER_VERTEX) { draw->vs.tgsi.buffer = buffer; - break; - case PIPE_SHADER_GEOMETRY: + } else { + debug_assert(shader == PIPE_SHADER_GEOMETRY); draw->gs.tgsi.buffer = buffer; - break; - case PIPE_SHADER_TESS_CTRL: - draw->tcs.tgsi.buffer = buffer; - break; - case PIPE_SHADER_TESS_EVAL: - draw->tes.tgsi.buffer = buffer; - break; - default: - assert(0); - break; } } @@ -961,8 +874,6 @@ draw_current_shader_position_output(const struct draw_context *draw) { if (draw->gs.geometry_shader) return draw->gs.position_output; - if (draw->tes.tess_eval_shader) - return draw->tes.position_output; return draw->vs.position_output; } @@ -976,8 +887,6 @@ draw_current_shader_viewport_index_output(const struct draw_context *draw) { if (draw->gs.geometry_shader) return draw->gs.geometry_shader->viewport_index_output; - else if (draw->tes.tess_eval_shader) - return draw->tes.tess_eval_shader->viewport_index_output; return draw->vs.vertex_shader->viewport_index_output; } @@ -1005,8 +914,6 @@ draw_current_shader_clipvertex_output(const struct draw_context *draw) { if (draw->gs.geometry_shader) return draw->gs.position_output; - if (draw->tes.tess_eval_shader) - return draw->tes.position_output; return draw->vs.clipvertex_output; } @@ -1016,8 +923,6 @@ draw_current_shader_ccdistance_output(const struct draw_context *draw, int index debug_assert(index < PIPE_MAX_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT); if (draw->gs.geometry_shader) return draw->gs.geometry_shader->ccdistance_output[index]; - if (draw->tes.tess_eval_shader) - return draw->tes.tess_eval_shader->ccdistance_output[index]; return draw->vs.ccdistance_output[index]; } @@ -1027,8 +932,6 @@ draw_current_shader_num_written_clipdistances(const struct draw_context *draw) { if (draw->gs.geometry_shader) return draw->gs.geometry_shader->info.num_written_clipdistance; - if (draw->tes.tess_eval_shader) - return draw->tes.tess_eval_shader->info.num_written_clipdistance; return draw->vs.vertex_shader->info.num_written_clipdistance; } @@ -1037,8 +940,6 @@ draw_current_shader_num_written_culldistances(const struct draw_context *draw) { if (draw->gs.geometry_shader) return draw->gs.geometry_shader->info.num_written_culldistance; - if (draw->tes.tess_eval_shader) - return draw->tes.tess_eval_shader->info.num_written_culldistance; return draw->vs.vertex_shader->info.num_written_culldistance; } @@ -1236,8 +1137,6 @@ draw_get_shader_param(enum pipe_shader_type shader, enum pipe_shader_cap param) switch(shader) { case PIPE_SHADER_VERTEX: case PIPE_SHADER_GEOMETRY: - case PIPE_SHADER_TESS_CTRL: - case PIPE_SHADER_TESS_EVAL: return gallivm_get_shader_param(param); default: return 0; @@ -1320,14 +1219,3 @@ draw_will_inject_frontface(const struct draw_context *draw) (rast->fill_front != PIPE_POLYGON_MODE_FILL || rast->fill_back != PIPE_POLYGON_MODE_FILL)); } - -void -draw_set_tess_state(struct draw_context *draw, - const float default_outer_level[4], - const float default_inner_level[2]) -{ - for (unsigned i = 0; i < 4; i++) - draw->default_outer_tess_level[i] = default_outer_level[i]; - for (unsigned i = 0; i < 2; i++) - draw->default_inner_tess_level[i] = default_inner_level[i]; -} diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_context.h b/lib/mesa/src/gallium/auxiliary/draw/draw_context.h index 659b81fd0..c58c12cc4 100644 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_context.h +++ b/lib/mesa/src/gallium/auxiliary/draw/draw_context.h @@ -45,8 +45,6 @@ struct draw_context; struct draw_stage; struct draw_vertex_shader; struct draw_geometry_shader; -struct draw_tess_ctrl_shader; -struct draw_tess_eval_shader; struct draw_fragment_shader; struct tgsi_sampler; struct tgsi_image; @@ -154,12 +152,6 @@ draw_total_vs_outputs(const struct draw_context *draw); uint draw_total_gs_outputs(const struct draw_context *draw); -uint -draw_total_tcs_outputs(const struct draw_context *draw); - -uint -draw_total_tes_outputs(const struct draw_context *draw); - void draw_texture_sampler(struct draw_context *draw, enum pipe_shader_type shader_type, @@ -250,26 +242,6 @@ void draw_bind_geometry_shader(struct draw_context *draw, void draw_delete_geometry_shader(struct draw_context *draw, struct draw_geometry_shader *dvs); -/* - * Tess shader functions - */ -struct draw_tess_ctrl_shader * -draw_create_tess_ctrl_shader(struct draw_context *draw, - const struct pipe_shader_state *shader); -void draw_bind_tess_ctrl_shader(struct draw_context *draw, - struct draw_tess_ctrl_shader *dvs); -void draw_delete_tess_ctrl_shader(struct draw_context *draw, - struct draw_tess_ctrl_shader *dvs); -struct draw_tess_eval_shader * -draw_create_tess_eval_shader(struct draw_context *draw, - const struct pipe_shader_state *shader); -void draw_bind_tess_eval_shader(struct draw_context *draw, - struct draw_tess_eval_shader *dvs); -void draw_delete_tess_eval_shader(struct draw_context *draw, - struct draw_tess_eval_shader *dvs); -void draw_set_tess_state(struct draw_context *draw, - const float default_outer_level[4], - const float default_inner_level[2]); /* * Vertex data functions diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_gs_tmp.h b/lib/mesa/src/gallium/auxiliary/draw/draw_gs_tmp.h index 5a5b9e22a..bf276d382 100644 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_gs_tmp.h +++ b/lib/mesa/src/gallium/auxiliary/draw/draw_gs_tmp.h @@ -12,6 +12,7 @@ const boolean quads_flatshade_last = FALSE; \ const boolean last_vertex_last = !gs->draw->rasterizer->flatshade_first; \ do { \ + debug_assert(input_prims->primitive_count == 1); \ switch (prim) { \ case PIPE_PRIM_QUADS: \ case PIPE_PRIM_QUAD_STRIP: \ diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.c b/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.c index 2fdbd5571..ca5cd6a37 100644 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.c +++ b/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.c @@ -37,7 +37,6 @@ #include "gallivm/lp_bld_gather.h" #include "gallivm/lp_bld_logic.h" #include "gallivm/lp_bld_const.h" -#include "gallivm/lp_bld_coro.h" #include "gallivm/lp_bld_swizzle.h" #include "gallivm/lp_bld_struct.h" #include "gallivm/lp_bld_type.h" @@ -81,33 +80,6 @@ draw_gs_llvm_iface(const struct lp_build_gs_iface *iface) return (const struct draw_gs_llvm_iface *)iface; } -struct draw_tcs_llvm_iface { - struct lp_build_tcs_iface base; - - struct draw_tcs_llvm_variant *variant; - LLVMValueRef input; - LLVMValueRef output; -}; - -static inline const struct draw_tcs_llvm_iface * -draw_tcs_llvm_iface(const struct lp_build_tcs_iface *iface) -{ - return (const struct draw_tcs_llvm_iface *)iface; -} - -struct draw_tes_llvm_iface { - struct lp_build_tes_iface base; - - struct draw_tes_llvm_variant *variant; - LLVMValueRef input; -}; - -static inline const struct draw_tes_llvm_iface * -draw_tes_llvm_iface(const struct lp_build_tes_iface *iface) -{ - return (const struct draw_tes_llvm_iface *)iface; -} - /** * Create LLVM type for draw_vertex_buffer. */ @@ -525,166 +497,6 @@ create_jit_vertex_header(struct gallivm_state *gallivm, int data_elems) return vertex_header; } -/** - * Create LLVM type for struct draw_tcs_jit_context - */ -static LLVMTypeRef -create_tcs_jit_context_type(struct gallivm_state *gallivm, - unsigned vector_length, - LLVMTypeRef texture_type, LLVMTypeRef sampler_type, - LLVMTypeRef image_type, - const char *struct_name) -{ - LLVMTargetDataRef target = gallivm->target; - LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context); - LLVMTypeRef int_type = LLVMInt32TypeInContext(gallivm->context); - LLVMTypeRef elem_types[DRAW_TCS_JIT_CTX_NUM_FIELDS]; - LLVMTypeRef context_type; - - elem_types[0] = LLVMArrayType(LLVMPointerType(float_type, 0), /* constants */ - LP_MAX_TGSI_CONST_BUFFERS); - elem_types[1] = LLVMArrayType(int_type, /* num_constants */ - LP_MAX_TGSI_CONST_BUFFERS); - elem_types[2] = LLVMInt32TypeInContext(gallivm->context); - elem_types[3] = LLVMInt32TypeInContext(gallivm->context); - - elem_types[4] = LLVMArrayType(texture_type, - PIPE_MAX_SHADER_SAMPLER_VIEWS); /* textures */ - elem_types[5] = LLVMArrayType(sampler_type, - PIPE_MAX_SAMPLERS); /* samplers */ - elem_types[6] = LLVMArrayType(image_type, - PIPE_MAX_SHADER_IMAGES); /* images */ - - elem_types[7] = LLVMArrayType(LLVMPointerType(int_type, 0), /* ssbos */ - LP_MAX_TGSI_SHADER_BUFFERS); - elem_types[8] = LLVMArrayType(int_type, /* num_ssbos */ - LP_MAX_TGSI_SHADER_BUFFERS); - - context_type = LLVMStructTypeInContext(gallivm->context, elem_types, - ARRAY_SIZE(elem_types), 0); - - (void) target; /* silence unused var warning for non-debug build */ - LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, constants, - target, context_type, DRAW_TCS_JIT_CTX_CONSTANTS); - LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, num_constants, - target, context_type, DRAW_TCS_JIT_CTX_NUM_CONSTANTS); - LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, textures, - target, context_type, - DRAW_TCS_JIT_CTX_TEXTURES); - LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, samplers, - target, context_type, - DRAW_TCS_JIT_CTX_SAMPLERS); - LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, ssbos, - target, context_type, DRAW_TCS_JIT_CTX_SSBOS); - LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, num_ssbos, - target, context_type, DRAW_TCS_JIT_CTX_NUM_SSBOS); - LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, images, - target, context_type, DRAW_TCS_JIT_CTX_IMAGES); - LP_CHECK_STRUCT_SIZE(struct draw_tcs_jit_context, - target, context_type); - - return context_type; -} - -static LLVMTypeRef -create_tcs_jit_input_type(struct gallivm_state *gallivm) -{ - LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context); - LLVMTypeRef input_array; - - input_array = LLVMArrayType(float_type, TGSI_NUM_CHANNELS); /* num channels */ - input_array = LLVMArrayType(input_array, NUM_TCS_INPUTS); /* num attrs per vertex */ - input_array = LLVMPointerType(input_array, 0); /* num vertices per prim */ - - return input_array; -} - -static LLVMTypeRef -create_tcs_jit_output_type(struct gallivm_state *gallivm) -{ - LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context); - LLVMTypeRef output_array; - - output_array = LLVMArrayType(float_type, TGSI_NUM_CHANNELS); /* num channels */ - output_array = LLVMArrayType(output_array, PIPE_MAX_SHADER_INPUTS); /* num attrs per vertex */ - output_array = LLVMPointerType(output_array, 0); /* num vertices per prim */ - - return output_array; -} - -static LLVMTypeRef -create_tes_jit_input_type(struct gallivm_state *gallivm) -{ - LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context); - LLVMTypeRef input_array; - - input_array = LLVMArrayType(float_type, TGSI_NUM_CHANNELS); /* num channels */ - input_array = LLVMArrayType(input_array, PIPE_MAX_SHADER_INPUTS); /* num attrs per vertex */ - input_array = LLVMPointerType(input_array, 0); /* num vertices per prim */ - - return input_array; -} - -/** - * Create LLVM type for struct draw_tes_jit_context - */ -static LLVMTypeRef -create_tes_jit_context_type(struct gallivm_state *gallivm, - unsigned vector_length, - LLVMTypeRef texture_type, LLVMTypeRef sampler_type, - LLVMTypeRef image_type, - const char *struct_name) -{ - LLVMTargetDataRef target = gallivm->target; - LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context); - LLVMTypeRef int_type = LLVMInt32TypeInContext(gallivm->context); - LLVMTypeRef elem_types[DRAW_TCS_JIT_CTX_NUM_FIELDS]; - LLVMTypeRef context_type; - - elem_types[0] = LLVMArrayType(LLVMPointerType(float_type, 0), /* constants */ - LP_MAX_TGSI_CONST_BUFFERS); - elem_types[1] = LLVMArrayType(int_type, /* num_constants */ - LP_MAX_TGSI_CONST_BUFFERS); - elem_types[2] = LLVMInt32TypeInContext(gallivm->context); - elem_types[3] = LLVMInt32TypeInContext(gallivm->context); - - elem_types[4] = LLVMArrayType(texture_type, - PIPE_MAX_SHADER_SAMPLER_VIEWS); /* textures */ - elem_types[5] = LLVMArrayType(sampler_type, - PIPE_MAX_SAMPLERS); /* samplers */ - elem_types[6] = LLVMArrayType(image_type, - PIPE_MAX_SHADER_IMAGES); /* images */ - - elem_types[7] = LLVMArrayType(LLVMPointerType(int_type, 0), /* ssbos */ - LP_MAX_TGSI_SHADER_BUFFERS); - elem_types[8] = LLVMArrayType(int_type, /* num_ssbos */ - LP_MAX_TGSI_SHADER_BUFFERS); - - context_type = LLVMStructTypeInContext(gallivm->context, elem_types, - ARRAY_SIZE(elem_types), 0); - - (void) target; /* silence unused var warning for non-debug build */ - LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, constants, - target, context_type, DRAW_TCS_JIT_CTX_CONSTANTS); - LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, num_constants, - target, context_type, DRAW_TCS_JIT_CTX_NUM_CONSTANTS); - LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, textures, - target, context_type, - DRAW_TCS_JIT_CTX_TEXTURES); - LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, samplers, - target, context_type, - DRAW_TCS_JIT_CTX_SAMPLERS); - LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, ssbos, - target, context_type, DRAW_TCS_JIT_CTX_SSBOS); - LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, num_ssbos, - target, context_type, DRAW_TCS_JIT_CTX_NUM_SSBOS); - LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, images, - target, context_type, DRAW_TCS_JIT_CTX_IMAGES); - LP_CHECK_STRUCT_SIZE(struct draw_tes_jit_context, - target, context_type); - - return context_type; -} /** * Create LLVM types for various structures. @@ -779,12 +591,6 @@ draw_llvm_create(struct draw_context *draw, LLVMContextRef context) llvm->nr_gs_variants = 0; make_empty_list(&llvm->gs_variants_list); - llvm->nr_tcs_variants = 0; - make_empty_list(&llvm->tcs_variants_list); - - llvm->nr_tes_variants = 0; - make_empty_list(&llvm->tes_variants_list); - return llvm; fail: @@ -1070,7 +876,7 @@ fetch_vector(struct gallivm_state *gallivm, } /* out-of-bound fetches return all zeros */ - for (i = 0; i < format_desc->nr_channels; i++) { + 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], @@ -1123,8 +929,8 @@ store_aos(struct gallivm_state *gallivm, * { * return (x >> 16) | // vertex_id * ((x & 0x3fff) << 18) | // clipmask - * ((x & 0x4000) << 3) | // edgeflag - * ((x & 0x8000) << 1); // pad + * ((x & 0x4000) << 3) | // pad + * ((x & 0x8000) << 1); // edgeflag * } */ static LLVMValueRef @@ -1142,11 +948,11 @@ adjust_mask(struct gallivm_state *gallivm, clipmask = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x3fff), ""); clipmask = LLVMBuildShl(builder, clipmask, lp_build_const_int32(gallivm, 18), ""); if (0) { - pad = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x8000), ""); - pad = LLVMBuildShl(builder, pad, lp_build_const_int32(gallivm, 1), ""); + 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, 0x4000), ""); - edgeflag = LLVMBuildShl(builder, edgeflag, 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, ""); if (0) { @@ -1751,17 +1557,10 @@ draw_gs_llvm_emit_vertex(const struct lp_build_gs_iface *gs_base, indices[i] = LLVMBuildAdd(builder, indices[i], currently_emitted, ""); } - LLVMValueRef stream_idx = LLVMBuildExtractElement(builder, stream_id, lp_build_const_int32(gallivm, 0), ""); - LLVMValueRef cnd = LLVMBuildICmp(builder, LLVMIntULT, stream_idx, lp_build_const_int32(gallivm, variant->shader->base.num_vertex_streams), ""); - struct lp_build_if_state if_ctx; - lp_build_if(&if_ctx, gallivm, cnd); - io = lp_build_pointer_get(builder, io, LLVMBuildExtractElement(builder, stream_id, lp_build_const_int32(gallivm, 0), "")); - convert_to_aos(gallivm, io, indices, outputs, clipmask, gs_info->num_outputs, gs_type, FALSE); - lp_build_endif(&if_ctx); } static void @@ -1798,7 +1597,7 @@ draw_gs_llvm_end_primitive(const struct lp_build_gs_iface *gs_base, static void draw_gs_llvm_epilogue(const struct lp_build_gs_iface *gs_base, LLVMValueRef total_emitted_vertices_vec, - LLVMValueRef emitted_prims_vec, unsigned stream) + LLVMValueRef emitted_prims_vec) { const struct draw_gs_llvm_iface *gs_iface = draw_gs_llvm_iface(gs_base); struct draw_gs_llvm_variant *variant = gs_iface->variant; @@ -1808,10 +1607,10 @@ draw_gs_llvm_epilogue(const struct lp_build_gs_iface *gs_base, draw_gs_jit_emitted_vertices(gallivm, variant->context_ptr); LLVMValueRef emitted_prims_ptr = draw_gs_jit_emitted_prims(gallivm, variant->context_ptr); - LLVMValueRef stream_val = lp_build_const_int32(gallivm, stream); + LLVMValueRef zero = lp_build_const_int32(gallivm, 0); - emitted_verts_ptr = LLVMBuildGEP(builder, emitted_verts_ptr, &stream_val, 1, ""); - emitted_prims_ptr = LLVMBuildGEP(builder, emitted_prims_ptr, &stream_val, 1, ""); + emitted_verts_ptr = LLVMBuildGEP(builder, emitted_verts_ptr, &zero, 0, ""); + emitted_prims_ptr = LLVMBuildGEP(builder, emitted_prims_ptr, &zero, 0, ""); LLVMBuildStore(builder, total_emitted_vertices_vec, emitted_verts_ptr); LLVMBuildStore(builder, emitted_prims_vec, emitted_prims_ptr); @@ -1861,9 +1660,9 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant) * (though this would be fixable here, but couldn't just broadcast * the values). */ - const boolean bypass_viewport = key->has_gs_or_tes || key->bypass_viewport || + const boolean bypass_viewport = key->has_gs || key->bypass_viewport || vs_info->writes_viewport_index; - const boolean enable_cliptest = !key->has_gs_or_tes && (key->clip_xy || + const boolean enable_cliptest = !key->has_gs && (key->clip_xy || key->clip_z || key->clip_user || key->need_edgeflags); @@ -2299,7 +2098,7 @@ draw_llvm_make_variant_key(struct draw_llvm *llvm, char *store) /* 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_or_tes = llvm->draw->gs.geometry_shader != NULL || llvm->draw->tes.tess_eval_shader != NULL; + key->has_gs = llvm->draw->gs.geometry_shader != NULL; key->num_outputs = draw_total_vs_outputs(llvm->draw); /* All variants of this shader will have the same value for @@ -2379,7 +2178,7 @@ draw_llvm_dump_variant_key(struct draw_llvm_variant_key *key) debug_printf("bypass_viewport = %u\n", key->bypass_viewport); debug_printf("clip_halfz = %u\n", key->clip_halfz); debug_printf("need_edgeflags = %u\n", key->need_edgeflags); - debug_printf("has_gs_or_tes = %u\n", key->has_gs_or_tes); + debug_printf("has_gs = %u\n", key->has_gs); debug_printf("ucp_enable = %u\n", key->ucp_enable); for (i = 0 ; i < key->nr_vertex_elements; i++) { @@ -2412,24 +2211,18 @@ draw_llvm_set_mapped_texture(struct draw_context *draw, unsigned j; struct draw_jit_texture *jit_tex; - switch (shader_stage) { - case PIPE_SHADER_VERTEX: + assert(shader_stage == PIPE_SHADER_VERTEX || + shader_stage == PIPE_SHADER_GEOMETRY); + + if (shader_stage == PIPE_SHADER_VERTEX) { assert(sview_idx < ARRAY_SIZE(draw->llvm->jit_context.textures)); + jit_tex = &draw->llvm->jit_context.textures[sview_idx]; - break; - case PIPE_SHADER_GEOMETRY: + } else if (shader_stage == PIPE_SHADER_GEOMETRY) { assert(sview_idx < ARRAY_SIZE(draw->llvm->gs_jit_context.textures)); + jit_tex = &draw->llvm->gs_jit_context.textures[sview_idx]; - break; - case PIPE_SHADER_TESS_CTRL: - assert(sview_idx < ARRAY_SIZE(draw->llvm->tcs_jit_context.textures)); - jit_tex = &draw->llvm->tcs_jit_context.textures[sview_idx]; - break; - case PIPE_SHADER_TESS_EVAL: - assert(sview_idx < ARRAY_SIZE(draw->llvm->tes_jit_context.textures)); - jit_tex = &draw->llvm->tes_jit_context.textures[sview_idx]; - break; - default: + } else { assert(0); return; } @@ -2459,24 +2252,18 @@ draw_llvm_set_mapped_image(struct draw_context *draw, { struct draw_jit_image *jit_image; - switch (shader_stage) { - case PIPE_SHADER_VERTEX: + assert(shader_stage == PIPE_SHADER_VERTEX || + shader_stage == PIPE_SHADER_GEOMETRY); + + if (shader_stage == PIPE_SHADER_VERTEX) { assert(idx < ARRAY_SIZE(draw->llvm->jit_context.images)); + jit_image = &draw->llvm->jit_context.images[idx]; - break; - case PIPE_SHADER_GEOMETRY: + } else if (shader_stage == PIPE_SHADER_GEOMETRY) { assert(idx < ARRAY_SIZE(draw->llvm->gs_jit_context.images)); + jit_image = &draw->llvm->gs_jit_context.images[idx]; - break; - case PIPE_SHADER_TESS_CTRL: - assert(idx < ARRAY_SIZE(draw->llvm->tcs_jit_context.images)); - jit_image = &draw->llvm->tcs_jit_context.images[idx]; - break; - case PIPE_SHADER_TESS_EVAL: - assert(idx < ARRAY_SIZE(draw->llvm->tes_jit_context.images)); - jit_image = &draw->llvm->tes_jit_context.images[idx]; - break; - default: + } else { assert(0); return; } @@ -2497,8 +2284,7 @@ draw_llvm_set_sampler_state(struct draw_context *draw, { unsigned i; - switch (shader_type) { - case PIPE_SHADER_VERTEX: + if (shader_type == PIPE_SHADER_VERTEX) { for (i = 0; i < draw->num_samplers[PIPE_SHADER_VERTEX]; i++) { struct draw_jit_sampler *jit_sam = &draw->llvm->jit_context.samplers[i]; @@ -2511,8 +2297,7 @@ draw_llvm_set_sampler_state(struct draw_context *draw, COPY_4V(jit_sam->border_color, s->border_color.f); } } - break; - case PIPE_SHADER_GEOMETRY: + } else if (shader_type == PIPE_SHADER_GEOMETRY) { for (i = 0; i < draw->num_samplers[PIPE_SHADER_GEOMETRY]; i++) { struct draw_jit_sampler *jit_sam = &draw->llvm->gs_jit_context.samplers[i]; @@ -2525,38 +2310,6 @@ draw_llvm_set_sampler_state(struct draw_context *draw, COPY_4V(jit_sam->border_color, s->border_color.f); } } - break; - case PIPE_SHADER_TESS_CTRL: - for (i = 0; i < draw->num_samplers[PIPE_SHADER_TESS_CTRL]; i++) { - struct draw_jit_sampler *jit_sam = &draw->llvm->tcs_jit_context.samplers[i]; - - if (draw->samplers[PIPE_SHADER_TESS_CTRL][i]) { - const struct pipe_sampler_state *s - = draw->samplers[PIPE_SHADER_TESS_CTRL][i]; - jit_sam->min_lod = s->min_lod; - jit_sam->max_lod = s->max_lod; - jit_sam->lod_bias = s->lod_bias; - COPY_4V(jit_sam->border_color, s->border_color.f); - } - } - break; - case PIPE_SHADER_TESS_EVAL: - for (i = 0; i < draw->num_samplers[PIPE_SHADER_TESS_EVAL]; i++) { - struct draw_jit_sampler *jit_sam = &draw->llvm->tes_jit_context.samplers[i]; - - if (draw->samplers[PIPE_SHADER_TESS_EVAL][i]) { - const struct pipe_sampler_state *s - = draw->samplers[PIPE_SHADER_TESS_EVAL][i]; - jit_sam->min_lod = s->min_lod; - jit_sam->max_lod = s->max_lod; - jit_sam->lod_bias = s->lod_bias; - COPY_4V(jit_sam->border_color, s->border_color.f); - } - } - break; - default: - assert(0); - break; } } @@ -2676,7 +2429,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm, arg_types[0] = get_gs_context_ptr_type(variant); /* context */ arg_types[1] = variant->input_array_type; /* input */ - arg_types[2] = LLVMPointerType(variant->vertex_header_ptr_type, 0); /* vertex_header */ + arg_types[2] = variant->vertex_header_ptr_type; /* vertex_header */ arg_types[3] = int32_type; /* num_prims */ arg_types[4] = int32_type; /* instance_id */ arg_types[5] = LLVMPointerType( @@ -2939,1087 +2692,3 @@ draw_gs_llvm_dump_variant_key(struct draw_gs_llvm_variant_key *key) debug_printf("images[%i].format = %s\n", i, util_format_name(image[i].image_state.format)); } - -static void -create_tcs_jit_types(struct draw_tcs_llvm_variant *var) -{ - struct gallivm_state *gallivm = var->gallivm; - LLVMTypeRef texture_type, sampler_type, image_type, context_type; - - texture_type = create_jit_texture_type(gallivm, "texture"); - sampler_type = create_jit_sampler_type(gallivm, "sampler"); - image_type = create_jit_image_type(gallivm, "image"); - - context_type = create_tcs_jit_context_type(gallivm, - 0, - texture_type, sampler_type, - image_type, - "draw_tcs_jit_context"); - var->input_array_type = create_tcs_jit_input_type(gallivm); - var->output_array_type = create_tcs_jit_output_type(gallivm); - var->context_ptr_type = LLVMPointerType(context_type, 0); -} - -static LLVMTypeRef -get_tcs_context_ptr_type(struct draw_tcs_llvm_variant *variant) -{ - if (!variant->context_ptr_type) - create_tcs_jit_types(variant); - return variant->context_ptr_type; -} - -static LLVMValueRef -draw_tcs_llvm_emit_fetch_input(const struct lp_build_tcs_iface *tes_iface, - struct lp_build_context *bld, - boolean is_vindex_indirect, - LLVMValueRef vertex_index, - boolean is_aindex_indirect, - LLVMValueRef attrib_index, - LLVMValueRef swizzle_index) -{ - const struct draw_tcs_llvm_iface *tcs = draw_tcs_llvm_iface(tes_iface); - struct gallivm_state *gallivm = bld->gallivm; - LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef indices[3]; - LLVMValueRef res; - struct lp_type type = bld->type; - - if (is_vindex_indirect || is_aindex_indirect) { - int i; - - res = bld->zero; - for (i = 0; i < type.length; ++i) { - LLVMValueRef idx = lp_build_const_int32(gallivm, i); - LLVMValueRef vert_chan_index = vertex_index; - LLVMValueRef attr_chan_index = attrib_index; - LLVMValueRef channel_vec; - - if (is_vindex_indirect) { - vert_chan_index = LLVMBuildExtractElement(builder, - vertex_index, idx, ""); - } - if (is_aindex_indirect) { - attr_chan_index = LLVMBuildExtractElement(builder, - attrib_index, idx, ""); - } - - indices[0] = vert_chan_index; - indices[1] = attr_chan_index; - indices[2] = swizzle_index; - - channel_vec = LLVMBuildGEP(builder, tcs->input, indices, 3, ""); - channel_vec = LLVMBuildLoad(builder, channel_vec, ""); - - res = LLVMBuildInsertElement(builder, res, channel_vec, idx, ""); - } - } else { - indices[0] = vertex_index; - indices[1] = attrib_index; - indices[2] = swizzle_index; - - res = LLVMBuildGEP(builder, tcs->input, indices, 3, ""); - res = LLVMBuildLoad(builder, res, ""); - res = lp_build_broadcast_scalar(bld, res); - } - return res; -} - -static LLVMValueRef -draw_tcs_llvm_emit_fetch_output(const struct lp_build_tcs_iface *tes_iface, - struct lp_build_context *bld, - boolean is_vindex_indirect, - LLVMValueRef vertex_index, - boolean is_aindex_indirect, - LLVMValueRef attrib_index, - LLVMValueRef swizzle_index, - uint32_t name) -{ - const struct draw_tcs_llvm_iface *tcs = draw_tcs_llvm_iface(tes_iface); - struct gallivm_state *gallivm = bld->gallivm; - LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef indices[3]; - LLVMValueRef res; - struct lp_type type = bld->type; - - if (is_vindex_indirect || is_aindex_indirect) { - int i; - - res = bld->zero; - for (i = 0; i < type.length; ++i) { - LLVMValueRef idx = lp_build_const_int32(gallivm, i); - LLVMValueRef vert_chan_index = vertex_index; - LLVMValueRef attr_chan_index = attrib_index; - LLVMValueRef channel_vec; - - if (is_vindex_indirect) { - vert_chan_index = LLVMBuildExtractElement(builder, - vertex_index, idx, ""); - } - if (is_aindex_indirect) { - attr_chan_index = LLVMBuildExtractElement(builder, - attrib_index, idx, ""); - } - - indices[0] = vert_chan_index; - indices[1] = attr_chan_index; - indices[2] = swizzle_index; - - channel_vec = LLVMBuildGEP(builder, tcs->output, indices, 3, ""); - channel_vec = LLVMBuildLoad(builder, channel_vec, ""); - - res = LLVMBuildInsertElement(builder, res, channel_vec, idx, ""); - } - } else { - indices[0] = vertex_index ? vertex_index : lp_build_const_int32(gallivm, 0); - indices[1] = attrib_index; - indices[2] = swizzle_index; - - res = LLVMBuildGEP(builder, tcs->output, indices, 3, ""); - res = LLVMBuildLoad(builder, res, ""); - res = lp_build_broadcast_scalar(bld, res); - } - return res; -} - -static void -draw_tcs_llvm_emit_store_output(const struct lp_build_tcs_iface *tes_iface, - struct lp_build_context *bld, - unsigned name, - boolean is_vindex_indirect, - LLVMValueRef vertex_index, - boolean is_aindex_indirect, - LLVMValueRef attrib_index, - LLVMValueRef swizzle_index, - LLVMValueRef value, - LLVMValueRef mask_vec) -{ - const struct draw_tcs_llvm_iface *tcs = draw_tcs_llvm_iface(tes_iface); - struct gallivm_state *gallivm = bld->gallivm; - LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef indices[3]; - LLVMValueRef res; - struct lp_type type = bld->type; - - if (is_vindex_indirect || is_aindex_indirect) { - int i; - - for (i = 0; i < type.length; ++i) { - LLVMValueRef idx = lp_build_const_int32(gallivm, i); - LLVMValueRef vert_chan_index = vertex_index ? vertex_index : lp_build_const_int32(gallivm, 0); - LLVMValueRef attr_chan_index = attrib_index; - LLVMValueRef channel_vec; - - if (is_vindex_indirect) { - vert_chan_index = LLVMBuildExtractElement(builder, - vertex_index, idx, ""); - } - if (is_aindex_indirect) { - attr_chan_index = LLVMBuildExtractElement(builder, - attrib_index, idx, ""); - } - - indices[0] = vert_chan_index; - indices[1] = attr_chan_index; - indices[2] = swizzle_index; - - channel_vec = LLVMBuildGEP(builder, tcs->output, indices, 3, ""); - - res = LLVMBuildExtractElement(builder, value, idx, ""); - - struct lp_build_if_state ifthen; - LLVMValueRef cond = LLVMBuildICmp(gallivm->builder, LLVMIntNE, mask_vec, lp_build_const_int_vec(gallivm, bld->type, 0), ""); - cond = LLVMBuildExtractElement(gallivm->builder, cond, idx, ""); - lp_build_if(&ifthen, gallivm, cond); - LLVMBuildStore(builder, res, channel_vec); - lp_build_endif(&ifthen); - } - } else { - indices[0] = vertex_index ? vertex_index : lp_build_const_int32(gallivm, 0); - indices[1] = attrib_index; - indices[2] = swizzle_index; - - res = LLVMBuildGEP(builder, tcs->output, indices, 3, ""); - for (unsigned i = 0; i < type.length; ++i) { - LLVMValueRef idx = lp_build_const_int32(gallivm, i); - LLVMValueRef val = LLVMBuildExtractElement(builder, value, idx, ""); - - struct lp_build_if_state ifthen; - LLVMValueRef cond = LLVMBuildICmp(gallivm->builder, LLVMIntNE, mask_vec, lp_build_const_int_vec(gallivm, bld->type, 0), ""); - cond = LLVMBuildExtractElement(gallivm->builder, cond, idx, ""); - lp_build_if(&ifthen, gallivm, cond); - LLVMBuildStore(builder, val, res); - lp_build_endif(&ifthen); - } - } -} - - -static LLVMValueRef -generate_tcs_mask_value(struct draw_tcs_llvm_variant *variant, - struct lp_type tcs_type, LLVMValueRef limit, LLVMValueRef loop_counter) -{ - struct gallivm_state *gallivm = variant->gallivm; - LLVMBuilderRef builder = gallivm->builder; - struct lp_type mask_type = lp_int_type(tcs_type); - LLVMValueRef num_vecs; - LLVMValueRef mask_val = lp_build_const_vec(gallivm, mask_type, 0); - unsigned i; - - num_vecs = lp_build_broadcast(gallivm, lp_build_vec_type(gallivm, mask_type), limit); - for (i = 0; i < tcs_type.length; i++) { - LLVMValueRef idx = lp_build_const_int32(gallivm, i); - mask_val = LLVMBuildInsertElement(builder, mask_val, LLVMBuildAdd(builder, loop_counter, idx, ""), idx, ""); - } - mask_val = lp_build_compare(gallivm, mask_type, - PIPE_FUNC_GREATER, num_vecs, mask_val); - - return mask_val; -} - -static void -draw_tcs_llvm_generate(struct draw_llvm *llvm, - struct draw_tcs_llvm_variant *variant) -{ - struct gallivm_state *gallivm = variant->gallivm; - LLVMContextRef context = gallivm->context; - LLVMTypeRef int32_type = LLVMInt32TypeInContext(context); - LLVMTypeRef arg_types[6]; - LLVMTypeRef func_type, coro_func_type; - LLVMValueRef variant_func, variant_coro; - LLVMValueRef context_ptr; - LLVMValueRef input_array, output_array, prim_id, patch_vertices_in; - LLVMValueRef mask_val; - LLVMBasicBlockRef block; - LLVMBuilderRef builder; - struct lp_build_context bld, bldvec; - struct lp_build_sampler_soa *sampler = 0; - struct lp_build_image_soa *image = NULL; - struct lp_bld_tgsi_system_values system_values; - char func_name[64], func_name_coro[64]; - unsigned i; - struct draw_tcs_llvm_iface tcs_iface; - struct lp_build_mask_context mask; - LLVMValueRef consts_ptr, num_consts_ptr; - LLVMValueRef ssbos_ptr, num_ssbos_ptr; - struct lp_type tcs_type; - unsigned vector_length = variant->shader->base.vector_length; - - memset(&system_values, 0, sizeof(system_values)); - - snprintf(func_name, sizeof(func_name), "draw_llvm_tcs_variant%u", - variant->shader->variants_cached); - - snprintf(func_name_coro, sizeof(func_name_coro), "draw_llvm_tcs_coro_variant%u", - variant->shader->variants_cached); - - arg_types[0] = get_tcs_context_ptr_type(variant); /* context */ - arg_types[1] = variant->input_array_type; /* input */ - arg_types[2] = variant->output_array_type; - arg_types[3] = int32_type; - arg_types[4] = int32_type; - arg_types[5] = int32_type; /* coroutine only */ - - func_type = LLVMFunctionType(int32_type, arg_types, ARRAY_SIZE(arg_types) - 1, 0); - - coro_func_type = LLVMFunctionType(LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0), arg_types, ARRAY_SIZE(arg_types), 0); - - variant_func = LLVMAddFunction(gallivm->module, func_name, func_type); - - variant_coro = LLVMAddFunction(gallivm->module, func_name_coro, coro_func_type); - - variant->function = variant_func; - LLVMSetFunctionCallConv(variant_func, LLVMCCallConv); - - LLVMSetFunctionCallConv(variant_coro, LLVMCCallConv); - - for (i = 0; i < ARRAY_SIZE(arg_types); ++i) { - if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) { - lp_add_function_attr(variant_coro, i + 1, LP_FUNC_ATTR_NOALIAS); - lp_add_function_attr(variant_func, i + 1, LP_FUNC_ATTR_NOALIAS); - } - } - - context_ptr = LLVMGetParam(variant_func, 0); - input_array = LLVMGetParam(variant_func, 1); - output_array = LLVMGetParam(variant_func, 2); - prim_id = LLVMGetParam(variant_func, 3); - patch_vertices_in = LLVMGetParam(variant_func, 4); - - lp_build_name(context_ptr, "context"); - lp_build_name(input_array, "input"); - lp_build_name(output_array, "output"); - lp_build_name(prim_id, "prim_id"); - lp_build_name(patch_vertices_in, "patch_vertices_in"); - - block = LLVMAppendBasicBlockInContext(gallivm->context, variant_func, "entry"); - builder = gallivm->builder; - LLVMPositionBuilderAtEnd(builder, block); - - lp_build_context_init(&bld, gallivm, lp_type_int(32)); - - memset(&tcs_type, 0, sizeof tcs_type); - tcs_type.floating = TRUE; /* floating point values */ - tcs_type.sign = TRUE; /* values are signed */ - tcs_type.norm = FALSE; /* values are not limited to [0,1] or [-1,1] */ - tcs_type.width = 32; /* 32-bit float */ - tcs_type.length = vector_length; - - lp_build_context_init(&bldvec, variant->gallivm, lp_int_type(tcs_type)); - - LLVMValueRef count = lp_build_const_int32(gallivm, variant->shader->base.vertices_out); - LLVMValueRef step = lp_build_const_int32(gallivm, vector_length); - - struct lp_build_loop_state loop_state[2]; - LLVMValueRef num_inner_loop; - unsigned count_align = util_align_npot(variant->shader->base.vertices_out, tcs_type.length); - num_inner_loop = lp_build_const_int32(gallivm, count_align / tcs_type.length); - LLVMTypeRef hdl_ptr_type = LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0); - LLVMValueRef coro_hdls = LLVMBuildArrayAlloca(gallivm->builder, hdl_ptr_type, num_inner_loop, "coro_hdls"); - unsigned end_coroutine = INT_MAX; - lp_build_loop_begin(&loop_state[1], gallivm, - lp_build_const_int32(gallivm, 0)); /* coroutine reentry loop */ - lp_build_loop_begin(&loop_state[0], gallivm, - lp_build_const_int32(gallivm, 0)); /* inner loop */ - { - LLVMValueRef args[6]; - args[0] = context_ptr; - args[1] = input_array; - args[2] = output_array; - args[3] = prim_id; - args[4] = patch_vertices_in; - args[5] = loop_state[0].counter; - LLVMValueRef coro_entry = LLVMBuildGEP(builder, coro_hdls, &loop_state[0].counter, 1, ""); - LLVMValueRef coro_hdl = LLVMBuildLoad(builder, coro_entry, "coro_hdl"); - - struct lp_build_if_state ifstate; - LLVMValueRef cmp = LLVMBuildICmp(builder, LLVMIntEQ, loop_state[1].counter, - lp_build_const_int32(gallivm, 0), ""); - /* first time here - call the coroutine function entry point */ - lp_build_if(&ifstate, gallivm, cmp); - LLVMValueRef coro_ret = LLVMBuildCall(builder, variant_coro, args, 6, ""); - LLVMBuildStore(builder, coro_ret, coro_entry); - lp_build_else(&ifstate); - /* subsequent calls for this invocation - check if done. */ - LLVMValueRef coro_done = lp_build_coro_done(gallivm, coro_hdl); - struct lp_build_if_state ifstate2; - lp_build_if(&ifstate2, gallivm, coro_done); - /* if done destroy and force loop exit */ - lp_build_coro_destroy(gallivm, coro_hdl); - lp_build_loop_force_set_counter(&loop_state[1], lp_build_const_int32(gallivm, end_coroutine - 1)); - lp_build_else(&ifstate2); - /* otherwise resume the coroutine */ - lp_build_coro_resume(gallivm, coro_hdl); - lp_build_endif(&ifstate2); - lp_build_endif(&ifstate); - lp_build_loop_force_reload_counter(&loop_state[1]); - } - lp_build_loop_end_cond(&loop_state[0], - num_inner_loop, - NULL, LLVMIntUGE); - lp_build_loop_end_cond(&loop_state[1], - lp_build_const_int32(gallivm, end_coroutine), - NULL, LLVMIntEQ); - LLVMBuildRet(builder, lp_build_zero(gallivm, lp_type_uint(32))); - - block = LLVMAppendBasicBlockInContext(gallivm->context, variant_coro, "entry"); - LLVMPositionBuilderAtEnd(builder, block); - - context_ptr = LLVMGetParam(variant_coro, 0); - input_array = LLVMGetParam(variant_coro, 1); - output_array = LLVMGetParam(variant_coro, 2); - prim_id = LLVMGetParam(variant_coro, 3); - patch_vertices_in = LLVMGetParam(variant_coro, 4); - - consts_ptr = draw_tcs_jit_context_constants(variant->gallivm, context_ptr); - num_consts_ptr = - draw_tcs_jit_context_num_constants(variant->gallivm, context_ptr); - - ssbos_ptr = draw_tcs_jit_context_ssbos(variant->gallivm, context_ptr); - num_ssbos_ptr = - draw_tcs_jit_context_num_ssbos(variant->gallivm, context_ptr); - sampler = draw_llvm_sampler_soa_create(variant->key.samplers); - image = draw_llvm_image_soa_create(draw_tcs_llvm_variant_key_images(&variant->key)); - - LLVMValueRef counter = LLVMGetParam(variant_coro, 5); - LLVMValueRef invocvec = LLVMGetUndef(LLVMVectorType(int32_type, vector_length)); - for (i = 0; i < vector_length; i++) { - LLVMValueRef idx = LLVMBuildAdd(builder, LLVMBuildMul(builder, counter, step, ""), lp_build_const_int32(gallivm, i), ""); - invocvec = LLVMBuildInsertElement(builder, invocvec, idx, idx, ""); - } - - system_values.invocation_id = invocvec; - system_values.prim_id = lp_build_broadcast_scalar(&bldvec, prim_id); - system_values.vertices_in = lp_build_broadcast_scalar(&bldvec, patch_vertices_in); - tcs_iface.input = input_array; - tcs_iface.output = output_array; - tcs_iface.base.emit_fetch_input = draw_tcs_llvm_emit_fetch_input; - tcs_iface.base.emit_fetch_output = draw_tcs_llvm_emit_fetch_output; - tcs_iface.base.emit_store_output = draw_tcs_llvm_emit_store_output; - - - { - LLVMValueRef coro_id = lp_build_coro_id(gallivm); - LLVMValueRef coro_hdl = lp_build_coro_begin_alloc_mem(gallivm, coro_id); - - mask_val = generate_tcs_mask_value(variant, tcs_type, count, LLVMBuildMul(builder, counter, step, "")); - lp_build_mask_begin(&mask, gallivm, tcs_type, mask_val); - - struct lp_build_coro_suspend_info coro_info; - - LLVMBasicBlockRef sus_block = LLVMAppendBasicBlockInContext(gallivm->context, variant_coro, "suspend"); - LLVMBasicBlockRef clean_block = LLVMAppendBasicBlockInContext(gallivm->context, variant_coro, "cleanup"); - - coro_info.suspend = sus_block; - coro_info.cleanup = clean_block; - - struct lp_build_tgsi_params params; - memset(¶ms, 0, sizeof(params)); - - params.type = tcs_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->tcs.tess_ctrl_shader->info; - params.ssbo_ptr = ssbos_ptr; - params.ssbo_sizes_ptr = num_ssbos_ptr; - params.image = image; - params.coro = &coro_info; - params.tcs_iface = &tcs_iface.base; - - lp_build_nir_soa(variant->gallivm, - llvm->draw->tcs.tess_ctrl_shader->state.ir.nir, - ¶ms, NULL); - - lp_build_mask_end(&mask); - - lp_build_coro_suspend_switch(gallivm, &coro_info, NULL, true); - LLVMPositionBuilderAtEnd(builder, clean_block); - - lp_build_coro_free_mem(gallivm, coro_id, coro_hdl); - - LLVMBuildBr(builder, sus_block); - LLVMPositionBuilderAtEnd(builder, sus_block); - - lp_build_coro_end(gallivm, coro_hdl); - LLVMBuildRet(builder, coro_hdl); - } - - sampler->destroy(sampler); - image->destroy(image); - gallivm_verify_function(gallivm, variant_func); - gallivm_verify_function(gallivm, variant_coro); -} - -struct draw_tcs_llvm_variant * -draw_tcs_llvm_create_variant(struct draw_llvm *llvm, - unsigned num_outputs, - const struct draw_tcs_llvm_variant_key *key) -{ - struct draw_tcs_llvm_variant *variant; - struct llvm_tess_ctrl_shader *shader = llvm_tess_ctrl_shader(llvm->draw->tcs.tess_ctrl_shader); - char module_name[64]; - - variant = MALLOC(sizeof *variant + - shader->variant_key_size - sizeof variant->key); - if (!variant) - return NULL; - - variant->llvm = llvm; - variant->shader = shader; - - snprintf(module_name, sizeof(module_name), "draw_llvm_tcs_variant%u", - variant->shader->variants_cached); - - variant->gallivm = gallivm_create(module_name, llvm->context); - - create_tcs_jit_types(variant); - - memcpy(&variant->key, key, shader->variant_key_size); - - if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) { - nir_print_shader(llvm->draw->tcs.tess_ctrl_shader->state.ir.nir, stderr); - draw_tcs_llvm_dump_variant_key(&variant->key); - } - - draw_tcs_llvm_generate(llvm, variant); - - gallivm_compile_module(variant->gallivm); - - variant->jit_func = (draw_tcs_jit_func) - gallivm_jit_function(variant->gallivm, variant->function); - - gallivm_free_ir(variant->gallivm); - - variant->list_item_global.base = variant; - variant->list_item_local.base = variant; - /*variant->no = */shader->variants_created++; - variant->list_item_global.base = variant; - - return variant; -} - -void -draw_tcs_llvm_destroy_variant(struct draw_tcs_llvm_variant *variant) -{ - struct draw_llvm *llvm = variant->llvm; - - if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) { - debug_printf("Deleting TCS variant: %u tcs variants,\t%u total variants\n", - variant->shader->variants_cached, llvm->nr_tcs_variants); - } - - gallivm_destroy(variant->gallivm); - - remove_from_list(&variant->list_item_local); - variant->shader->variants_cached--; - remove_from_list(&variant->list_item_global); - llvm->nr_tcs_variants--; - FREE(variant); -} - -struct draw_tcs_llvm_variant_key * -draw_tcs_llvm_make_variant_key(struct draw_llvm *llvm, char *store) -{ - unsigned i; - struct draw_tcs_llvm_variant_key *key; - struct draw_sampler_static_state *draw_sampler; - struct draw_image_static_state *draw_image; - - key = (struct draw_tcs_llvm_variant_key *)store; - - memset(key, 0, offsetof(struct draw_tcs_llvm_variant_key, samplers[0])); - - /* All variants of this shader will have the same value for - * nr_samplers. Not yet trying to compact away holes in the - * sampler array. - */ - key->nr_samplers = llvm->draw->tcs.tess_ctrl_shader->info.file_max[TGSI_FILE_SAMPLER] + 1; - if (llvm->draw->tcs.tess_ctrl_shader->info.file_max[TGSI_FILE_SAMPLER_VIEW] != -1) { - key->nr_sampler_views = - llvm->draw->tcs.tess_ctrl_shader->info.file_max[TGSI_FILE_SAMPLER_VIEW] + 1; - } - else { - key->nr_sampler_views = key->nr_samplers; - } - - key->nr_images = llvm->draw->tcs.tess_ctrl_shader->info.file_max[TGSI_FILE_IMAGE] + 1; - - draw_sampler = key->samplers; - - 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, - llvm->draw->samplers[PIPE_SHADER_TESS_CTRL][i]); - } - for (i = 0 ; i < key->nr_sampler_views; i++) { - lp_sampler_static_texture_state(&draw_sampler[i].texture_state, - llvm->draw->sampler_views[PIPE_SHADER_TESS_CTRL][i]); - } - - draw_image = draw_tcs_llvm_variant_key_images(key); - memset(draw_image, 0, - key->nr_images * sizeof *draw_image); - for (i = 0; i < key->nr_images; i++) { - lp_sampler_static_texture_state_image(&draw_image[i].image_state, - llvm->draw->images[PIPE_SHADER_TESS_CTRL][i]); - } - return key; -} - -void -draw_tcs_llvm_dump_variant_key(struct draw_tcs_llvm_variant_key *key) -{ - unsigned i; - struct draw_sampler_static_state *sampler = key->samplers; - struct draw_image_static_state *image = draw_tcs_llvm_variant_key_images(key); - for (i = 0 ; i < key->nr_sampler_views; i++) { - debug_printf("sampler[%i].src_format = %s\n", i, - util_format_name(sampler[i].texture_state.format)); - } - - for (i = 0 ; i < key->nr_images; i++) - debug_printf("images[%i].format = %s\n", i, util_format_name(image[i].image_state.format)); - -} - -static void -create_tes_jit_types(struct draw_tes_llvm_variant *var) -{ - struct gallivm_state *gallivm = var->gallivm; - LLVMTypeRef texture_type, sampler_type, image_type, context_type; - - texture_type = create_jit_texture_type(gallivm, "texture"); - sampler_type = create_jit_sampler_type(gallivm, "sampler"); - image_type = create_jit_image_type(gallivm, "image"); - - context_type = create_tes_jit_context_type(gallivm, - 0, - texture_type, sampler_type, - image_type, - "draw_tes_jit_context"); - var->context_ptr_type = LLVMPointerType(context_type, 0); - - var->input_array_type = create_tes_jit_input_type(gallivm); -} - -static LLVMTypeRef -get_tes_context_ptr_type(struct draw_tes_llvm_variant *variant) -{ - if (!variant->context_ptr_type) - create_tes_jit_types(variant); - return variant->context_ptr_type; -} - -static LLVMValueRef -generate_tes_mask_value(struct draw_tes_llvm_variant *variant, - struct lp_type tes_type, LLVMValueRef limit, LLVMValueRef loop_counter) -{ - struct gallivm_state *gallivm = variant->gallivm; - LLVMBuilderRef builder = gallivm->builder; - struct lp_type mask_type = lp_int_type(tes_type); - LLVMValueRef num_prims; - LLVMValueRef mask_val = lp_build_const_vec(gallivm, mask_type, 0); - unsigned i; - - num_prims = lp_build_broadcast(gallivm, lp_build_vec_type(gallivm, mask_type), limit); - for (i = 0; i < tes_type.length; i++) { - LLVMValueRef idx = lp_build_const_int32(gallivm, i); - mask_val = LLVMBuildInsertElement(builder, mask_val, LLVMBuildAdd(builder, loop_counter, idx, ""), idx, ""); - } - mask_val = lp_build_compare(gallivm, mask_type, - PIPE_FUNC_GREATER, num_prims, mask_val); - - return mask_val; -} - -static LLVMValueRef -draw_tes_llvm_fetch_vertex_input(const struct lp_build_tes_iface *tes_iface, - struct lp_build_context *bld, - boolean is_vindex_indirect, - LLVMValueRef vertex_index, - boolean is_aindex_indirect, - LLVMValueRef attrib_index, - LLVMValueRef swizzle_index) -{ - const struct draw_tes_llvm_iface *tes = draw_tes_llvm_iface(tes_iface); - struct gallivm_state *gallivm = bld->gallivm; - LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef indices[3]; - LLVMValueRef res; - struct lp_type type = bld->type; - - if (is_vindex_indirect || is_aindex_indirect) { - int i; - - res = bld->zero; - - for (i = 0; i < type.length; ++i) { - LLVMValueRef idx = lp_build_const_int32(gallivm, i); - LLVMValueRef vert_chan_index = vertex_index; - LLVMValueRef attr_chan_index = attrib_index; - LLVMValueRef channel_vec; - - if (is_vindex_indirect) { - vert_chan_index = LLVMBuildExtractElement(builder, - vertex_index, idx, ""); - } - if (is_aindex_indirect) { - attr_chan_index = LLVMBuildExtractElement(builder, - attrib_index, idx, ""); - } - - indices[0] = vert_chan_index; - indices[1] = attr_chan_index; - indices[2] = swizzle_index; - - channel_vec = LLVMBuildGEP(builder, tes->input, indices, 3, ""); - channel_vec = LLVMBuildLoad(builder, channel_vec, ""); - - res = LLVMBuildInsertElement(builder, res, channel_vec, idx, ""); - } - } else { - indices[0] = vertex_index; - indices[1] = attrib_index; - indices[2] = swizzle_index; - - res = LLVMBuildGEP(builder, tes->input, indices, 3, ""); - res = LLVMBuildLoad(builder, res, ""); - res = lp_build_broadcast_scalar(bld, res); - } - return res; -} - -static LLVMValueRef -draw_tes_llvm_fetch_patch_input(const struct lp_build_tes_iface *tes_iface, - struct lp_build_context *bld, - boolean is_aindex_indirect, - LLVMValueRef attrib_index, - LLVMValueRef swizzle_index) -{ - const struct draw_tes_llvm_iface *tes = draw_tes_llvm_iface(tes_iface); - struct gallivm_state *gallivm = bld->gallivm; - LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef indices[3]; - LLVMValueRef res; - struct lp_type type = bld->type; - - if (is_aindex_indirect) { - int i; - - res = bld->zero; - - for (i = 0; i < type.length; ++i) { - LLVMValueRef idx = lp_build_const_int32(gallivm, i); - LLVMValueRef attr_chan_index = attrib_index; - LLVMValueRef channel_vec; - - if (is_aindex_indirect) { - attr_chan_index = LLVMBuildExtractElement(builder, - attrib_index, idx, ""); - } - - indices[0] = lp_build_const_int32(gallivm, 0); - indices[1] = attr_chan_index; - indices[2] = swizzle_index; - - channel_vec = LLVMBuildGEP(builder, tes->input, indices, 3, ""); - channel_vec = LLVMBuildLoad(builder, channel_vec, ""); - - res = LLVMBuildInsertElement(builder, res, channel_vec, idx, ""); - } - } else { - indices[0] = lp_build_const_int32(gallivm, 0); - indices[1] = attrib_index; - indices[2] = swizzle_index; - - res = LLVMBuildGEP(builder, tes->input, indices, 3, ""); - res = LLVMBuildLoad(builder, res, ""); - res = lp_build_broadcast_scalar(bld, res); - } - return res; -} - -static void -draw_tes_llvm_generate(struct draw_llvm *llvm, - struct draw_tes_llvm_variant *variant) -{ - struct gallivm_state *gallivm = variant->gallivm; - LLVMContextRef context = gallivm->context; - LLVMTypeRef int32_type = LLVMInt32TypeInContext(context); - LLVMTypeRef flt_type = LLVMFloatTypeInContext(context); - LLVMTypeRef arg_types[10]; - LLVMTypeRef func_type; - LLVMValueRef variant_func; - LLVMValueRef context_ptr; - LLVMValueRef tess_coord[2], io_ptr, input_array, num_tess_coord; - LLVMValueRef tess_inner, tess_outer, prim_id, patch_vertices_in; - LLVMBasicBlockRef block; - LLVMBuilderRef builder; - LLVMValueRef mask_val; - struct lp_build_context bld, bldvec; - struct lp_build_sampler_soa *sampler = 0; - struct lp_build_image_soa *image = NULL; - struct lp_bld_tgsi_system_values system_values; - char func_name[64]; - unsigned i; - struct draw_tes_llvm_iface tes_iface; - LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][TGSI_NUM_CHANNELS]; - struct lp_build_mask_context mask; - LLVMValueRef consts_ptr, num_consts_ptr; - LLVMValueRef ssbos_ptr, num_ssbos_ptr; - LLVMValueRef step; - struct lp_type tes_type; - unsigned vector_length = variant->shader->base.vector_length; - - memset(&system_values, 0, sizeof(system_values)); - memset(&outputs, 0, sizeof(outputs)); - - snprintf(func_name, sizeof(func_name), "draw_llvm_tes_variant%u", - variant->shader->variants_cached); - - arg_types[0] = get_tes_context_ptr_type(variant); /* context */ - arg_types[1] = variant->input_array_type; /* input */ - arg_types[2] = variant->vertex_header_ptr_type; - arg_types[3] = int32_type; - arg_types[4] = int32_type; - arg_types[5] = LLVMPointerType(flt_type, 0); - arg_types[6] = LLVMPointerType(flt_type, 0); - arg_types[7] = LLVMPointerType(LLVMArrayType(flt_type, 4), 0); - arg_types[8] = LLVMPointerType(LLVMArrayType(flt_type, 2), 0); - arg_types[9] = int32_type; - - func_type = LLVMFunctionType(int32_type, arg_types, ARRAY_SIZE(arg_types), 0); - variant_func = LLVMAddFunction(gallivm->module, func_name, func_type); - - variant->function = variant_func; - LLVMSetFunctionCallConv(variant_func, LLVMCCallConv); - - for (i = 0; i < ARRAY_SIZE(arg_types); ++i) - if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) - lp_add_function_attr(variant_func, i + 1, LP_FUNC_ATTR_NOALIAS); - - context_ptr = LLVMGetParam(variant_func, 0); - input_array = LLVMGetParam(variant_func, 1); - io_ptr = LLVMGetParam(variant_func, 2); - prim_id = LLVMGetParam(variant_func, 3); - num_tess_coord = LLVMGetParam(variant_func, 4); - tess_coord[0] = LLVMGetParam(variant_func, 5); - tess_coord[1] = LLVMGetParam(variant_func, 6); - tess_outer = LLVMGetParam(variant_func, 7); - tess_inner = LLVMGetParam(variant_func, 8); - patch_vertices_in = LLVMGetParam(variant_func, 9); - - lp_build_name(context_ptr, "context"); - lp_build_name(input_array, "input"); - lp_build_name(io_ptr, "io"); - lp_build_name(prim_id, "prim_id"); - lp_build_name(num_tess_coord, "num_tess_coord"); - lp_build_name(tess_coord[0], "tess_coord[0]"); - lp_build_name(tess_coord[1], "tess_coord[1]"); - lp_build_name(tess_outer, "tess_outer"); - lp_build_name(tess_inner, "tess_inner"); - lp_build_name(patch_vertices_in, "patch_vertices_in"); - - tes_iface.base.fetch_vertex_input = draw_tes_llvm_fetch_vertex_input; - tes_iface.base.fetch_patch_input = draw_tes_llvm_fetch_patch_input; - tes_iface.input = input_array; - tes_iface.variant = variant; - - block = LLVMAppendBasicBlockInContext(gallivm->context, variant_func, "entry"); - builder = gallivm->builder; - LLVMPositionBuilderAtEnd(builder, block); - - lp_build_context_init(&bld, gallivm, lp_type_int(32)); - - memset(&tes_type, 0, sizeof tes_type); - tes_type.floating = TRUE; /* floating point values */ - tes_type.sign = TRUE; /* values are signed */ - tes_type.norm = FALSE; /* values are not limited to [0,1] or [-1,1] */ - tes_type.width = 32; /* 32-bit float */ - tes_type.length = vector_length; - - lp_build_context_init(&bldvec, variant->gallivm, lp_int_type(tes_type)); - consts_ptr = draw_tes_jit_context_constants(variant->gallivm, context_ptr); - num_consts_ptr = - draw_tes_jit_context_num_constants(variant->gallivm, context_ptr); - - ssbos_ptr = draw_tes_jit_context_ssbos(variant->gallivm, context_ptr); - num_ssbos_ptr = - draw_tes_jit_context_num_ssbos(variant->gallivm, context_ptr); - sampler = draw_llvm_sampler_soa_create(variant->key.samplers); - image = draw_llvm_image_soa_create(draw_tes_llvm_variant_key_images(&variant->key)); - step = lp_build_const_int32(gallivm, vector_length); - - system_values.tess_outer = LLVMBuildLoad(builder, tess_outer, ""); - system_values.tess_inner = LLVMBuildLoad(builder, tess_inner, ""); - - system_values.prim_id = lp_build_broadcast_scalar(&bldvec, prim_id); - - system_values.vertices_in = lp_build_broadcast_scalar(&bldvec, patch_vertices_in); - struct lp_build_loop_state lp_loop; - lp_build_loop_begin(&lp_loop, gallivm, bld.zero); - { - LLVMValueRef io; - - io = LLVMBuildGEP(builder, io_ptr, &lp_loop.counter, 1, ""); - mask_val = generate_tes_mask_value(variant, tes_type, num_tess_coord, lp_loop.counter); - lp_build_mask_begin(&mask, gallivm, tes_type, mask_val); - - system_values.tess_coord = LLVMGetUndef(LLVMArrayType(LLVMVectorType(flt_type, vector_length), 3)); - for (i = 0; i < 3; i++) { - LLVMValueRef tess_coord_chan = LLVMGetUndef(LLVMVectorType(flt_type, vector_length)); - for (unsigned j = 0; j < vector_length; j++) { - LLVMValueRef idx = LLVMBuildAdd(builder, lp_loop.counter, lp_build_const_int32(gallivm, j), ""); - LLVMValueRef tc_val; - if (i == 2) { - if (variant->shader->base.prim_mode == PIPE_PRIM_TRIANGLES) { - tc_val = lp_build_const_float(gallivm, 1.0); - tc_val = LLVMBuildFSub(builder, tc_val, lp_build_pointer_get(builder, tess_coord[0], idx), ""); - tc_val = LLVMBuildFSub(builder, tc_val, lp_build_pointer_get(builder, tess_coord[1], idx), ""); - } else - tc_val = lp_build_const_float(gallivm, 0.0); - } else - tc_val = lp_build_pointer_get(builder, tess_coord[i], idx); - - tess_coord_chan = LLVMBuildInsertElement(builder, tess_coord_chan, tc_val, lp_build_const_int32(gallivm, j), ""); - } - system_values.tess_coord = LLVMBuildInsertValue(builder, system_values.tess_coord, tess_coord_chan, i, ""); - } - - struct lp_build_tgsi_params params; - memset(¶ms, 0, sizeof(params)); - - params.type = tes_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->tes.tess_eval_shader->info; - params.ssbo_ptr = ssbos_ptr; - params.ssbo_sizes_ptr = num_ssbos_ptr; - params.image = image; - params.tes_iface = &tes_iface.base; - - lp_build_nir_soa(variant->gallivm, - llvm->draw->tes.tess_eval_shader->state.ir.nir, - ¶ms, - outputs); - - lp_build_mask_end(&mask); - LLVMValueRef clipmask = lp_build_const_int_vec(gallivm, - lp_int_type(tes_type), 0); - - convert_to_aos(gallivm, io, NULL, outputs, clipmask, - params.info->num_outputs, tes_type, FALSE); - } - lp_build_loop_end_cond(&lp_loop, num_tess_coord, step, LLVMIntUGE); - sampler->destroy(sampler); - image->destroy(image); - - LLVMBuildRet(builder, lp_build_zero(gallivm, lp_type_uint(32))); - gallivm_verify_function(gallivm, variant_func); -} - -struct draw_tes_llvm_variant * -draw_tes_llvm_create_variant(struct draw_llvm *llvm, - unsigned num_outputs, - const struct draw_tes_llvm_variant_key *key) -{ - struct draw_tes_llvm_variant *variant; - struct llvm_tess_eval_shader *shader = llvm_tess_eval_shader(llvm->draw->tes.tess_eval_shader); - LLVMTypeRef vertex_header; - char module_name[64]; - - variant = MALLOC(sizeof *variant + - shader->variant_key_size - sizeof variant->key); - if (!variant) - return NULL; - - variant->llvm = llvm; - variant->shader = shader; - - snprintf(module_name, sizeof(module_name), "draw_llvm_tes_variant%u", - variant->shader->variants_cached); - - variant->gallivm = gallivm_create(module_name, llvm->context); - - create_tes_jit_types(variant); - - memcpy(&variant->key, key, shader->variant_key_size); - - vertex_header = create_jit_vertex_header(variant->gallivm, num_outputs); - - variant->vertex_header_ptr_type = LLVMPointerType(vertex_header, 0); - - if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) { - nir_print_shader(llvm->draw->tes.tess_eval_shader->state.ir.nir, stderr); - draw_tes_llvm_dump_variant_key(&variant->key); - } - - draw_tes_llvm_generate(llvm, variant); - - gallivm_compile_module(variant->gallivm); - - variant->jit_func = (draw_tes_jit_func) - gallivm_jit_function(variant->gallivm, variant->function); - - gallivm_free_ir(variant->gallivm); - - variant->list_item_global.base = variant; - variant->list_item_local.base = variant; - /*variant->no = */shader->variants_created++; - variant->list_item_global.base = variant; - - return variant; -} - -void -draw_tes_llvm_destroy_variant(struct draw_tes_llvm_variant *variant) -{ - struct draw_llvm *llvm = variant->llvm; - - if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) { - debug_printf("Deleting TES variant: %u tes variants,\t%u total variants\n", - variant->shader->variants_cached, llvm->nr_tes_variants); - } - - gallivm_destroy(variant->gallivm); - - remove_from_list(&variant->list_item_local); - variant->shader->variants_cached--; - remove_from_list(&variant->list_item_global); - llvm->nr_tes_variants--; - FREE(variant); -} - -struct draw_tes_llvm_variant_key * -draw_tes_llvm_make_variant_key(struct draw_llvm *llvm, char *store) -{ - unsigned i; - struct draw_tes_llvm_variant_key *key; - struct draw_sampler_static_state *draw_sampler; - struct draw_image_static_state *draw_image; - - key = (struct draw_tes_llvm_variant_key *)store; - - memset(key, 0, offsetof(struct draw_tes_llvm_variant_key, samplers[0])); - - /* All variants of this shader will have the same value for - * nr_samplers. Not yet trying to compact away holes in the - * sampler array. - */ - key->nr_samplers = llvm->draw->tes.tess_eval_shader->info.file_max[TGSI_FILE_SAMPLER] + 1; - if (llvm->draw->tes.tess_eval_shader->info.file_max[TGSI_FILE_SAMPLER_VIEW] != -1) { - key->nr_sampler_views = - llvm->draw->tes.tess_eval_shader->info.file_max[TGSI_FILE_SAMPLER_VIEW] + 1; - } - else { - key->nr_sampler_views = key->nr_samplers; - } - - key->nr_images = llvm->draw->tes.tess_eval_shader->info.file_max[TGSI_FILE_IMAGE] + 1; - - draw_sampler = key->samplers; - - 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, - llvm->draw->samplers[PIPE_SHADER_TESS_EVAL][i]); - } - for (i = 0 ; i < key->nr_sampler_views; i++) { - lp_sampler_static_texture_state(&draw_sampler[i].texture_state, - llvm->draw->sampler_views[PIPE_SHADER_TESS_EVAL][i]); - } - - draw_image = draw_tes_llvm_variant_key_images(key); - memset(draw_image, 0, - key->nr_images * sizeof *draw_image); - for (i = 0; i < key->nr_images; i++) { - lp_sampler_static_texture_state_image(&draw_image[i].image_state, - llvm->draw->images[PIPE_SHADER_TESS_EVAL][i]); - } - return key; -} - -void -draw_tes_llvm_dump_variant_key(struct draw_tes_llvm_variant_key *key) -{ - unsigned i; - struct draw_sampler_static_state *sampler = key->samplers; - struct draw_image_static_state *image = draw_tes_llvm_variant_key_images(key); - for (i = 0 ; i < key->nr_sampler_views; i++) { - debug_printf("sampler[%i].src_format = %s\n", i, - util_format_name(sampler[i].texture_state.format)); - } - - for (i = 0 ; i < key->nr_images; i++) - debug_printf("images[%i].format = %s\n", i, util_format_name(image[i].image_state.format)); - -} diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.h b/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.h index b1c498631..6edc89b63 100644 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.h +++ b/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.h @@ -32,7 +32,6 @@ #include "draw/draw_vs.h" #include "draw/draw_gs.h" -#include "draw/draw_tess.h" #include "gallivm/lp_bld_sample.h" #include "gallivm/lp_bld_limits.h" @@ -44,8 +43,6 @@ struct draw_llvm; struct llvm_vertex_shader; struct llvm_geometry_shader; -struct llvm_tess_ctrl_shader; -struct llvm_tess_eval_shader; struct draw_jit_texture { @@ -320,103 +317,6 @@ enum { #define draw_gs_jit_context_num_ssbos(_gallivm, _ptr) \ lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_NUM_SSBOS, "num_ssbos") - -struct draw_tcs_jit_context { - const float *constants[LP_MAX_TGSI_CONST_BUFFERS]; - int num_constants[LP_MAX_TGSI_CONST_BUFFERS]; - - int dummy1; - int dummy2; - /* There two need to be exactly at DRAW_JIT_CTX_TEXTURES and - * DRAW_JIT_CTX_SAMPLERS positions in the struct */ - struct draw_jit_texture textures[PIPE_MAX_SHADER_SAMPLER_VIEWS]; - struct draw_jit_sampler samplers[PIPE_MAX_SAMPLERS]; - struct draw_jit_image images[PIPE_MAX_SHADER_IMAGES]; - - const uint32_t *ssbos[LP_MAX_TGSI_SHADER_BUFFERS]; - int num_ssbos[LP_MAX_TGSI_SHADER_BUFFERS]; -}; - -enum { - DRAW_TCS_JIT_CTX_CONSTANTS = 0, - DRAW_TCS_JIT_CTX_NUM_CONSTANTS = 1, - DRAW_TCS_JIT_CTX_TEXTURES = DRAW_JIT_CTX_TEXTURES, - DRAW_TCS_JIT_CTX_SAMPLERS = DRAW_JIT_CTX_SAMPLERS, - DRAW_TCS_JIT_CTX_IMAGES = DRAW_JIT_CTX_IMAGES, - DRAW_TCS_JIT_CTX_SSBOS = 7, - DRAW_TCS_JIT_CTX_NUM_SSBOS = 8, - DRAW_TCS_JIT_CTX_NUM_FIELDS = 9, -}; - -#define draw_tcs_jit_context_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_CONSTANTS, "constants") - -#define draw_tcs_jit_context_num_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_NUM_CONSTANTS, "num_constants") - -#define draw_tcs_jit_context_textures(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_TEXTURES, "textures") - -#define draw_tcs_jit_context_samplers(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_SAMPLERS, "samplers") - -#define draw_tcs_jit_context_images(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_IMAGES, "images") - -#define draw_tcs_jit_context_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_SSBOS, "ssbos") - -#define draw_tcs_jit_context_num_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_NUM_SSBOS, "num_ssbos") - -struct draw_tes_jit_context { - const float *constants[LP_MAX_TGSI_CONST_BUFFERS]; - int num_constants[LP_MAX_TGSI_CONST_BUFFERS]; - - int dummy1; - int dummy2; - /* There two need to be exactly at DRAW_JIT_CTX_TEXTURES and - * DRAW_JIT_CTX_SAMPLERS positions in the struct */ - struct draw_jit_texture textures[PIPE_MAX_SHADER_SAMPLER_VIEWS]; - struct draw_jit_sampler samplers[PIPE_MAX_SAMPLERS]; - struct draw_jit_image images[PIPE_MAX_SHADER_IMAGES]; - - const uint32_t *ssbos[LP_MAX_TGSI_SHADER_BUFFERS]; - int num_ssbos[LP_MAX_TGSI_SHADER_BUFFERS]; -}; - -enum { - DRAW_TES_JIT_CTX_CONSTANTS = 0, - DRAW_TES_JIT_CTX_NUM_CONSTANTS = 1, - DRAW_TES_JIT_CTX_TEXTURES = DRAW_JIT_CTX_TEXTURES, - DRAW_TES_JIT_CTX_SAMPLERS = DRAW_JIT_CTX_SAMPLERS, - DRAW_TES_JIT_CTX_IMAGES = DRAW_JIT_CTX_IMAGES, - DRAW_TES_JIT_CTX_SSBOS = 7, - DRAW_TES_JIT_CTX_NUM_SSBOS = 8, - DRAW_TES_JIT_CTX_NUM_FIELDS = 9, -}; - -#define draw_tes_jit_context_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_CONSTANTS, "constants") - -#define draw_tes_jit_context_num_constants(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_NUM_CONSTANTS, "num_constants") - -#define draw_tes_jit_context_textures(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_TEXTURES, "textures") - -#define draw_tes_jit_context_samplers(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_SAMPLERS, "samplers") - -#define draw_tes_jit_context_images(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_IMAGES, "images") - -#define draw_tes_jit_context_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_SSBOS, "ssbos") - -#define draw_tes_jit_context_num_ssbos(_gallivm, _ptr) \ - lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_NUM_SSBOS, "num_ssbos") - typedef boolean (*draw_jit_vert_func)(struct draw_jit_context *context, struct vertex_header *io, @@ -435,27 +335,12 @@ typedef boolean typedef int (*draw_gs_jit_func)(struct draw_gs_jit_context *context, float inputs[6][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS][TGSI_NUM_CHANNELS], - struct vertex_header **output, + struct vertex_header *output, unsigned num_prims, unsigned instance_id, int *prim_ids, unsigned invocation_id); -typedef int -(*draw_tcs_jit_func)(struct draw_tcs_jit_context *context, - float inputs[32][NUM_TCS_INPUTS][TGSI_NUM_CHANNELS], - float outputs[32][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS], - uint32_t prim_id, uint32_t patch_vertices_in); - -typedef int -(*draw_tes_jit_func)(struct draw_tes_jit_context *context, - float inputs[32][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS], - struct vertex_header *io, - uint32_t prim_id, uint32_t num_tess_coord, - float *tess_coord_x, float *tess_coord_y, float *tess_outer, - float *tess_inner, uint32_t patch_vertices_in); - - struct draw_llvm_variant_key { unsigned nr_vertex_elements:8; @@ -469,7 +354,7 @@ struct draw_llvm_variant_key unsigned clip_halfz:1; unsigned bypass_viewport:1; unsigned need_edgeflags:1; - unsigned has_gs_or_tes:1; + unsigned has_gs:1; unsigned num_outputs:8; unsigned ucp_enable:PIPE_MAX_CLIP_PLANES; /* note padding here - must use memset */ @@ -497,24 +382,6 @@ struct draw_gs_llvm_variant_key /* Followed by variable number of images.*/ }; -struct draw_tcs_llvm_variant_key -{ - unsigned nr_samplers:8; - unsigned nr_sampler_views:8; - unsigned nr_images:8; - struct draw_sampler_static_state samplers[1]; - /* Followed by variable number of images.*/ -}; - -struct draw_tes_llvm_variant_key -{ - unsigned nr_samplers:8; - unsigned nr_sampler_views:8; - unsigned nr_images:8; - struct draw_sampler_static_state samplers[1]; - /* Followed by variable number of images.*/ -}; - #define DRAW_LLVM_MAX_VARIANT_KEY_SIZE \ (sizeof(struct draw_llvm_variant_key) + \ PIPE_MAX_SHADER_SAMPLER_VIEWS * sizeof(struct draw_sampler_static_state) + \ @@ -526,16 +393,6 @@ struct draw_tes_llvm_variant_key PIPE_MAX_SHADER_IMAGES * sizeof(struct draw_image_static_state) + \ PIPE_MAX_SHADER_SAMPLER_VIEWS * sizeof(struct draw_sampler_static_state)) -#define DRAW_TCS_LLVM_MAX_VARIANT_KEY_SIZE \ - (sizeof(struct draw_tcs_llvm_variant_key) + \ - PIPE_MAX_SHADER_IMAGES * sizeof(struct draw_image_static_state) + \ - PIPE_MAX_SHADER_SAMPLER_VIEWS * sizeof(struct draw_sampler_static_state)) - -#define DRAW_TES_LLVM_MAX_VARIANT_KEY_SIZE \ - (sizeof(struct draw_tes_llvm_variant_key) + \ - PIPE_MAX_SHADER_IMAGES * sizeof(struct draw_image_static_state) + \ - PIPE_MAX_SHADER_SAMPLER_VIEWS * sizeof(struct draw_sampler_static_state)) - static inline size_t draw_llvm_variant_key_size(unsigned nr_vertex_elements, @@ -556,21 +413,6 @@ draw_gs_llvm_variant_key_size(unsigned nr_samplers, unsigned nr_images) (nr_samplers - 1) * sizeof(struct draw_sampler_static_state)); } -static inline size_t -draw_tcs_llvm_variant_key_size(unsigned nr_samplers, unsigned nr_images) -{ - return (sizeof(struct draw_tcs_llvm_variant_key) + - (nr_images) * sizeof(struct draw_sampler_static_state) + - (nr_samplers - 1) * sizeof(struct draw_sampler_static_state)); -} - -static inline size_t -draw_tes_llvm_variant_key_size(unsigned nr_samplers, unsigned nr_images) -{ - return (sizeof(struct draw_tes_llvm_variant_key) + - (nr_images) * sizeof(struct draw_sampler_static_state) + - (nr_samplers - 1) * sizeof(struct draw_sampler_static_state)); -} static inline struct draw_sampler_static_state * draw_llvm_variant_key_samplers(struct draw_llvm_variant_key *key) @@ -595,20 +437,6 @@ draw_gs_llvm_variant_key_images(struct draw_gs_llvm_variant_key *key) &key->samplers[key->nr_samplers]; } -static inline struct draw_image_static_state * -draw_tcs_llvm_variant_key_images(struct draw_tcs_llvm_variant_key *key) -{ - return (struct draw_image_static_state *) - &key->samplers[key->nr_samplers]; -} - -static inline struct draw_image_static_state * -draw_tes_llvm_variant_key_images(struct draw_tes_llvm_variant_key *key) -{ - return (struct draw_image_static_state *) - &key->samplers[key->nr_samplers]; -} - struct draw_llvm_variant_list_item { struct draw_llvm_variant *base; @@ -621,17 +449,6 @@ struct draw_gs_llvm_variant_list_item struct draw_gs_llvm_variant_list_item *next, *prev; }; -struct draw_tcs_llvm_variant_list_item -{ - struct draw_tcs_llvm_variant *base; - struct draw_tcs_llvm_variant_list_item *next, *prev; -}; - -struct draw_tes_llvm_variant_list_item -{ - struct draw_tes_llvm_variant *base; - struct draw_tes_llvm_variant_list_item *next, *prev; -}; struct draw_llvm_variant { @@ -682,57 +499,6 @@ struct draw_gs_llvm_variant struct draw_gs_llvm_variant_key key; }; -struct draw_tcs_llvm_variant -{ - struct gallivm_state *gallivm; - - /* LLVM JIT builder types */ - LLVMTypeRef context_ptr_type; - LLVMTypeRef input_array_type; - LLVMTypeRef output_array_type; - - LLVMValueRef context_ptr; - LLVMValueRef io_ptr; - LLVMValueRef num_prims; - LLVMValueRef function; - draw_tcs_jit_func jit_func; - - struct llvm_tess_ctrl_shader *shader; - - struct draw_llvm *llvm; - struct draw_tcs_llvm_variant_list_item list_item_global; - struct draw_tcs_llvm_variant_list_item list_item_local; - - /* key is variable-sized, must be last */ - struct draw_tcs_llvm_variant_key key; -}; - -struct draw_tes_llvm_variant -{ - struct gallivm_state *gallivm; - - /* LLVM JIT builder types */ - LLVMTypeRef context_ptr_type; - LLVMTypeRef vertex_header_ptr_type; - LLVMTypeRef input_array_type; - LLVMTypeRef patch_input_array_type; - - LLVMValueRef context_ptr; - LLVMValueRef io_ptr; - LLVMValueRef num_prims; - LLVMValueRef function; - draw_tes_jit_func jit_func; - - struct llvm_tess_eval_shader *shader; - - struct draw_llvm *llvm; - struct draw_tes_llvm_variant_list_item list_item_global; - struct draw_tes_llvm_variant_list_item list_item_local; - - /* key is variable-sized, must be last */ - struct draw_tes_llvm_variant_key key; -}; - struct llvm_vertex_shader { struct draw_vertex_shader base; @@ -751,23 +517,6 @@ struct llvm_geometry_shader { unsigned variants_cached; }; -struct llvm_tess_ctrl_shader { - struct draw_tess_ctrl_shader base; - - unsigned variant_key_size; - struct draw_tcs_llvm_variant_list_item variants; - unsigned variants_created; - unsigned variants_cached; -}; - -struct llvm_tess_eval_shader { - struct draw_tess_eval_shader base; - - unsigned variant_key_size; - struct draw_tes_llvm_variant_list_item variants; - unsigned variants_created; - unsigned variants_cached; -}; struct draw_llvm { struct draw_context *draw; @@ -777,20 +526,12 @@ struct draw_llvm { struct draw_jit_context jit_context; struct draw_gs_jit_context gs_jit_context; - struct draw_tcs_jit_context tcs_jit_context; - struct draw_tes_jit_context tes_jit_context; struct draw_llvm_variant_list_item vs_variants_list; int nr_variants; struct draw_gs_llvm_variant_list_item gs_variants_list; int nr_gs_variants; - - struct draw_tcs_llvm_variant_list_item tcs_variants_list; - int nr_tcs_variants; - - struct draw_tes_llvm_variant_list_item tes_variants_list; - int nr_tes_variants; }; @@ -806,17 +547,8 @@ llvm_geometry_shader(struct draw_geometry_shader *gs) return (struct llvm_geometry_shader *)gs; } -static inline struct llvm_tess_ctrl_shader * -llvm_tess_ctrl_shader(struct draw_tess_ctrl_shader *tcs) -{ - return (struct llvm_tess_ctrl_shader *)tcs; -} -static inline struct llvm_tess_eval_shader * -llvm_tess_eval_shader(struct draw_tess_eval_shader *tes) -{ - return (struct llvm_tess_eval_shader *)tes; -} + struct draw_llvm * draw_llvm_create(struct draw_context *draw, LLVMContextRef llvm_context); @@ -853,34 +585,6 @@ draw_gs_llvm_make_variant_key(struct draw_llvm *llvm, char *store); void draw_gs_llvm_dump_variant_key(struct draw_gs_llvm_variant_key *key); -struct draw_tcs_llvm_variant * -draw_tcs_llvm_create_variant(struct draw_llvm *llvm, - unsigned num_vertex_header_attribs, - const struct draw_tcs_llvm_variant_key *key); - -void -draw_tcs_llvm_destroy_variant(struct draw_tcs_llvm_variant *variant); - -struct draw_tcs_llvm_variant_key * -draw_tcs_llvm_make_variant_key(struct draw_llvm *llvm, char *store); - -void -draw_tcs_llvm_dump_variant_key(struct draw_tcs_llvm_variant_key *key); - -struct draw_tes_llvm_variant * -draw_tes_llvm_create_variant(struct draw_llvm *llvm, - unsigned num_vertex_header_attribs, - const struct draw_tes_llvm_variant_key *key); - -void -draw_tes_llvm_destroy_variant(struct draw_tes_llvm_variant *variant); - -struct draw_tes_llvm_variant_key * -draw_tes_llvm_make_variant_key(struct draw_llvm *llvm, char *store); - -void -draw_tes_llvm_dump_variant_key(struct draw_tes_llvm_variant_key *key); - struct lp_build_sampler_soa * draw_llvm_sampler_soa_create(const struct draw_sampler_static_state *static_state); diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_user_cull.c b/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_user_cull.c deleted file mode 100644 index fcc177e04..000000000 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_user_cull.c +++ /dev/null @@ -1,197 +0,0 @@ -/************************************************************************** - * - * Copyright 2007 VMware, Inc. - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. - * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR - * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE - * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ - -/** - * \brief Drawing stage for user culling - */ - -#include "util/u_math.h" -#include "util/u_memory.h" -#include "pipe/p_defines.h" -#include "draw_pipe.h" - -struct user_cull_stage { - struct draw_stage stage; -}; - -static inline struct user_cull_stage *user_cull_stage( struct draw_stage *stage ) -{ - return (struct user_cull_stage *)stage; -} - -static inline boolean -cull_distance_is_out(float dist) -{ - return (dist < 0.0f) || util_is_inf_or_nan(dist); -} - -/* - * If the shader writes the culldistance then we can - * perform distance based culling. Distance based - * culling doesn't require a face and can be performed - * on primitives without faces (e.g. points and lines) - */ -static void user_cull_point( struct draw_stage *stage, - struct prim_header *header ) -{ - const unsigned num_written_culldistances = - draw_current_shader_num_written_culldistances(stage->draw); - const unsigned num_written_clipdistances = - draw_current_shader_num_written_clipdistances(stage->draw); - unsigned i; - - debug_assert(num_written_culldistances); - - for (i = 0; i < num_written_culldistances; ++i) { - unsigned cull_idx = (num_written_clipdistances + i) / 4; - unsigned out_idx = - draw_current_shader_ccdistance_output(stage->draw, cull_idx); - unsigned idx = (num_written_clipdistances + i) % 4; - float cull1 = header->v[0]->data[out_idx][idx]; - boolean vert1_out = cull_distance_is_out(cull1); - if (vert1_out) - return; - } - stage->next->point( stage->next, header ); -} - -/* - * If the shader writes the culldistance then we can - * perform distance based culling. Distance based - * culling doesn't require a face and can be performed - * on primitives without faces (e.g. points and lines) - */ -static void user_cull_line( struct draw_stage *stage, - struct prim_header *header ) -{ - const unsigned num_written_culldistances = - draw_current_shader_num_written_culldistances(stage->draw); - const unsigned num_written_clipdistances = - draw_current_shader_num_written_clipdistances(stage->draw); - unsigned i; - - debug_assert(num_written_culldistances); - - for (i = 0; i < num_written_culldistances; ++i) { - unsigned cull_idx = (num_written_clipdistances + i) / 4; - unsigned out_idx = - draw_current_shader_ccdistance_output(stage->draw, cull_idx); - unsigned idx = (num_written_clipdistances + i) % 4; - float cull1 = header->v[0]->data[out_idx][idx]; - float cull2 = header->v[1]->data[out_idx][idx]; - boolean vert1_out = cull_distance_is_out(cull1); - boolean vert2_out = cull_distance_is_out(cull2); - if (vert1_out && vert2_out) - return; - } - stage->next->line( stage->next, header ); -} - -/* - * Triangles can be culled either using the cull distance - * shader outputs or the regular face culling. If required - * this function performs both, starting with distance culling. - */ -static void user_cull_tri( struct draw_stage *stage, - struct prim_header *header ) -{ - const unsigned num_written_culldistances = - draw_current_shader_num_written_culldistances(stage->draw); - const unsigned num_written_clipdistances = - draw_current_shader_num_written_clipdistances(stage->draw); - unsigned i; - - debug_assert(num_written_culldistances); - - /* Do the distance culling */ - for (i = 0; i < num_written_culldistances; ++i) { - unsigned cull_idx = (num_written_clipdistances + i) / 4; - unsigned out_idx = - draw_current_shader_ccdistance_output(stage->draw, cull_idx); - unsigned idx = (num_written_clipdistances + i) % 4; - float cull1 = header->v[0]->data[out_idx][idx]; - float cull2 = header->v[1]->data[out_idx][idx]; - float cull3 = header->v[2]->data[out_idx][idx]; - boolean vert1_out = cull_distance_is_out(cull1); - boolean vert2_out = cull_distance_is_out(cull2); - boolean vert3_out = cull_distance_is_out(cull3); - if (vert1_out && vert2_out && vert3_out) { - return; - } - } - stage->next->tri( stage->next, header ); -} - -static void user_cull_flush( struct draw_stage *stage, unsigned flags ) -{ - stage->point = user_cull_point; - stage->line = user_cull_line; - stage->tri = user_cull_tri; - stage->next->flush( stage->next, flags ); -} - -static void user_cull_reset_stipple_counter( struct draw_stage *stage ) -{ - stage->next->reset_stipple_counter( stage->next ); -} - -static void user_cull_destroy( struct draw_stage *stage ) -{ - draw_free_temp_verts( stage ); - FREE( stage ); -} - -/** - * Create a new polygon culling stage. - */ -struct draw_stage *draw_user_cull_stage( struct draw_context *draw ) -{ - struct user_cull_stage *user_cull = CALLOC_STRUCT(user_cull_stage); - if (!user_cull) - goto fail; - - user_cull->stage.draw = draw; - user_cull->stage.name = "user_cull"; - user_cull->stage.next = NULL; - user_cull->stage.point = user_cull_point; - user_cull->stage.line = user_cull_line; - user_cull->stage.tri = user_cull_tri; - user_cull->stage.flush = user_cull_flush; - user_cull->stage.reset_stipple_counter = user_cull_reset_stipple_counter; - user_cull->stage.destroy = user_cull_destroy; - - if (!draw_alloc_temp_verts( &user_cull->stage, 0 )) - goto fail; - - return &user_cull->stage; - -fail: - if (user_cull) - user_cull->stage.destroy( &user_cull->stage ); - - return NULL; -} diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_validate.c b/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_validate.c index 940ca5644..846cd4db3 100644 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_validate.c +++ b/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_validate.c @@ -100,9 +100,6 @@ draw_need_pipeline(const struct draw_context *draw, /* point sprites */ if (rasterizer->sprite_coord_enable && draw->pipeline.point_sprite) return TRUE; - - if (draw_current_shader_num_written_culldistances(draw)) - return TRUE; } else if (reduced_prim == PIPE_PRIM_TRIANGLES) { /* polygon stipple */ @@ -255,7 +252,8 @@ static struct draw_stage *validate_pipeline( struct draw_stage *stage ) * to less work emitting vertices, smaller vertex buffers, etc. * It's difficult to say whether this will be true in general. */ - if (need_det || rast->cull_face != PIPE_FACE_NONE) { + if (need_det || rast->cull_face != PIPE_FACE_NONE || + draw_current_shader_num_written_culldistances(draw)) { draw->pipeline.cull->next = next; next = draw->pipeline.cull; } @@ -268,11 +266,6 @@ static struct draw_stage *validate_pipeline( struct draw_stage *stage ) next = draw->pipeline.clip; } - if (draw_current_shader_num_written_culldistances(draw)) { - draw->pipeline.user_cull->next = next; - next = draw->pipeline.user_cull; - } - draw->pipeline.first = next; if (0) { diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_private.h b/lib/mesa/src/gallium/auxiliary/draw/draw_private.h index a5a1b4e9b..0fd0caab3 100644 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_private.h +++ b/lib/mesa/src/gallium/auxiliary/draw/draw_private.h @@ -122,7 +122,6 @@ struct draw_context struct draw_stage *flatshade; struct draw_stage *clip; struct draw_stage *cull; - struct draw_stage *user_cull; struct draw_stage *twoside; struct draw_stage *offset; struct draw_stage *unfilled; @@ -158,7 +157,7 @@ struct draw_context unsigned prim; unsigned opt; /**< bitmask of PT_x flags */ unsigned eltSize; /* saved eltSize for flushing */ - ubyte vertices_per_patch; + boolean rebind_parameters; struct { @@ -207,20 +206,12 @@ struct draw_context unsigned vs_constants_size[PIPE_MAX_CONSTANT_BUFFERS]; const void *gs_constants[PIPE_MAX_CONSTANT_BUFFERS]; unsigned gs_constants_size[PIPE_MAX_CONSTANT_BUFFERS]; - const void *tcs_constants[PIPE_MAX_CONSTANT_BUFFERS]; - unsigned tcs_constants_size[PIPE_MAX_CONSTANT_BUFFERS]; - const void *tes_constants[PIPE_MAX_CONSTANT_BUFFERS]; - unsigned tes_constants_size[PIPE_MAX_CONSTANT_BUFFERS]; /** shader buffers (for vertex/geometry shader) */ const void *vs_ssbos[PIPE_MAX_SHADER_BUFFERS]; unsigned vs_ssbos_size[PIPE_MAX_SHADER_BUFFERS]; const void *gs_ssbos[PIPE_MAX_SHADER_BUFFERS]; unsigned gs_ssbos_size[PIPE_MAX_SHADER_BUFFERS]; - const void *tcs_ssbos[PIPE_MAX_SHADER_BUFFERS]; - unsigned tcs_ssbos_size[PIPE_MAX_SHADER_BUFFERS]; - const void *tes_ssbos[PIPE_MAX_SHADER_BUFFERS]; - unsigned tes_ssbos_size[PIPE_MAX_SHADER_BUFFERS]; /* pointer to planes */ float (*planes)[DRAW_TOTAL_CLIP_PLANES][4]; @@ -312,34 +303,6 @@ struct draw_context } gs; - /* Tessellation state */ - struct { - struct draw_tess_ctrl_shader *tess_ctrl_shader; - - /** Fields for TGSI interpreter / execution */ - struct { - struct tgsi_exec_machine *machine; - - struct tgsi_sampler *sampler; - struct tgsi_image *image; - struct tgsi_buffer *buffer; - } tgsi; - } tcs; - - struct { - struct draw_tess_eval_shader *tess_eval_shader; - uint position_output; - - /** Fields for TGSI interpreter / execution */ - struct { - struct tgsi_exec_machine *machine; - - struct tgsi_sampler *sampler; - struct tgsi_image *image; - struct tgsi_buffer *buffer; - } tgsi; - } tes; - /** Fragment shader state */ struct { struct draw_fragment_shader *fragment_shader; @@ -386,8 +349,6 @@ struct draw_context struct pipe_query_data_pipeline_statistics statistics; boolean collect_statistics; - float default_outer_tess_level[4]; - float default_inner_tess_level[2]; bool collect_primgen; struct draw_assembler *ia; diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_pt.c b/lib/mesa/src/gallium/auxiliary/draw/draw_pt.c index 986f87e01..24ac05427 100644 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_pt.c +++ b/lib/mesa/src/gallium/auxiliary/draw/draw_pt.c @@ -32,7 +32,6 @@ #include "draw/draw_context.h" #include "draw/draw_gs.h" -#include "draw/draw_tess.h" #include "draw/draw_private.h" #include "draw/draw_pt.h" #include "draw/draw_vbuf.h" @@ -67,24 +66,16 @@ draw_pt_arrays(struct draw_context *draw, */ { unsigned first, incr; - - if (prim == PIPE_PRIM_PATCHES) { - first = draw->pt.vertices_per_patch; - incr = draw->pt.vertices_per_patch; - } else - draw_pt_split_prim(prim, &first, &incr); + draw_pt_split_prim(prim, &first, &incr); count = draw_pt_trim_count(count, first, incr); if (count < first) return TRUE; } if (!draw->force_passthrough) { - unsigned out_prim = prim; - - if (draw->gs.geometry_shader) - out_prim = draw->gs.geometry_shader->output_primitive; - else if (draw->tes.tess_eval_shader) - out_prim = get_tes_output_prim(draw->tes.tess_eval_shader); + unsigned gs_out_prim = (draw->gs.geometry_shader ? + draw->gs.geometry_shader->output_primitive : + prim); if (!draw->render) { opt |= PT_PIPELINE; @@ -92,7 +83,7 @@ draw_pt_arrays(struct draw_context *draw, if (draw_need_pipeline(draw, draw->rasterizer, - out_prim)) { + gs_out_prim)) { opt |= PT_PIPELINE; } @@ -496,8 +487,6 @@ draw_vbo(struct draw_context *draw, draw->pt.user.eltSize = info->index_size ? draw->pt.user.eltSizeIB : 0; draw->pt.user.drawid = info->drawid; - draw->pt.vertices_per_patch = info->vertices_per_patch; - if (0) debug_printf("draw_vbo(mode=%u start=%u count=%u):\n", info->mode, info->start, count); diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c b/lib/mesa/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c index d403e81c2..c19eda2ed 100644 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c +++ b/lib/mesa/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c @@ -30,7 +30,6 @@ #include "util/u_prim.h" #include "draw/draw_context.h" #include "draw/draw_gs.h" -#include "draw/draw_tess.h" #include "draw/draw_vbuf.h" #include "draw/draw_vertex.h" #include "draw/draw_pt.h" @@ -139,146 +138,6 @@ llvm_middle_end_prepare_gs(struct llvm_middle_end *fpme) gs->current_variant = variant; } -static void -llvm_middle_end_prepare_tcs(struct llvm_middle_end *fpme) -{ - struct draw_context *draw = fpme->draw; - struct draw_llvm *llvm = fpme->llvm; - struct draw_tess_ctrl_shader *tcs = draw->tcs.tess_ctrl_shader; - struct draw_tcs_llvm_variant_key *key; - struct draw_tcs_llvm_variant *variant = NULL; - struct draw_tcs_llvm_variant_list_item *li; - struct llvm_tess_ctrl_shader *shader = llvm_tess_ctrl_shader(tcs); - char store[DRAW_TCS_LLVM_MAX_VARIANT_KEY_SIZE]; - unsigned i; - - key = draw_tcs_llvm_make_variant_key(llvm, store); - - /* Search shader's list of variants for the key */ - li = first_elem(&shader->variants); - while (!at_end(&shader->variants, li)) { - if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) { - variant = li->base; - break; - } - li = next_elem(li); - } - - if (variant) { - /* found the variant, move to head of global list (for LRU) */ - move_to_head(&llvm->tcs_variants_list, &variant->list_item_global); - } - else { - /* Need to create new variant */ - - /* First check if we've created too many variants. If so, free - * 3.125% of the LRU to avoid using too much memory. - */ - if (llvm->nr_tcs_variants >= DRAW_MAX_SHADER_VARIANTS) { - if (gallivm_debug & GALLIVM_DEBUG_PERF) { - debug_printf("Evicting TCS: %u tcs variants,\t%u total variants\n", - shader->variants_cached, llvm->nr_tcs_variants); - } - - /* - * XXX: should we flush here ? - */ - for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) { - struct draw_tcs_llvm_variant_list_item *item; - if (is_empty_list(&llvm->tcs_variants_list)) { - break; - } - item = last_elem(&llvm->tcs_variants_list); - assert(item); - assert(item->base); - draw_tcs_llvm_destroy_variant(item->base); - } - } - - variant = draw_tcs_llvm_create_variant(llvm, 0, key); - - if (variant) { - insert_at_head(&shader->variants, &variant->list_item_local); - insert_at_head(&llvm->tcs_variants_list, - &variant->list_item_global); - llvm->nr_tcs_variants++; - shader->variants_cached++; - } - } - - tcs->current_variant = variant; -} - -static void -llvm_middle_end_prepare_tes(struct llvm_middle_end *fpme) -{ - struct draw_context *draw = fpme->draw; - struct draw_llvm *llvm = fpme->llvm; - struct draw_tess_eval_shader *tes = draw->tes.tess_eval_shader; - struct draw_tes_llvm_variant_key *key; - struct draw_tes_llvm_variant *variant = NULL; - struct draw_tes_llvm_variant_list_item *li; - struct llvm_tess_eval_shader *shader = llvm_tess_eval_shader(tes); - char store[DRAW_TES_LLVM_MAX_VARIANT_KEY_SIZE]; - unsigned i; - - key = draw_tes_llvm_make_variant_key(llvm, store); - - /* Search shader's list of variants for the key */ - li = first_elem(&shader->variants); - while (!at_end(&shader->variants, li)) { - if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) { - variant = li->base; - break; - } - li = next_elem(li); - } - - if (variant) { - /* found the variant, move to head of global list (for LRU) */ - move_to_head(&llvm->tes_variants_list, &variant->list_item_global); - } - else { - /* Need to create new variant */ - - /* First check if we've created too many variants. If so, free - * 3.125% of the LRU to avoid using too much memory. - */ - if (llvm->nr_tes_variants >= DRAW_MAX_SHADER_VARIANTS) { - if (gallivm_debug & GALLIVM_DEBUG_PERF) { - debug_printf("Evicting TES: %u tes variants,\t%u total variants\n", - shader->variants_cached, llvm->nr_tes_variants); - } - - /* - * XXX: should we flush here ? - */ - for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) { - struct draw_tes_llvm_variant_list_item *item; - if (is_empty_list(&llvm->tes_variants_list)) { - break; - } - item = last_elem(&llvm->tes_variants_list); - assert(item); - assert(item->base); - draw_tes_llvm_destroy_variant(item->base); - } - } - - variant = draw_tes_llvm_create_variant(llvm, tes->info.num_outputs, key); - - if (variant) { - insert_at_head(&shader->variants, &variant->list_item_local); - insert_at_head(&llvm->tes_variants_list, - &variant->list_item_global); - llvm->nr_tes_variants++; - shader->variants_cached++; - } - } - - tes->current_variant = variant; -} - /** * Prepare/validate middle part of the vertex pipeline. * NOTE: if you change this function, also look at the non-LLVM @@ -295,9 +154,7 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle, struct draw_llvm *llvm = fpme->llvm; struct draw_vertex_shader *vs = draw->vs.vertex_shader; struct draw_geometry_shader *gs = draw->gs.geometry_shader; - struct draw_tess_ctrl_shader *tcs = draw->tcs.tess_ctrl_shader; - struct draw_tess_eval_shader *tes = draw->tes.tess_eval_shader; - const unsigned out_prim = gs ? gs->output_primitive : tes ? get_tes_output_prim(tes) : + const unsigned out_prim = gs ? gs->output_primitive : u_assembled_prim(in_prim); unsigned point_clip = draw->rasterizer->fill_front == PIPE_POLYGON_MODE_POINT || out_prim == PIPE_PRIM_POINTS; @@ -413,12 +270,6 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle, if (gs) { llvm_middle_end_prepare_gs(fpme); } - if (tcs) { - llvm_middle_end_prepare_tcs(fpme); - } - if (tes) { - llvm_middle_end_prepare_tes(fpme); - } } @@ -478,42 +329,6 @@ llvm_middle_end_bind_parameters(struct draw_pt_middle_end *middle) } } - for (i = 0; i < ARRAY_SIZE(llvm->tcs_jit_context.constants); ++i) { - int num_consts = - DIV_ROUND_UP(draw->pt.user.tcs_constants_size[i], (sizeof(float) * 4)); - llvm->tcs_jit_context.constants[i] = draw->pt.user.tcs_constants[i]; - llvm->tcs_jit_context.num_constants[i] = num_consts; - if (num_consts == 0) { - llvm->tcs_jit_context.constants[i] = fake_const_buf; - } - } - for (i = 0; i < ARRAY_SIZE(llvm->tcs_jit_context.ssbos); ++i) { - int num_ssbos = draw->pt.user.tcs_ssbos_size[i]; - llvm->tcs_jit_context.ssbos[i] = draw->pt.user.tcs_ssbos[i]; - llvm->tcs_jit_context.num_ssbos[i] = num_ssbos; - if (num_ssbos == 0) { - llvm->tcs_jit_context.ssbos[i] = (const uint32_t *)fake_const_buf; - } - } - - for (i = 0; i < ARRAY_SIZE(llvm->tes_jit_context.constants); ++i) { - int num_consts = - DIV_ROUND_UP(draw->pt.user.tes_constants_size[i], (sizeof(float) * 4)); - llvm->tes_jit_context.constants[i] = draw->pt.user.tes_constants[i]; - llvm->tes_jit_context.num_constants[i] = num_consts; - if (num_consts == 0) { - llvm->tes_jit_context.constants[i] = fake_const_buf; - } - } - for (i = 0; i < ARRAY_SIZE(llvm->tes_jit_context.ssbos); ++i) { - int num_ssbos = draw->pt.user.tes_ssbos_size[i]; - llvm->tes_jit_context.ssbos[i] = draw->pt.user.tes_ssbos[i]; - llvm->tes_jit_context.num_ssbos[i] = num_ssbos; - if (num_ssbos == 0) { - llvm->tes_jit_context.ssbos[i] = (const uint32_t *)fake_const_buf; - } - } - llvm->jit_context.planes = (float (*)[DRAW_TOTAL_CLIP_PLANES][4]) draw->pt.user.planes[0]; llvm->gs_jit_context.planes = @@ -562,14 +377,8 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle, struct llvm_middle_end *fpme = llvm_middle_end(middle); struct draw_context *draw = fpme->draw; struct draw_geometry_shader *gshader = draw->gs.geometry_shader; - struct draw_tess_ctrl_shader *tcs_shader = draw->tcs.tess_ctrl_shader; - struct draw_tess_eval_shader *tes_shader = draw->tes.tess_eval_shader; - struct draw_prim_info tcs_prim_info; - struct draw_prim_info tes_prim_info; struct draw_prim_info gs_prim_info[TGSI_MAX_VERTEX_STREAMS]; struct draw_vertex_info llvm_vert_info; - struct draw_vertex_info tcs_vert_info; - struct draw_vertex_info tes_vert_info; struct draw_vertex_info gs_vert_info[TGSI_MAX_VERTEX_STREAMS]; struct draw_vertex_info *vert_info; struct draw_prim_info ia_prim_info; @@ -580,7 +389,6 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle, boolean clipped = 0; unsigned start_or_maxelt, vid_base; const unsigned *elts; - ushort *tes_elts_out = NULL; assert(fetch_info->count > 0); llvm_vert_info.count = fetch_info->count; @@ -596,11 +404,8 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle, if (draw->collect_statistics) { draw->statistics.ia_vertices += prim_info->count; - if (prim_info->prim == PIPE_PRIM_PATCHES) - draw->statistics.ia_primitives += prim_info->count / draw->pt.vertices_per_patch; - else - draw->statistics.ia_primitives += - u_decomposed_prims_for_vertices(prim_info->prim, prim_info->count); + draw->statistics.ia_primitives += + u_decomposed_prims_for_vertices(prim_info->prim, prim_info->count); draw->statistics.vs_invocations += fetch_info->count; } @@ -631,56 +436,6 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle, fetch_info = NULL; vert_info = &llvm_vert_info; - if (opt & PT_SHADE) { - struct draw_vertex_shader *vshader = draw->vs.vertex_shader; - if (tcs_shader) { - draw_tess_ctrl_shader_run(tcs_shader, - draw->pt.user.tcs_constants, - draw->pt.user.tcs_constants_size, - vert_info, - prim_info, - &vshader->info, - &tcs_vert_info, - &tcs_prim_info); - FREE(vert_info->verts); - vert_info = &tcs_vert_info; - prim_info = &tcs_prim_info; - - } else if (tes_shader) { - unsigned num_prims = prim_info->count / draw->pt.vertices_per_patch; - tcs_prim_info = *prim_info; - tcs_prim_info.primitive_count = num_prims; - prim_info = &tcs_prim_info; - } - - if (tes_shader) { - draw_tess_eval_shader_run(tes_shader, - draw->pt.user.tes_constants, - draw->pt.user.tes_constants_size, - tcs_shader ? tcs_shader->vertices_out : draw->pt.vertices_per_patch, - vert_info, - prim_info, - tcs_shader ? &tcs_shader->info : &vshader->info, - &tes_vert_info, - &tes_prim_info, &tes_elts_out); - - FREE(vert_info->verts); - vert_info = &tes_vert_info; - prim_info = &tes_prim_info; - free_prim_info = TRUE; - - /* - * pt emit can only handle ushort number of vertices (see - * render->allocate_vertices). - * vsplit guarantees there's never more than 4096, however GS can - * easily blow this up (by a factor of 256 (or even 1024) max). - */ - if (vert_info->count > 65535) { - opt |= PT_PIPELINE; - } - } - } - if ((opt & PT_SHADE) && gshader) { struct draw_vertex_shader *vshader = draw->vs.vertex_shader; draw_geometry_shader_run(gshader, @@ -688,18 +443,13 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle, draw->pt.user.gs_constants_size, vert_info, prim_info, - tes_shader ? &tes_shader->info : &vshader->info, + &vshader->info, gs_vert_info, gs_prim_info); FREE(vert_info->verts); - if (free_prim_info) { - FREE(prim_info->primitive_lengths); - FREE(tes_elts_out); - } vert_info = &gs_vert_info[0]; prim_info = &gs_prim_info[0]; - free_prim_info = FALSE; /* * pt emit can only handle ushort number of vertices (see * render->allocate_vertices). @@ -727,14 +477,13 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle, FREE(vert_info->verts); if (free_prim_info) { - FREE(tes_elts_out); FREE(prim_info->primitive_lengths); } return; } /* stream output needs to be done before clipping */ - draw_pt_so_emit( fpme->so_emit, gshader ? gshader->num_vertex_streams : 1, vert_info, prim_info ); + draw_pt_so_emit( fpme->so_emit, 1, vert_info, prim_info ); draw_stats_clipper_primitives(draw, prim_info); @@ -743,7 +492,7 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle, * will try to access non-existent position output. */ if (draw_current_shader_position_output(draw) != -1) { - if ((opt & PT_SHADE) && (gshader || tes_shader || + if ((opt & PT_SHADE) && (gshader || draw->vs.vertex_shader->info.writes_viewport_index)) { clipped = draw_pt_post_vs_run( fpme->post_vs, vert_info, prim_info ); } @@ -763,7 +512,6 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle, } FREE(vert_info->verts); if (free_prim_info) { - FREE(tes_elts_out); FREE(prim_info->primitive_lengths); } } diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_tess.c b/lib/mesa/src/gallium/auxiliary/draw/draw_tess.c deleted file mode 100644 index 07d5ef960..000000000 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_tess.c +++ /dev/null @@ -1,644 +0,0 @@ -/************************************************************************** - * - * Copyright 2020 Red Hat. - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - * - **************************************************************************/ -#include "draw_tess.h" -#ifdef LLVM_AVAILABLE -#include "draw_llvm.h" -#endif - -#include "tessellator/p_tessellator.h" -#include "nir/nir_to_tgsi_info.h" -#include "util/u_prim.h" -#include "util/u_math.h" -#include "util/u_memory.h" -#include "util/ralloc.h" -static inline int -draw_tes_get_input_index(int semantic, int index, - const struct tgsi_shader_info *input_info) -{ - int i; - const ubyte *input_semantic_names = input_info->output_semantic_name; - const ubyte *input_semantic_indices = input_info->output_semantic_index; - for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) { - if (input_semantic_names[i] == semantic && - input_semantic_indices[i] == index) - return i; - } - return -1; -} - -#ifdef LLVM_AVAILABLE -#define DEBUG_INPUTS 0 -static void -llvm_fetch_tcs_input(struct draw_tess_ctrl_shader *shader, - const struct draw_prim_info *input_prim_info, - unsigned prim_id, - unsigned num_vertices) -{ - const float (*input_ptr)[4]; - float (*input_data)[32][NUM_TCS_INPUTS][TGSI_NUM_CHANNELS] = &shader->tcs_input->data; - unsigned slot, i; - int vs_slot; - unsigned input_vertex_stride = shader->input_vertex_stride; - - input_ptr = shader->input; - for (i = 0; i < num_vertices; i++) { - const float (*input)[4]; - int vertex_idx = prim_id * num_vertices + i; - if (input_prim_info->linear == FALSE) - vertex_idx = input_prim_info->elts[vertex_idx]; -#if DEBUG_INPUTS - debug_printf("%d) tcs vertex index = %d (prim idx = %d)\n", - i, prim_id, 0); -#endif - input = (const float (*)[4])((const char *)input_ptr + (vertex_idx * input_vertex_stride)); - for (slot = 0, vs_slot = 0; slot < shader->info.num_inputs; ++slot) { - vs_slot = draw_tes_get_input_index( - shader->info.input_semantic_name[slot], - shader->info.input_semantic_index[slot], - shader->input_info); - if (vs_slot < 0) { - debug_printf("VS/TCS signature mismatch!\n"); - (*input_data)[i][slot][0] = 0; - (*input_data)[i][slot][1] = 0; - (*input_data)[i][slot][2] = 0; - (*input_data)[i][slot][3] = 0; - } else { - (*input_data)[i][slot][0] = input[vs_slot][0]; - (*input_data)[i][slot][1] = input[vs_slot][1]; - (*input_data)[i][slot][2] = input[vs_slot][2]; - (*input_data)[i][slot][3] = input[vs_slot][3]; -#if DEBUG_INPUTS - debug_printf("\t\t%p = %f %f %f %f\n", &(*input_data)[i][slot][0], - (*input_data)[i][slot][0], - (*input_data)[i][slot][1], - (*input_data)[i][slot][2], - (*input_data)[i][slot][3]); -#endif - ++vs_slot; - } - } - } -} - -#define DEBUG_OUTPUTS 0 -static void -llvm_store_tcs_output(struct draw_tess_ctrl_shader *shader, - unsigned prim_id, - struct draw_vertex_info *output_verts, - unsigned vert_start) -{ - float (*output_ptr)[4]; - float (*output_data)[32][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS] = &shader->tcs_output->data; - unsigned slot, i; - unsigned num_vertices = shader->vertices_out; - - char *output = (char *)output_verts->verts->data; - output += vert_start * output_verts->stride; - - for (i = 0; i < num_vertices; i++) { - -#if DEBUG_OUTPUTS - debug_printf("%d) tcs store vertex index = %d (prim idx = %d)\n", - i, prim_id, 0); -#endif - output_ptr = (float(*)[4])(output + (i * output_verts->stride)); - - for (slot = 0; slot < shader->info.num_outputs; ++slot) { - output_ptr[slot][0] = (*output_data)[i][slot][0]; - output_ptr[slot][1] = (*output_data)[i][slot][1]; - output_ptr[slot][2] = (*output_data)[i][slot][2]; - output_ptr[slot][3] = (*output_data)[i][slot][3]; -#if DEBUG_OUTPUTS - debug_printf("\t\t%p = %f %f %f %f\n", - &output_ptr[slot][0], - output_ptr[slot][0], - output_ptr[slot][1], - output_ptr[slot][2], - output_ptr[slot][3]); -#endif - } - } -} - -static void -llvm_tcs_run(struct draw_tess_ctrl_shader *shader, uint32_t prim_id) -{ - shader->current_variant->jit_func(shader->jit_context, shader->tcs_input->data, shader->tcs_output->data, prim_id, - shader->draw->pt.vertices_per_patch); -} -#endif - -/** - * Execute tess ctrl shader. - */ -int draw_tess_ctrl_shader_run(struct draw_tess_ctrl_shader *shader, - const void *constants[PIPE_MAX_CONSTANT_BUFFERS], - const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS], - const struct draw_vertex_info *input_verts, - const struct draw_prim_info *input_prim, - const struct tgsi_shader_info *input_info, - struct draw_vertex_info *output_verts, - struct draw_prim_info *output_prims ) -{ - const float (*input)[4] = (const float (*)[4])input_verts->verts->data; - unsigned num_outputs = draw_total_tcs_outputs(shader->draw); - unsigned input_stride = input_verts->vertex_size; - unsigned vertex_size = sizeof(struct vertex_header) + num_outputs * 4 * sizeof(float); - unsigned num_patches = input_prim->count / shader->draw->pt.vertices_per_patch; - - output_verts->vertex_size = vertex_size; - output_verts->stride = output_verts->vertex_size; - output_verts->verts = NULL; - output_verts->count = 0; - shader->input = input; - shader->input_vertex_stride = input_stride; - shader->input_info = input_info; - - output_prims->linear = TRUE; - output_prims->start = 0; - output_prims->elts = NULL; - output_prims->count = 0; - output_prims->prim = PIPE_PRIM_PATCHES; - output_prims->flags = 0; - output_prims->primitive_lengths = NULL; - output_prims->primitive_count = 0; - - if (shader->draw->collect_statistics) { - shader->draw->statistics.hs_invocations += num_patches; - } -#ifdef LLVM_AVAILABLE - for (unsigned i = 0; i < num_patches; i++) { - uint32_t vert_start = output_verts->count; - - output_verts->count += shader->vertices_out; - - llvm_fetch_tcs_input(shader, input_prim, i, shader->draw->pt.vertices_per_patch); - - llvm_tcs_run(shader, i); - - uint32_t old_verts = util_align_npot(vert_start, 16); - uint32_t new_verts = util_align_npot(output_verts->count, 16); - uint32_t old_size = output_verts->vertex_size * old_verts; - uint32_t new_size = output_verts->vertex_size * new_verts; - output_verts->verts = REALLOC(output_verts->verts, old_size, new_size); - - llvm_store_tcs_output(shader, i, output_verts, vert_start); - } -#endif - - output_prims->primitive_count = num_patches; - return 0; -} - -#ifdef LLVM_AVAILABLE -#define DEBUG_INPUTS 0 -static void -llvm_fetch_tes_input(struct draw_tess_eval_shader *shader, - const struct draw_prim_info *input_prim_info, - unsigned prim_id, - unsigned num_vertices) -{ - const float (*input_ptr)[4]; - float (*input_data)[32][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS] = &shader->tes_input->data; - unsigned slot, i; - int vs_slot; - unsigned input_vertex_stride = shader->input_vertex_stride; - - input_ptr = shader->input; - for (i = 0; i < num_vertices; i++) { - const float (*input)[4]; - int vertex_idx = prim_id * num_vertices + i; - - if (input_prim_info->linear == FALSE) - vertex_idx = input_prim_info->elts[vertex_idx]; -#if DEBUG_INPUTS - debug_printf("%d) tes vertex index = %d (prim idx = %d)\n", - i, prim_id, 0); -#endif - input = (const float (*)[4])((const char *)input_ptr + (vertex_idx * input_vertex_stride)); - for (slot = 0, vs_slot = 0; slot < shader->info.num_inputs; ++slot) { - vs_slot = draw_tes_get_input_index( - shader->info.input_semantic_name[slot], - shader->info.input_semantic_index[slot], - shader->input_info); - if (vs_slot < 0) { - debug_printf("TCS/TES signature mismatch!\n"); - (*input_data)[i][slot][0] = 0; - (*input_data)[i][slot][1] = 0; - (*input_data)[i][slot][2] = 0; - (*input_data)[i][slot][3] = 0; - } else { - (*input_data)[i][slot][0] = input[vs_slot][0]; - (*input_data)[i][slot][1] = input[vs_slot][1]; - (*input_data)[i][slot][2] = input[vs_slot][2]; - (*input_data)[i][slot][3] = input[vs_slot][3]; -#if DEBUG_INPUTS - debug_printf("\t\t%p = %f %f %f %f\n", - &input[vs_slot][0], - (*input_data)[i][slot][0], - (*input_data)[i][slot][1], - (*input_data)[i][slot][2], - (*input_data)[i][slot][3]); -#endif - ++vs_slot; - } - } - } -} - -static void -llvm_fetch_tess_factors(struct draw_tess_eval_shader *shader, - unsigned patch_id, - unsigned num_vertices, - struct pipe_tessellation_factors *factors) -{ - int outer_slot = draw_tes_get_input_index( - TGSI_SEMANTIC_TESSOUTER, 0, shader->input_info); - int inner_slot = draw_tes_get_input_index( - TGSI_SEMANTIC_TESSINNER, 0, shader->input_info); - const float (*input_ptr)[4]; - const float (*input)[4]; - input_ptr = shader->input; - input = (const float (*)[4])((const char *)input_ptr + ((patch_id * num_vertices) * shader->input_vertex_stride)); - - if (outer_slot != -1) { - for (unsigned i = 0; i < 4; i++) - factors->outer_tf[i] = input[outer_slot][i]; - } else { - for (unsigned i = 0; i < 4; i++) - factors->outer_tf[i] = shader->draw->default_outer_tess_level[i]; - } - if (inner_slot != -1) { - for (unsigned i = 0; i < 2; i++) - factors->inner_tf[i] = input[inner_slot][i]; - } else { - for (unsigned i = 0; i < 2; i++) - factors->inner_tf[i] = shader->draw->default_inner_tess_level[i]; - } -} - -static void -llvm_tes_run(struct draw_tess_eval_shader *shader, - uint32_t prim_id, - uint32_t patch_vertices_in, - struct pipe_tessellator_data *tess_data, - struct pipe_tessellation_factors *tess_factors, - struct vertex_header *output) -{ - shader->current_variant->jit_func(shader->jit_context, shader->tes_input->data, output, prim_id, - tess_data->num_domain_points, tess_data->domain_points_u, tess_data->domain_points_v, - tess_factors->outer_tf, tess_factors->inner_tf, patch_vertices_in); -} -#endif - -/** - * Execute tess eval shader. - */ -int draw_tess_eval_shader_run(struct draw_tess_eval_shader *shader, - const void *constants[PIPE_MAX_CONSTANT_BUFFERS], - const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS], - unsigned num_input_vertices_per_patch, - const struct draw_vertex_info *input_verts, - const struct draw_prim_info *input_prim, - const struct tgsi_shader_info *input_info, - struct draw_vertex_info *output_verts, - struct draw_prim_info *output_prims, - ushort **elts_out) -{ - const float (*input)[4] = (const float (*)[4])input_verts->verts->data; - unsigned num_outputs = draw_total_tes_outputs(shader->draw); - unsigned input_stride = input_verts->vertex_size; - unsigned vertex_size = sizeof(struct vertex_header) + num_outputs * 4 * sizeof(float); - ushort *elts = NULL; - output_verts->vertex_size = vertex_size; - output_verts->stride = output_verts->vertex_size; - output_verts->count = 0; - output_verts->verts = NULL; - - output_prims->linear = FALSE; - output_prims->start = 0; - output_prims->elts = NULL; - output_prims->count = 0; - output_prims->prim = get_tes_output_prim(shader); - output_prims->flags = 0; - output_prims->primitive_lengths = NULL; - output_prims->primitive_count = 0; - - shader->input = input; - shader->input_vertex_stride = input_stride; - shader->input_info = input_info; - - if (shader->draw->collect_statistics) { - shader->draw->statistics.ds_invocations += input_prim->primitive_count; - } -#ifdef LLVM_AVAILABLE - struct pipe_tessellation_factors factors; - struct pipe_tessellator_data data = { 0 }; - struct pipe_tessellator *ptess = p_tess_init(shader->prim_mode, - shader->spacing, - !shader->vertex_order_cw, - shader->point_mode); - for (unsigned i = 0; i < input_prim->primitive_count; i++) { - uint32_t vert_start = output_verts->count; - uint32_t prim_start = output_prims->primitive_count; - uint32_t elt_start = output_prims->count; - - llvm_fetch_tess_factors(shader, i, num_input_vertices_per_patch, &factors); - - /* tessellate with the factors for this primitive */ - p_tessellate(ptess, &factors, &data); - - if (data.num_domain_points == 0) - continue; - - uint32_t old_verts = vert_start; - uint32_t new_verts = vert_start + util_align_npot(data.num_domain_points, 4); - uint32_t old_size = output_verts->vertex_size * old_verts; - uint32_t new_size = output_verts->vertex_size * new_verts; - output_verts->verts = REALLOC(output_verts->verts, old_size, new_size); - - output_verts->count += data.num_domain_points; - - output_prims->count += data.num_indices; - elts = REALLOC(elts, elt_start * sizeof(uint16_t), - output_prims->count * sizeof(uint16_t)); - - for (unsigned i = 0; i < data.num_indices; i++) - elts[elt_start + i] = vert_start + data.indices[i]; - - llvm_fetch_tes_input(shader, input_prim, i, num_input_vertices_per_patch); - /* run once per primitive? */ - char *output = (char *)output_verts->verts; - output += vert_start * vertex_size; - llvm_tes_run(shader, i, num_input_vertices_per_patch, &data, &factors, (struct vertex_header *)output); - - uint32_t prim_len = u_prim_vertex_count(output_prims->prim)->min; - output_prims->primitive_count += data.num_indices / prim_len; - output_prims->primitive_lengths = REALLOC(output_prims->primitive_lengths, prim_start * sizeof(uint32_t), - output_prims->primitive_count * sizeof(uint32_t)); - for (unsigned i = prim_start; i < output_prims->primitive_count; i++) { - output_prims->primitive_lengths[i] = prim_len; - } - } - p_tess_destroy(ptess); -#endif - - *elts_out = elts; - output_prims->elts = elts; - return 0; -} - -struct draw_tess_ctrl_shader * -draw_create_tess_ctrl_shader(struct draw_context *draw, - const struct pipe_shader_state *state) -{ -#ifdef LLVM_AVAILABLE - boolean use_llvm = draw->llvm != NULL; - struct llvm_tess_ctrl_shader *llvm_tcs = NULL; -#endif - struct draw_tess_ctrl_shader *tcs; - -#ifdef LLVM_AVAILABLE - if (use_llvm) { - llvm_tcs = CALLOC_STRUCT(llvm_tess_ctrl_shader); - - if (!llvm_tcs) - return NULL; - - tcs = &llvm_tcs->base; - - make_empty_list(&llvm_tcs->variants); - } else -#endif - { - tcs = CALLOC_STRUCT(draw_tess_ctrl_shader); - } - - if (!tcs) - return NULL; - - tcs->draw = draw; - tcs->state = *state; - - nir_tgsi_scan_shader(state->ir.nir, &tcs->info, true); - - tcs->vector_length = 4; - tcs->vertices_out = tcs->info.properties[TGSI_PROPERTY_TCS_VERTICES_OUT]; -#ifdef LLVM_AVAILABLE - if (use_llvm) { - - tcs->tcs_input = align_malloc(sizeof(struct draw_tcs_inputs), 16); - memset(tcs->tcs_input, 0, sizeof(struct draw_tcs_inputs)); - - tcs->tcs_output = align_malloc(sizeof(struct draw_tcs_outputs), 16); - memset(tcs->tcs_output, 0, sizeof(struct draw_tcs_outputs)); - - tcs->jit_context = &draw->llvm->tcs_jit_context; - llvm_tcs->variant_key_size = - draw_tcs_llvm_variant_key_size( - MAX2(tcs->info.file_max[TGSI_FILE_SAMPLER]+1, - tcs->info.file_max[TGSI_FILE_SAMPLER_VIEW]+1), - tcs->info.file_max[TGSI_FILE_IMAGE]+1); - } -#endif - return tcs; -} - -void draw_bind_tess_ctrl_shader(struct draw_context *draw, - struct draw_tess_ctrl_shader *dtcs) -{ - draw_do_flush(draw, DRAW_FLUSH_STATE_CHANGE); - if (dtcs) { - draw->tcs.tess_ctrl_shader = dtcs; - } else { - draw->tcs.tess_ctrl_shader = NULL; - } -} - -void draw_delete_tess_ctrl_shader(struct draw_context *draw, - struct draw_tess_ctrl_shader *dtcs) -{ - if (!dtcs) - return; - -#ifdef LLVM_AVAILABLE - if (draw->llvm) { - struct llvm_tess_ctrl_shader *shader = llvm_tess_ctrl_shader(dtcs); - - struct draw_tcs_llvm_variant_list_item *li; - - li = first_elem(&shader->variants); - while(!at_end(&shader->variants, li)) { - struct draw_tcs_llvm_variant_list_item *next = next_elem(li); - draw_tcs_llvm_destroy_variant(li->base); - li = next; - } - - assert(shader->variants_cached == 0); - align_free(dtcs->tcs_input); - align_free(dtcs->tcs_output); - } -#endif - - if (dtcs->state.ir.nir) - ralloc_free(dtcs->state.ir.nir); - FREE(dtcs); -} - -#ifdef LLVM_AVAILABLE -void draw_tcs_set_current_variant(struct draw_tess_ctrl_shader *shader, - struct draw_tcs_llvm_variant *variant) -{ - shader->current_variant = variant; -} -#endif - -struct draw_tess_eval_shader * -draw_create_tess_eval_shader(struct draw_context *draw, - const struct pipe_shader_state *state) -{ -#ifdef LLVM_AVAILABLE - boolean use_llvm = draw->llvm != NULL; - struct llvm_tess_eval_shader *llvm_tes = NULL; -#endif - struct draw_tess_eval_shader *tes; - -#ifdef LLVM_AVAILABLE - if (use_llvm) { - llvm_tes = CALLOC_STRUCT(llvm_tess_eval_shader); - - if (!llvm_tes) - return NULL; - - tes = &llvm_tes->base; - make_empty_list(&llvm_tes->variants); - } else -#endif - { - tes = CALLOC_STRUCT(draw_tess_eval_shader); - } - - if (!tes) - return NULL; - - tes->draw = draw; - tes->state = *state; - - nir_tgsi_scan_shader(state->ir.nir, &tes->info, true); - - tes->prim_mode = tes->info.properties[TGSI_PROPERTY_TES_PRIM_MODE]; - tes->spacing = tes->info.properties[TGSI_PROPERTY_TES_SPACING]; - tes->vertex_order_cw = tes->info.properties[TGSI_PROPERTY_TES_VERTEX_ORDER_CW]; - tes->point_mode = tes->info.properties[TGSI_PROPERTY_TES_POINT_MODE]; - - tes->vector_length = 4; - - tes->position_output = -1; - for (unsigned i = 0; i < tes->info.num_outputs; i++) { - if (tes->info.output_semantic_name[i] == TGSI_SEMANTIC_POSITION && - tes->info.output_semantic_index[i] == 0) - tes->position_output = i; - if (tes->info.output_semantic_name[i] == TGSI_SEMANTIC_VIEWPORT_INDEX) - tes->viewport_index_output = i; - if (tes->info.output_semantic_name[i] == TGSI_SEMANTIC_CLIPDIST) { - debug_assert(tes->info.output_semantic_index[i] < - PIPE_MAX_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT); - tes->ccdistance_output[tes->info.output_semantic_index[i]] = i; - } - } - -#ifdef LLVM_AVAILABLE - if (use_llvm) { - - tes->tes_input = align_malloc(sizeof(struct draw_tes_inputs), 16); - memset(tes->tes_input, 0, sizeof(struct draw_tes_inputs)); - - tes->jit_context = &draw->llvm->tes_jit_context; - llvm_tes->variant_key_size = - draw_tes_llvm_variant_key_size( - MAX2(tes->info.file_max[TGSI_FILE_SAMPLER]+1, - tes->info.file_max[TGSI_FILE_SAMPLER_VIEW]+1), - tes->info.file_max[TGSI_FILE_IMAGE]+1); - } -#endif - return tes; -} - -void draw_bind_tess_eval_shader(struct draw_context *draw, - struct draw_tess_eval_shader *dtes) -{ - draw_do_flush(draw, DRAW_FLUSH_STATE_CHANGE); - if (dtes) { - draw->tes.tess_eval_shader = dtes; - draw->tes.position_output = dtes->position_output; - } else { - draw->tes.tess_eval_shader = NULL; - } -} - -void draw_delete_tess_eval_shader(struct draw_context *draw, - struct draw_tess_eval_shader *dtes) -{ - if (!dtes) - return; - -#ifdef LLVM_AVAILABLE - if (draw->llvm) { - struct llvm_tess_eval_shader *shader = llvm_tess_eval_shader(dtes); - struct draw_tes_llvm_variant_list_item *li; - - li = first_elem(&shader->variants); - while(!at_end(&shader->variants, li)) { - struct draw_tes_llvm_variant_list_item *next = next_elem(li); - draw_tes_llvm_destroy_variant(li->base); - li = next; - } - - assert(shader->variants_cached == 0); - align_free(dtes->tes_input); - } -#endif - if (dtes->state.ir.nir) - ralloc_free(dtes->state.ir.nir); - FREE(dtes); -} - -#ifdef LLVM_AVAILABLE -void draw_tes_set_current_variant(struct draw_tess_eval_shader *shader, - struct draw_tes_llvm_variant *variant) -{ - shader->current_variant = variant; -} -#endif - -enum pipe_prim_type get_tes_output_prim(struct draw_tess_eval_shader *shader) -{ - if (shader->point_mode) - return PIPE_PRIM_POINTS; - else if (shader->prim_mode == PIPE_PRIM_LINES) - return PIPE_PRIM_LINES; - else - return PIPE_PRIM_TRIANGLES; -} diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_tess.h b/lib/mesa/src/gallium/auxiliary/draw/draw_tess.h deleted file mode 100644 index 29ae0847a..000000000 --- a/lib/mesa/src/gallium/auxiliary/draw/draw_tess.h +++ /dev/null @@ -1,130 +0,0 @@ -/************************************************************************** - * - * Copyright 2020 Red Hat. - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - * - **************************************************************************/ - -#ifndef DRAW_TESS_H -#define DRAW_TESS_H - -#include "draw_context.h" -#include "draw_private.h" - -struct draw_context; -#ifdef LLVM_AVAILABLE - -#define NUM_PATCH_INPUTS 32 -#define NUM_TCS_INPUTS (PIPE_MAX_SHADER_INPUTS - NUM_PATCH_INPUTS) - -struct draw_tcs_inputs { - /* num vertices per prim */ - float data[32][NUM_TCS_INPUTS][4]; -}; - -struct draw_tcs_outputs { - /* num vertices per prim */ - float data[32][PIPE_MAX_SHADER_INPUTS][4]; -}; - -struct draw_tes_inputs { - /* num vertices per prim */ - float data[32][PIPE_MAX_SHADER_INPUTS][4]; -}; - -#endif - -struct draw_tess_ctrl_shader { - struct draw_context *draw; - - struct pipe_shader_state state; - struct tgsi_shader_info info; - - unsigned vector_length; - unsigned vertices_out; - - unsigned input_vertex_stride; - const float (*input)[4]; - const struct tgsi_shader_info *input_info; -#ifdef LLVM_AVAILABLE - struct draw_tcs_inputs *tcs_input; - struct draw_tcs_outputs *tcs_output; - struct draw_tcs_jit_context *jit_context; - struct draw_tcs_llvm_variant *current_variant; -#endif -}; - -struct draw_tess_eval_shader { - struct draw_context *draw; - struct pipe_shader_state state; - struct tgsi_shader_info info; - - unsigned prim_mode; - unsigned spacing; - unsigned vertex_order_cw; - unsigned point_mode; - - unsigned position_output; - unsigned viewport_index_output; - unsigned ccdistance_output[PIPE_MAX_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT]; - unsigned vector_length; - - unsigned input_vertex_stride; - const float (*input)[4]; - const struct tgsi_shader_info *input_info; - -#ifdef LLVM_AVAILABLE - struct draw_tes_inputs *tes_input; - struct draw_tes_jit_context *jit_context; - struct draw_tes_llvm_variant *current_variant; -#endif -}; - -enum pipe_prim_type get_tes_output_prim(struct draw_tess_eval_shader *shader); - -int draw_tess_ctrl_shader_run(struct draw_tess_ctrl_shader *shader, - const void *constants[PIPE_MAX_CONSTANT_BUFFERS], - const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS], - const struct draw_vertex_info *input_verts, - const struct draw_prim_info *input_prim, - const struct tgsi_shader_info *input_info, - struct draw_vertex_info *output_verts, - struct draw_prim_info *output_prims ); - -int draw_tess_eval_shader_run(struct draw_tess_eval_shader *shader, - const void *constants[PIPE_MAX_CONSTANT_BUFFERS], - const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS], - unsigned num_input_vertices_per_patch, - const struct draw_vertex_info *input_verts, - const struct draw_prim_info *input_prim, - const struct tgsi_shader_info *input_info, - struct draw_vertex_info *output_verts, - struct draw_prim_info *output_prims, - ushort **elts_out); - -#ifdef LLVM_AVAILABLE -void draw_tcs_set_current_variant(struct draw_tess_ctrl_shader *shader, - struct draw_tcs_llvm_variant *variant); -void draw_tes_set_current_variant(struct draw_tess_eval_shader *shader, - struct draw_tes_llvm_variant *variant); -#endif - -#endif |