1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
// 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 "symbol_conf.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);
}
|
