]> Git Repo - J-linux.git/blob - tools/perf/util/llvm-c-helpers.cpp
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / tools / perf / util / llvm-c-helpers.cpp
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>
18 extern "C" {
19 #include <linux/zalloc.h>
20 }
21 #include "symbol_conf.h"
22 #include "llvm-c-helpers.h"
23
24 extern "C"
25 char *dso__demangle_sym(struct dso *dso, int kmodule, const char *elf_name);
26
27 using namespace llvm;
28 using 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  */
35 static 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. */
55 static 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
74 extern "C"
75 int 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
141 static char *
142 make_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
163 extern "C"
164 char *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
181 extern "C"
182 char *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 }
This page took 0.037845 seconds and 4 git commands to generate.