1// SPDX-License-Identifier: GPL-2.0
  2
  3/*
  4 * Must come before the linux/compiler.h include, which defines several
  5 * macros (e.g. noinline) that conflict with compiler builtins used
  6 * by LLVM.
  7 */
  8#pragma GCC diagnostic push
  9#pragma GCC diagnostic ignored "-Wunused-parameter"  /* Needed for LLVM <= 15 */
 10#include <llvm/DebugInfo/Symbolize/Symbolize.h>
 11#include <llvm/Support/TargetSelect.h>
 12#pragma GCC diagnostic pop
 13
 14#include <inttypes.h>
 15#include <stdio.h>
 16#include <sys/types.h>
 17#include <linux/compiler.h>
 18extern "C" {
 19#include <linux/zalloc.h>
 20}
 21#include "symbol_conf.h"
 22#include "llvm-c-helpers.h"
 23
 24extern "C"
 25char *dso__demangle_sym(struct dso *dso, int kmodule, const char *elf_name);
 26
 27using namespace llvm;
 28using llvm::symbolize::LLVMSymbolizer;
 29
 30/*
 31 * Allocate a static LLVMSymbolizer, which will live to the end of the program.
 32 * Unlike the bfd paths, LLVMSymbolizer has its own cache, so we do not need
 33 * to store anything in the dso struct.
 34 */
 35static LLVMSymbolizer *get_symbolizer()
 36{
 37	static LLVMSymbolizer *instance = nullptr;
 38	if (instance == nullptr) {
 39		LLVMSymbolizer::Options opts;
 40		/*
 41		 * LLVM sometimes demangles slightly different from the rest
 42		 * of the code, and this mismatch can cause new_inline_sym()
 43		 * to get confused and mark non-inline symbol as inlined
 44		 * (since the name does not properly match up with base_sym).
 45		 * Thus, disable the demangling and let the rest of the code
 46		 * handle it.
 47		 */
 48		opts.Demangle = false;
 49		instance = new LLVMSymbolizer(opts);
 50	}
 51	return instance;
 52}
 53
 54/* Returns 0 on error, 1 on success. */
 55static int extract_file_and_line(const DILineInfo &line_info, char **file,
 56				 unsigned int *line)
 57{
 58	if (file) {
 59		if (line_info.FileName == "<invalid>") {
 60			/* Match the convention of libbfd. */
 61			*file = nullptr;
 62		} else {
 63			/* The caller expects to get something it can free(). */
 64			*file = strdup(line_info.FileName.c_str());
 65			if (*file == nullptr)
 66				return 0;
 67		}
 68	}
 69	if (line)
 70		*line = line_info.Line;
 71	return 1;
 72}
 73
 74extern "C"
 75int llvm_addr2line(const char *dso_name, u64 addr,
 76		   char **file, unsigned int *line,
 77		   bool unwind_inlines,
 78		   llvm_a2l_frame **inline_frames)
 79{
 80	LLVMSymbolizer *symbolizer = get_symbolizer();
 81	object::SectionedAddress sectioned_addr = {
 82		addr,
 83		object::SectionedAddress::UndefSection
 84	};
 85
 86	if (unwind_inlines) {
 87		Expected<DIInliningInfo> res_or_err =
 88			symbolizer->symbolizeInlinedCode(dso_name,
 89							 sectioned_addr);
 90		if (!res_or_err)
 91			return 0;
 92		unsigned num_frames = res_or_err->getNumberOfFrames();
 93		if (num_frames == 0)
 94			return 0;
 95
 96		if (extract_file_and_line(res_or_err->getFrame(0),
 97					  file, line) == 0)
 98			return 0;
 99
100		*inline_frames = (llvm_a2l_frame *)calloc(
101			num_frames, sizeof(**inline_frames));
102		if (*inline_frames == nullptr)
103			return 0;
104
105		for (unsigned i = 0; i < num_frames; ++i) {
106			const DILineInfo &src = res_or_err->getFrame(i);
107
108			llvm_a2l_frame &dst = (*inline_frames)[i];
109			if (src.FileName == "<invalid>")
110				/* Match the convention of libbfd. */
111				dst.filename = nullptr;
112			else
113				dst.filename = strdup(src.FileName.c_str());
114			dst.funcname = strdup(src.FunctionName.c_str());
115			dst.line = src.Line;
116
117			if (dst.filename == nullptr ||
118			    dst.funcname == nullptr) {
119				for (unsigned j = 0; j <= i; ++j) {
120					zfree(&(*inline_frames)[j].filename);
121					zfree(&(*inline_frames)[j].funcname);
122				}
123				zfree(inline_frames);
124				return 0;
125			}
126		}
127
128		return num_frames;
129	} else {
130		if (inline_frames)
131			*inline_frames = nullptr;
132
133		Expected<DILineInfo> res_or_err =
134			symbolizer->symbolizeCode(dso_name, sectioned_addr);
135		if (!res_or_err)
136			return 0;
137		return extract_file_and_line(*res_or_err, file, line);
138	}
139}
140
141static char *
142make_symbol_relative_string(struct dso *dso, const char *sym_name,
143			    u64 addr, u64 base_addr)
144{
145	if (!strcmp(sym_name, "<invalid>"))
146		return NULL;
147
148	char *demangled = dso__demangle_sym(dso, 0, sym_name);
149	if (base_addr && base_addr != addr) {
150		char buf[256];
151		snprintf(buf, sizeof(buf), "%s+0x%" PRIx64,
152			 demangled ? demangled : sym_name, addr - base_addr);
153		free(demangled);
154		return strdup(buf);
155	} else {
156		if (demangled)
157			return demangled;
158		else
159			return strdup(sym_name);
160	}
161}
162
163extern "C"
164char *llvm_name_for_code(struct dso *dso, const char *dso_name, u64 addr)
165{
166	LLVMSymbolizer *symbolizer = get_symbolizer();
167	object::SectionedAddress sectioned_addr = {
168		addr,
169		object::SectionedAddress::UndefSection
170	};
171	Expected<DILineInfo> res_or_err =
172		symbolizer->symbolizeCode(dso_name, sectioned_addr);
173	if (!res_or_err) {
174		return NULL;
175	}
176	return make_symbol_relative_string(
177		dso, res_or_err->FunctionName.c_str(),
178		addr, res_or_err->StartAddress ? *res_or_err->StartAddress : 0);
179}
180
181extern "C"
182char *llvm_name_for_data(struct dso *dso, const char *dso_name, u64 addr)
183{
184	LLVMSymbolizer *symbolizer = get_symbolizer();
185	object::SectionedAddress sectioned_addr = {
186		addr,
187		object::SectionedAddress::UndefSection
188	};
189	Expected<DIGlobal> res_or_err =
190		symbolizer->symbolizeData(dso_name, sectioned_addr);
191	if (!res_or_err) {
192		return NULL;
193	}
194	return make_symbol_relative_string(
195		dso, res_or_err->Name.c_str(),
196		addr, res_or_err->Start);
197}