llvmpipe: add function name to gallivm_jit_function

Reviewed-by: Dave Airlie <airlied@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/26018>

src/gallium/auxiliary/draw/draw_llvm.c

@@ -525,7 +525,7 @@ draw_llvm_create_variant(struct draw_llvm *llvm,
    gallivm_compile_module(variant->gallivm);
 
    variant->jit_func = (draw_jit_vert_func)
-         gallivm_jit_function(variant->gallivm, variant->function);
+         gallivm_jit_function(variant->gallivm, variant->function, variant->function_name);
 
    if (needs_caching)
       llvm->draw->disk_cache_insert_shader(llvm->draw->disk_cache_cookie,
@@ -1628,6 +1628,8 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant)
 
    variant_func = LLVMAddFunction(gallivm->module, func_name, func_type);
    variant->function = variant_func;
+   variant->function_name = MALLOC(strlen(func_name)+1);
+   strcpy(variant->function_name, func_name);
 
    LLVMSetFunctionCallConv(variant_func, LLVMCCallConv);
    for (i = 0; i < num_arg_types; ++i)
@@ -2245,6 +2247,8 @@ draw_llvm_destroy_variant(struct draw_llvm_variant *variant)
    variant->shader->variants_cached--;
    list_del(&variant->list_item_global.list);
    llvm->nr_variants--;
+   if(variant->function_name)
+      FREE(variant->function_name);
    FREE(variant);
 }
 
