hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

gcov: clang: drop support for clang-10 and older 

LLVM changed the expected function signatures for llvm_gcda_start_file()
and llvm_gcda_emit_function() in the clang-11 release.  Drop the older
implementations and require folks to upgrade their compiler if they're
interested in GCOV support.

Link: https://reviews.llvm.org/rGcdd683b516d147925212724b09ec6fb792a40041
Link: https://reviews.llvm.org/rG13a633b438b6500ecad9e4f936ebadf3411d0f44
Link: https://lkml.kernel.org/r/20210312224132.3413602-3-ndesaulniers@google.com
Link: https://lkml.kernel.org/r/20210413183113.2977432-1-ndesaulniers@google.com
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Suggested-by: Nathan Chancellor <nathan@kernel.org>
Acked-by: Peter Oberparleiter <oberpar@linux.ibm.com>
Reviewed-by: Nathan Chancellor <nathan@kernel.org>
Reviewed-by: Fangrui Song <maskray@google.com>
Cc: Prasad Sodagudi <psodagud@quicinc.com>
Cc: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Nick Desaulniers 2021-05-06 18:04:54 -07:00 committed by Linus Torvalds
parent 1391efa952
commit 9b472e85d0
2 changed files with 1 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
kernel/gcov/Kconfig
View File

@ -4,6 +4,7 @@ menu "GCOV-based kernel profiling"
config GCOV_KERNEL config GCOV_KERNEL
bool "Enable gcov-based kernel profiling" bool "Enable gcov-based kernel profiling"
depends on DEBUG_FS depends on DEBUG_FS
depends on !CC_IS_CLANG || CLANG_VERSION >= 110000
select CONSTRUCTORS select CONSTRUCTORS
default n default n
help help

103
kernel/gcov/clang.c
View File

