// SPDX-License-Identifier: GPL-2.0 /* * Must come before the linux/compiler.h include, which defines several * macros (e.g. noinline) that conflict with compiler builtins used * by LLVM. */#pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wunused-parameter"  /* Needed for LLVM <= 15 */#include <llvm/DebugInfo/Symbolize/Symbolize.h>#include <llvm/Support/TargetSelect.h>#pragma GCC diagnostic pop #include <inttypes.h>#include <stdio.h>#include <sys/types.h>#include <linux/compiler.h>extern "C" {#include <linux/zalloc.h>}#include "llvm-c-helpers.h" extern "C"char *dso__demangle_sym(struct dso *dso, int kmodule, const char *elf_name); using namespace llvm;using llvm::symbolize::LLVMSymbolizer; /* * Allocate a static LLVMSymbolizer, which will live to the end of the program. * Unlike the bfd paths, LLVMSymbolizer has its own cache, so we do not need * to store anything in the dso struct. */static LLVMSymbolizer *get_symbolizer(){	static LLVMSymbolizer *instance = nullptr;	if (instance == nullptr) {		LLVMSymbolizer::Options opts;		/*		 * LLVM sometimes demangles slightly different from the rest		 * of the code, and this mismatch can cause new_inline_sym()		 * to get confused and mark non-inline symbol as inlined		 * (since the name does not properly match up with base_sym).		 * Thus, disable the demangling and let the rest of the code		 * handle it.		 */		opts.Demangle = false;		instance = new LLVMSymbolizer(opts);	}	return instance;} /* Returns 0 on error, 1 on success. */static int extract_file_and_line(const DILineInfo &line_info, char **file,				 unsigned int *line){	if (file) {		if (line_info.FileName == "<invalid>") {			/* Match the convention of libbfd. */			*file = nullptr;		} else {			/* The caller expects to get something it can free(). */			*file = strdup(line_info.FileName.c_str());			if (*file == nullptr)				return 0;		}	}	if (line)		*line = line_info.Line;	return 1;} extern "C"int llvm_addr2line(const char *dso_name, u64 addr,		   char **file, unsigned int *line,		   bool unwind_inlines,		   llvm_a2l_frame **inline_frames){	LLVMSymbolizer *symbolizer = get_symbolizer();	object::SectionedAddress sectioned_addr = {		addr,		object::SectionedAddress::UndefSection	}; 	if (unwind_inlines) {		Expected<DIInliningInfo> res_or_err =			symbolizer->symbolizeInlinedCode(dso_name,							 sectioned_addr);		if (!res_or_err)			return 0;		unsigned num_frames = res_or_err->getNumberOfFrames();		if (num_frames == 0)			return 0; 		if (extract_file_and_line(res_or_err->getFrame(0),					  file, line) == 0)			return 0; 		*inline_frames = (llvm_a2l_frame *)calloc(			num_frames, sizeof(**inline_frames));		if (*inline_frames == nullptr)			return 0; 		for (unsigned i = 0; i < num_frames; ++i) {			const DILineInfo &src = res_or_err->getFrame(i); 			llvm_a2l_frame &dst = (*inline_frames)[i];			if (src.FileName == "<invalid>")				/* Match the convention of libbfd. */				dst.filename = nullptr;			else				dst.filename = strdup(src.FileName.c_str());			dst.funcname = strdup(src.FunctionName.c_str());			dst.line = src.Line; 			if (dst.filename == nullptr ||			    dst.funcname == nullptr) {				for (unsigned j = 0; j <= i; ++j) {					zfree(&(*inline_frames)[j].filename);					zfree(&(*inline_frames)[j].funcname);				}				zfree(inline_frames);				return 0;			}		} 		return num_frames;	} else {		if (inline_frames)			*inline_frames = nullptr; 		Expected<DILineInfo> res_or_err =			symbolizer->symbolizeCode(dso_name, sectioned_addr);		if (!res_or_err)			return 0;		return extract_file_and_line(*res_or_err, file, line);	}} static char *make_symbol_relative_string(struct dso *dso, const char *sym_name,			    u64 addr, u64 base_addr){	if (!strcmp(sym_name, "<invalid>"))		return NULL; 	char *demangled = dso__demangle_sym(dso, 0, sym_name);	if (base_addr && base_addr != addr) {		char buf[256];		snprintf(buf, sizeof(buf), "%s+0x%" PRIx64,			 demangled ? demangled : sym_name, addr - base_addr);		free(demangled);		return strdup(buf);	} else {		if (demangled)			return demangled;		else			return strdup(sym_name);	}} extern "C"char *llvm_name_for_code(struct dso *dso, const char *dso_name, u64 addr){	LLVMSymbolizer *symbolizer = get_symbolizer();	object::SectionedAddress sectioned_addr = {		addr,		object::SectionedAddress::UndefSection	};	Expected<DILineInfo> res_or_err =		symbolizer->symbolizeCode(dso_name, sectioned_addr);	if (!res_or_err) {		return NULL;	}	return make_symbol_relative_string(		dso, res_or_err->FunctionName.c_str(),		addr, res_or_err->StartAddress ? *res_or_err->StartAddress : 0);} extern "C"char *llvm_name_for_data(struct dso *dso, const char *dso_name, u64 addr){	LLVMSymbolizer *symbolizer = get_symbolizer();	object::SectionedAddress sectioned_addr = {		addr,		object::SectionedAddress::UndefSection	};	Expected<DIGlobal> res_or_err =		symbolizer->symbolizeData(dso_name, sectioned_addr);	if (!res_or_err) {		return NULL;	}	return make_symbol_relative_string(		dso, res_or_err->Name.c_str(),		addr, res_or_err->Start);}