@@ -2354,6 +2358,8 @@ draw_gs_llvm_generate(struct draw_llvm *llvm,
    variant_func = LLVMAddFunction(gallivm->module, func_name, func_type);
 
    variant->function = variant_func;
+   variant->function_name = MALLOC(strlen(func_name)+1);
+   strcpy(variant->function_name, func_name);
 
    LLVMSetFunctionCallConv(variant_func, LLVMCCallConv);
 
@@ -2532,7 +2538,7 @@ draw_gs_llvm_create_variant(struct draw_llvm *llvm,
    gallivm_compile_module(variant->gallivm);
 
    variant->jit_func = (draw_gs_jit_func)
-         gallivm_jit_function(variant->gallivm, variant->function);
+         gallivm_jit_function(variant->gallivm, variant->function, variant->function_name);
 
    if (needs_caching)
       llvm->draw->disk_cache_insert_shader(llvm->draw->disk_cache_cookie,
@@ -2565,6 +2571,8 @@ draw_gs_llvm_destroy_variant(struct draw_gs_llvm_variant *variant)
    variant->shader->variants_cached--;
    list_del(&variant->list_item_global.list);
    llvm->nr_gs_variants--;
+   if(variant->function_name)
+      FREE(variant->function_name);
    FREE(variant);
 }
 
@@ -2938,6 +2946,8 @@ draw_tcs_llvm_generate(struct draw_llvm *llvm,
    variant_coro = LLVMAddFunction(gallivm->module, func_name_coro, coro_func_type);
 
    variant->function = variant_func;
+   variant->function_name = MALLOC(strlen(func_name)+1);
+   strcpy(variant->function_name, func_name);
    LLVMSetFunctionCallConv(variant_func, LLVMCCallConv);
 
    LLVMSetFunctionCallConv(variant_coro, LLVMCCallConv);
@@ -3188,7 +3198,7 @@ draw_tcs_llvm_create_variant(struct draw_llvm *llvm,
    gallivm_compile_module(variant->gallivm);
 
    variant->jit_func = (draw_tcs_jit_func)
-      gallivm_jit_function(variant->gallivm, variant->function);
+      gallivm_jit_function(variant->gallivm, variant->function, variant->function_name);
 
    if (needs_caching)
       llvm->draw->disk_cache_insert_shader(llvm->draw->disk_cache_cookie,
@@ -3221,6 +3231,8 @@ draw_tcs_llvm_destroy_variant(struct draw_tcs_llvm_variant *variant)
    variant->shader->variants_cached--;
    list_del(&variant->list_item_global.list);
    llvm->nr_tcs_variants--;
+   if(variant->function_name)
+      FREE(variant->function_name);
    FREE(variant);
 }
 
@@ -3503,6 +3515,8 @@ draw_tes_llvm_generate(struct draw_llvm *llvm,
    variant_func = LLVMAddFunction(gallivm->module, func_name, func_type);
 
    variant->function = variant_func;
+   variant->function_name = MALLOC(strlen(func_name)+1);
+   strcpy(variant->function_name, func_name);
    LLVMSetFunctionCallConv(variant_func, LLVMCCallConv);
 
    for (i = 0; i < ARRAY_SIZE(arg_types); ++i)
@@ -3710,7 +3724,7 @@ draw_tes_llvm_create_variant(struct draw_llvm *llvm,
    gallivm_compile_module(variant->gallivm);
 
    variant->jit_func = (draw_tes_jit_func)
-      gallivm_jit_function(variant->gallivm, variant->function);
+      gallivm_jit_function(variant->gallivm, variant->function, variant->function_name);
 
    if (needs_caching)
       llvm->draw->disk_cache_insert_shader(llvm->draw->disk_cache_cookie,
@@ -3743,6 +3757,8 @@ draw_tes_llvm_destroy_variant(struct draw_tes_llvm_variant *variant)
    variant->shader->variants_cached--;
    list_del(&variant->list_item_global.list);
    llvm->nr_tes_variants--;
+   if(variant->function_name)
+      FREE(variant->function_name);
    FREE(variant);
 }
 

src/gallium/auxiliary/draw/draw_llvm.h

@@ -398,6 +398,7 @@ struct draw_llvm_variant
    LLVMTypeRef vertex_header_ptr_type;
 
    LLVMValueRef function;
+   char *function_name;
    draw_jit_vert_func jit_func;
 
    struct llvm_vertex_shader *shader;
@@ -431,6 +432,7 @@ struct draw_gs_llvm_variant
    LLVMValueRef io_ptr;
    LLVMValueRef num_prims;
    LLVMValueRef function;
+   char *function_name;
    draw_gs_jit_func jit_func;
 
    struct llvm_geometry_shader *shader;
@@ -457,6 +459,7 @@ struct draw_tcs_llvm_variant
    /* LLVMValueRef io_ptr; */
    LLVMValueRef num_prims;
    LLVMValueRef function;
+   char *function_name;
    draw_tcs_jit_func jit_func;
 
    struct llvm_tess_ctrl_shader *shader;
@@ -487,6 +490,7 @@ struct draw_tes_llvm_variant
    LLVMValueRef io_ptr;
    LLVMValueRef num_prims;
    LLVMValueRef function;
+   char *function_name;
    draw_tes_jit_func jit_func;
 
    struct llvm_tess_eval_shader *shader;

src/gallium/auxiliary/gallivm/lp_bld_init.c

@@ -470,7 +470,7 @@ gallivm_compile_module(struct gallivm_state *gallivm)
 
 func_pointer
 gallivm_jit_function(struct gallivm_state *gallivm,
-                     LLVMValueRef func)
+                     LLVMValueRef func, const char *func_name)
 {
    void *code;
    func_pointer jit_func;

src/gallium/auxiliary/gallivm/lp_bld_init.h

@@ -102,7 +102,7 @@ gallivm_compile_module(struct gallivm_state *gallivm);
 
 func_pointer
 gallivm_jit_function(struct gallivm_state *gallivm,
-                     LLVMValueRef func);
+                     LLVMValueRef func, const char *func_name);
 
 unsigned gallivm_get_perf_flags(void);
 

src/gallium/drivers/llvmpipe/lp_state_cs.c

@@ -397,6 +397,9 @@ generate_compute(struct llvmpipe_context *lp,
    lp_build_coro_add_presplit(coro);
 
    variant->function = function;
+   variant->function_name = MALLOC(strlen(func_name)+1);
+   strcpy(variant->function_name, func_name);
+
 
    for (i = 0; i < CS_ARG_MAX - !is_mesh; ++i) {
       if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) {
@@ -1013,6 +1016,8 @@ llvmpipe_remove_cs_shader_variant(struct llvmpipe_context *lp,
    lp->nr_cs_variants--;
    lp->nr_cs_instrs -= variant->nr_instrs;
 
+   if(variant->function_name)
+      FREE(variant->function_name);
    FREE(variant);
 }
 
@@ -1274,7 +1279,7 @@ generate_variant(struct llvmpipe_context *lp,
    variant->nr_instrs += lp_build_count_ir_module(variant->gallivm->module);
 
    variant->jit_function = (lp_jit_cs_func)
-      gallivm_jit_function(variant->gallivm, variant->function);
+      gallivm_jit_function(variant->gallivm, variant->function, variant->function_name);
 
    if (needs_caching) {
       lp_disk_cache_insert_shader(screen, &cached, ir_sha1_cache_key);

src/gallium/drivers/llvmpipe/lp_state_cs.h

@@ -91,6 +91,7 @@ struct lp_compute_shader_variant
    LLVMTypeRef jit_vertex_header_ptr_type;
    LLVMTypeRef jit_prim_type;
    LLVMValueRef function;
+   char *function_name;
    lp_jit_cs_func jit_function;
 
    /* Total number of LLVM instructions generated */

src/gallium/drivers/llvmpipe/lp_state_fs.c

@@ -3207,6 +3207,8 @@ generate_fragment(struct llvmpipe_context *lp,
    LLVMSetFunctionCallConv(function, LLVMCCallConv);
 
    variant->function[partial_mask] = function;
+   variant->function_name[partial_mask] = MALLOC(strlen(func_name)+1);
+   strcpy(variant->function_name[partial_mask], func_name);
 
    /* XXX: need to propagate noalias down into color param now we are
     * passing a pointer-to-pointer?
@@ -3921,13 +3923,15 @@ generate_variant(struct llvmpipe_context *lp,
    if (variant->function[RAST_EDGE_TEST]) {
       variant->jit_function[RAST_EDGE_TEST] = (lp_jit_frag_func)
             gallivm_jit_function(variant->gallivm,
-                                 variant->function[RAST_EDGE_TEST]);
+                                 variant->function[RAST_EDGE_TEST],
+                                 variant->function_name[RAST_EDGE_TEST]);
    }
 
    if (variant->function[RAST_WHOLE]) {
       variant->jit_function[RAST_WHOLE] = (lp_jit_frag_func)
          gallivm_jit_function(variant->gallivm,
-                              variant->function[RAST_WHOLE]);
+                              variant->function[RAST_WHOLE],
+                              variant->function_name[RAST_WHOLE]);
    } else if (!variant->jit_function[RAST_WHOLE]) {
       variant->jit_function[RAST_WHOLE] = (lp_jit_frag_func)
          variant->jit_function[RAST_EDGE_TEST];
@@ -3936,7 +3940,8 @@ generate_variant(struct llvmpipe_context *lp,
    if (linear_pipeline) {
       if (variant->linear_function) {
          variant->jit_linear_llvm = (lp_jit_linear_llvm_func)
-            gallivm_jit_function(variant->gallivm, variant->linear_function);
+            gallivm_jit_function(variant->gallivm, variant->linear_function,
+                                 variant->linear_function_name);
       }
 
       /*
@@ -4112,6 +4117,12 @@ llvmpipe_destroy_shader_variant(struct llvmpipe_context *lp,
 {
    gallivm_destroy(variant->gallivm);
    lp_fs_reference(lp, &variant->shader, NULL);
+   if (variant->function_name[RAST_EDGE_TEST])
+      FREE(variant->function_name[RAST_EDGE_TEST]);
+   if (variant->function_name[RAST_WHOLE])
+      FREE(variant->function_name[RAST_WHOLE]);
+   if (variant->linear_function_name)
+      FREE(variant->linear_function_name);
    FREE(variant);
 }
 

src/gallium/drivers/llvmpipe/lp_state_fs.h

@@ -168,6 +168,7 @@ struct lp_fragment_shader_variant
    LLVMTypeRef jit_linear_textures_type;
 
    LLVMValueRef function[2]; // [RAST_WHOLE], [RAST_EDGE_TEST]
+   char *function_name[2];
 
    lp_jit_frag_func jit_function[2]; // [RAST_WHOLE], [RAST_EDGE_TEST]
 
@@ -177,6 +178,7 @@ struct lp_fragment_shader_variant
    /* Functions within the linear path:
     */
    LLVMValueRef linear_function;
+   char *linear_function_name;
    lp_jit_linear_llvm_func jit_linear_llvm;
 
    /* Bitmask to say what cbufs are unswizzled */

src/gallium/drivers/llvmpipe/lp_state_fs_linear_llvm.c

@@ -289,6 +289,8 @@ llvmpipe_fs_variant_linear_llvm(struct llvmpipe_context *lp,
    LLVMSetFunctionCallConv(function, LLVMCCallConv);
 
    variant->linear_function = function;
+   variant->linear_function_name = MALLOC(strlen(func_name)+1);
+   strcpy(variant->linear_function_name, func_name);
 
    /* XXX: need to propagate noalias down into color param now we are
     * passing a pointer-to-pointer?

src/gallium/drivers/llvmpipe/lp_state_setup.c

@@ -688,6 +688,8 @@ generate_setup_variant(struct lp_setup_variant_key *key,
                        arg_types, ARRAY_SIZE(arg_types), 0);
 
    variant->function = LLVMAddFunction(gallivm->module, func_name, func_type);
+   variant->function_name = MALLOC(strlen(func_name)+1);
+   strcpy(variant->function_name, func_name);
    if (!variant->function)
       goto fail;
 
@@ -732,7 +734,7 @@ generate_setup_variant(struct lp_setup_variant_key *key,
    gallivm_compile_module(gallivm);
 
    variant->jit_function = (lp_jit_setup_triangle)
-      gallivm_jit_function(gallivm, variant->function);
+      gallivm_jit_function(gallivm, variant->function, variant->function_name);
    if (!variant->jit_function)
       goto fail;
 
@@ -832,6 +834,7 @@ remove_setup_variant(struct llvmpipe_context *lp,
 
    list_del(&variant->list_item_global.list);
    lp->nr_setup_variants--;
+   FREE(variant->function_name);
    FREE(variant);
 }
 

src/gallium/drivers/llvmpipe/lp_state_setup.h

@@ -66,6 +66,7 @@ struct lp_setup_variant {
     * assembly.
     */
    LLVMValueRef function;
+   char *function_name;
 
    /* The actual generated setup function:
     */

src/gallium/drivers/llvmpipe/lp_test_arit.c

@@ -440,7 +440,7 @@ test_unary(unsigned verbose, FILE *fp, const struct unary_test_t *test, unsigned
 
    gallivm_compile_module(gallivm);
 
-   test_func_jit = (unary_func_t) gallivm_jit_function(gallivm, test_func);
+   test_func_jit = (unary_func_t) gallivm_jit_function(gallivm, test_func, test_name);
 
    gallivm_free_ir(gallivm);
 

src/gallium/drivers/llvmpipe/lp_test_blend.c

@@ -458,7 +458,7 @@ test_one(unsigned verbose,
 
    gallivm_compile_module(gallivm);
 
-   blend_test_ptr = (blend_test_ptr_t)gallivm_jit_function(gallivm, func);
+   blend_test_ptr = (blend_test_ptr_t)gallivm_jit_function(gallivm, func, "test");
 
    gallivm_free_ir(gallivm);
 

src/gallium/drivers/llvmpipe/lp_test_conv.c

@@ -229,7 +229,7 @@ test_one(unsigned verbose,
 
    gallivm_compile_module(gallivm);
 
-   conv_test_ptr = (conv_test_ptr_t)gallivm_jit_function(gallivm, func);
+   conv_test_ptr = (conv_test_ptr_t)gallivm_jit_function(gallivm, func, "test");
 
    gallivm_free_ir(gallivm);
 

src/gallium/drivers/llvmpipe/lp_test_format.c

@@ -44,6 +44,8 @@
 
 #include "lp_test.h"
 
+#define MAX_NAME 64
+
 static struct lp_build_format_cache *cache_ptr;
 
 void
@@ -79,9 +81,9 @@ static LLVMValueRef
 add_fetch_rgba_test(struct gallivm_state *gallivm, unsigned verbose,
                     const struct util_format_description *desc,
                     struct lp_type type,
-                    unsigned use_cache)
+                    unsigned use_cache,
+                    char *name)
 {
-   char name[256];
    LLVMContextRef context = gallivm->context;
    LLVMModuleRef module = gallivm->module;
    LLVMBuilderRef builder = gallivm->builder;
@@ -96,7 +98,7 @@ add_fetch_rgba_test(struct gallivm_state *gallivm, unsigned verbose,
    LLVMValueRef rgba;
    LLVMValueRef cache = NULL;
 
-   snprintf(name, sizeof name, "fetch_%s_%s", desc->short_name,
+   snprintf(name, MAX_NAME * sizeof(char), "fetch_%s_%s", desc->short_name,
             type.floating ? "float" : "unorm8");
 
    args[0] = LLVMPointerType(lp_build_vec_type(gallivm, type), 0);
@@ -142,6 +144,7 @@ test_format_float(unsigned verbose, FILE *fp,
    lp_context_ref context;
    struct gallivm_state *gallivm;
    LLVMValueRef fetch = NULL;
+   char fetch_name[MAX_NAME];
    fetch_ptr_t fetch_ptr;
    alignas(16) uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
    alignas(16) float unpacked[4];
@@ -153,11 +156,11 @@ test_format_float(unsigned verbose, FILE *fp,
    gallivm = gallivm_create("test_module_float", &context, NULL);
 
    fetch = add_fetch_rgba_test(gallivm, verbose, desc,
-                               lp_float32_vec4_type(), use_cache);
+                               lp_float32_vec4_type(), use_cache, fetch_name);
 
    gallivm_compile_module(gallivm);
 
-   fetch_ptr = (fetch_ptr_t) gallivm_jit_function(gallivm, fetch);
+   fetch_ptr = (fetch_ptr_t) gallivm_jit_function(gallivm, fetch, fetch_name);
 
    gallivm_free_ir(gallivm);
 
@@ -243,6 +246,7 @@ test_format_unorm8(unsigned verbose, FILE *fp,
    lp_context_ref context;
    struct gallivm_state *gallivm;
    LLVMValueRef fetch = NULL;
+   char fetch_name[MAX_NAME];
    fetch_ptr_t fetch_ptr;
    alignas(16) uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
    uint8_t unpacked[4];
@@ -254,11 +258,11 @@ test_format_unorm8(unsigned verbose, FILE *fp,
    gallivm = gallivm_create("test_module_unorm8", &context, NULL);
 
    fetch = add_fetch_rgba_test(gallivm, verbose, desc,
-                               lp_unorm8_vec4_type(), use_cache);
+                               lp_unorm8_vec4_type(), use_cache, fetch_name);
 
    gallivm_compile_module(gallivm);
 
-   fetch_ptr = (fetch_ptr_t) gallivm_jit_function(gallivm, fetch);
+   fetch_ptr = (fetch_ptr_t) gallivm_jit_function(gallivm, fetch, fetch_name);
 
    gallivm_free_ir(gallivm);
 

src/gallium/drivers/llvmpipe/lp_test_printf.c

@@ -102,7 +102,7 @@ test_printf(unsigned verbose, FILE *fp,
 
    gallivm_compile_module(gallivm);
 
-   test_printf_func = (test_printf_t) gallivm_jit_function(gallivm, test);
+   test_printf_func = (test_printf_t) gallivm_jit_function(gallivm, test, "test_printf");
 
    gallivm_free_ir(gallivm);
 

src/gallium/drivers/llvmpipe/lp_texture_handle.c

@@ -226,13 +226,14 @@ get_llvm_context(struct llvmpipe_context *ctx)
 
 static void *
 compile_function(struct llvmpipe_context *ctx, struct gallivm_state *gallivm, LLVMValueRef function,
+                 const char *func_name,
                  bool needs_caching,
                  uint8_t cache_key[SHA1_DIGEST_LENGTH])
 {
    gallivm_verify_function(gallivm, function);
    gallivm_compile_module(gallivm);
 
-   void *function_ptr = func_to_pointer(gallivm_jit_function(gallivm, function));
+   void *function_ptr = func_to_pointer(gallivm_jit_function(gallivm, function, func_name));
 
    if (needs_caching)
       lp_disk_cache_insert_shader(llvmpipe_screen(ctx->pipe.screen), gallivm->cache, cache_key);
@@ -365,7 +366,7 @@ compile_image_function(struct llvmpipe_context *ctx, struct lp_static_texture_st
 
    free(image_soa);
 
-   return compile_function(ctx, gallivm, function, needs_caching, cache_key);
+   return compile_function(ctx, gallivm, function, "image", needs_caching, cache_key);
 }
 
 static void *
@@ -518,7 +519,7 @@ compile_sample_function(struct llvmpipe_context *ctx, struct lp_static_texture_s
 
    free(sampler_soa);
 
-   return compile_function(ctx, gallivm, function, needs_caching, cache_key);
+   return compile_function(ctx, gallivm, function, "sample", needs_caching, cache_key);
 }
 
 static uint64_t
@@ -670,7 +671,7 @@ compile_jit_sample_function(struct llvmpipe_context *ctx, uint32_t sample_key)
    LLVMDisposeBuilder(gallivm->builder);
    gallivm->builder = old_builder;
 
-   return compile_function(ctx, gallivm, function, needs_caching, cache_key);
+   return compile_function(ctx, gallivm, function, "sample", needs_caching, cache_key);
 }
 
 static void *
@@ -752,7 +753,7 @@ compile_size_function(struct llvmpipe_context *ctx, struct lp_static_texture_sta
 
    free(sampler_soa);
 
-   return compile_function(ctx, gallivm, function, needs_caching, cache_key);
+   return compile_function(ctx, gallivm, function, "size", needs_caching, cache_key);
 }
 
 static void