@ -69,16 +69,10 @@ struct gcov_fn_info {
u32 ident; u32 ident;
u32 checksum; u32 checksum;
#if CONFIG_CLANG_VERSION < 110000
u8 use_extra_checksum;
#endif
u32 cfg_checksum; u32 cfg_checksum;
u32 num_counters; u32 num_counters;
u64 *counters; u64 *counters;
#if CONFIG_CLANG_VERSION < 110000
const char *function_name;
#endif
}; };
static struct gcov_info *current_info; static struct gcov_info *current_info;
@ -108,16 +102,6 @@ void llvm_gcov_init(llvm_gcov_callback writeout, llvm_gcov_callback flush)
} }
EXPORT_SYMBOL(llvm_gcov_init); EXPORT_SYMBOL(llvm_gcov_init);
#if CONFIG_CLANG_VERSION < 110000
void llvm_gcda_start_file(const char *orig_filename, const char version[4],
u32 checksum)
{
current_info->filename = orig_filename;
memcpy(&current_info->version, version, sizeof(current_info->version));
current_info->checksum = checksum;
}
EXPORT_SYMBOL(llvm_gcda_start_file);
#else
void llvm_gcda_start_file(const char *orig_filename, u32 version, u32 checksum) void llvm_gcda_start_file(const char *orig_filename, u32 version, u32 checksum)
{ {
current_info->filename = orig_filename; current_info->filename = orig_filename;
@ -125,28 +109,7 @@ void llvm_gcda_start_file(const char *orig_filename, u32 version, u32 checksum)
current_info->checksum = checksum; current_info->checksum = checksum;
} }
EXPORT_SYMBOL(llvm_gcda_start_file); EXPORT_SYMBOL(llvm_gcda_start_file);
#endif
#if CONFIG_CLANG_VERSION < 110000
void llvm_gcda_emit_function(u32 ident, const char *function_name,
u32 func_checksum, u8 use_extra_checksum, u32 cfg_checksum)
{
struct gcov_fn_info *info = kzalloc(sizeof(*info), GFP_KERNEL);
if (!info)
return;
INIT_LIST_HEAD(&info->head);
info->ident = ident;
info->checksum = func_checksum;
info->use_extra_checksum = use_extra_checksum;
info->cfg_checksum = cfg_checksum;
if (function_name)
info->function_name = kstrdup(function_name, GFP_KERNEL);
list_add_tail(&info->head, &current_info->functions);
}
#else
void llvm_gcda_emit_function(u32 ident, u32 func_checksum, u32 cfg_checksum) void llvm_gcda_emit_function(u32 ident, u32 func_checksum, u32 cfg_checksum)
{ {
struct gcov_fn_info *info = kzalloc(sizeof(*info), GFP_KERNEL); struct gcov_fn_info *info = kzalloc(sizeof(*info), GFP_KERNEL);
@ -160,7 +123,6 @@ void llvm_gcda_emit_function(u32 ident, u32 func_checksum, u32 cfg_checksum)
info->cfg_checksum = cfg_checksum; info->cfg_checksum = cfg_checksum;
list_add_tail(&info->head, &current_info->functions); list_add_tail(&info->head, &current_info->functions);
} }
#endif
EXPORT_SYMBOL(llvm_gcda_emit_function); EXPORT_SYMBOL(llvm_gcda_emit_function);
void llvm_gcda_emit_arcs(u32 num_counters, u64 *counters) void llvm_gcda_emit_arcs(u32 num_counters, u64 *counters)
@ -291,16 +253,8 @@ int gcov_info_is_compatible(struct gcov_info *info1, struct gcov_info *info2)
!list_is_last(&fn_ptr2->head, &info2->functions)) { !list_is_last(&fn_ptr2->head, &info2->functions)) {
if (fn_ptr1->checksum != fn_ptr2->checksum) if (fn_ptr1->checksum != fn_ptr2->checksum)
return false; return false;
#if CONFIG_CLANG_VERSION < 110000
if (fn_ptr1->use_extra_checksum != fn_ptr2->use_extra_checksum)
return false;
if (fn_ptr1->use_extra_checksum &&
fn_ptr1->cfg_checksum != fn_ptr2->cfg_checksum)
return false;
#else
if (fn_ptr1->cfg_checksum != fn_ptr2->cfg_checksum) if (fn_ptr1->cfg_checksum != fn_ptr2->cfg_checksum)
return false; return false;
#endif
fn_ptr1 = list_next_entry(fn_ptr1, head); fn_ptr1 = list_next_entry(fn_ptr1, head);
fn_ptr2 = list_next_entry(fn_ptr2, head); fn_ptr2 = list_next_entry(fn_ptr2, head);
} }
@ -329,35 +283,6 @@ void gcov_info_add(struct gcov_info *dst, struct gcov_info *src)
} }
} }
#if CONFIG_CLANG_VERSION < 110000
static struct gcov_fn_info *gcov_fn_info_dup(struct gcov_fn_info *fn)
{
size_t cv_size; /* counter values size */
struct gcov_fn_info *fn_dup = kmemdup(fn, sizeof(*fn), GFP_KERNEL);
if (!fn_dup)
return NULL;
INIT_LIST_HEAD(&fn_dup->head);
fn_dup->function_name = kstrdup(fn->function_name, GFP_KERNEL);
if (!fn_dup->function_name)
goto err_name;
cv_size = fn->num_counters * sizeof(fn->counters[0]);
fn_dup->counters = kvmalloc(cv_size, GFP_KERNEL);
if (!fn_dup->counters)
goto err_counters;
memcpy(fn_dup->counters, fn->counters, cv_size);
return fn_dup;
err_counters:
kfree(fn_dup->function_name);
err_name:
kfree(fn_dup);
return NULL;
}
#else
static struct gcov_fn_info *gcov_fn_info_dup(struct gcov_fn_info *fn) static struct gcov_fn_info *gcov_fn_info_dup(struct gcov_fn_info *fn)
{ {
size_t cv_size; /* counter values size */ size_t cv_size; /* counter values size */
@ -378,7 +303,6 @@ static struct gcov_fn_info *gcov_fn_info_dup(struct gcov_fn_info *fn)
return fn_dup; return fn_dup;
} }
#endif
/** /**
* gcov_info_dup - duplicate profiling data set * gcov_info_dup - duplicate profiling data set
@ -419,21 +343,6 @@ err:
* gcov_info_free - release memory for profiling data set duplicate * gcov_info_free - release memory for profiling data set duplicate
* @info: profiling data set duplicate to free * @info: profiling data set duplicate to free
*/ */
#if CONFIG_CLANG_VERSION < 110000
void gcov_info_free(struct gcov_info *info)
{
struct gcov_fn_info *fn, *tmp;
list_for_each_entry_safe(fn, tmp, &info->functions, head) {
kfree(fn->function_name);
vfree(fn->counters);
list_del(&fn->head);
kfree(fn);
}
kfree(info->filename);
kfree(info);
}
#else
void gcov_info_free(struct gcov_info *info) void gcov_info_free(struct gcov_info *info)
{ {
struct gcov_fn_info *fn, *tmp; struct gcov_fn_info *fn, *tmp;
@ -446,7 +355,6 @@ void gcov_info_free(struct gcov_info *info)
kfree(info->filename); kfree(info->filename);
kfree(info); kfree(info);
} }
#endif
/** /**
* convert_to_gcda - convert profiling data set to gcda file format * convert_to_gcda - convert profiling data set to gcda file format
@ -469,21 +377,10 @@ size_t convert_to_gcda(char *buffer, struct gcov_info *info)
u32 i; u32 i;
pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION); pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION);
#if CONFIG_CLANG_VERSION < 110000
pos += store_gcov_u32(buffer, pos,
fi_ptr->use_extra_checksum ? 3 : 2);
#else
pos += store_gcov_u32(buffer, pos, 3); pos += store_gcov_u32(buffer, pos, 3);
#endif
pos += store_gcov_u32(buffer, pos, fi_ptr->ident); pos += store_gcov_u32(buffer, pos, fi_ptr->ident);
pos += store_gcov_u32(buffer, pos, fi_ptr->checksum); pos += store_gcov_u32(buffer, pos, fi_ptr->checksum);
#if CONFIG_CLANG_VERSION < 110000
if (fi_ptr->use_extra_checksum)
pos += store_gcov_u32(buffer, pos, fi_ptr->cfg_checksum);
#else
pos += store_gcov_u32(buffer, pos, fi_ptr->cfg_checksum); pos += store_gcov_u32(buffer, pos, fi_ptr->cfg_checksum);
#endif
pos += store_gcov_u32(buffer, pos, GCOV_TAG_COUNTER_BASE); pos += store_gcov_u32(buffer, pos, GCOV_TAG_COUNTER_BASE);
pos += store_gcov_u32(buffer, pos, fi_ptr->num_counters * 2); pos += store_gcov_u32(buffer, pos, fi_ptr->num_counters * 2);
for (i = 0; i < fi_ptr->num_counters; i++) for (i = 0; i < fi_ptr->num_counters; i++)