1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #include <string.h> |
3 | #include "debug.h" |
4 | |
5 | #include "demangle-rust.h" |
6 | |
7 | /* |
8 | * Mangled Rust symbols look like this: |
9 | * |
10 | * _$LT$std..sys..fd..FileDesc$u20$as$u20$core..ops..Drop$GT$::drop::hc68340e1baa4987a |
11 | * |
12 | * The original symbol is: |
13 | * |
14 | * <std::sys::fd::FileDesc as core::ops::Drop>::drop |
15 | * |
16 | * The last component of the path is a 64-bit hash in lowercase hex, prefixed |
17 | * with "h". Rust does not have a global namespace between crates, an illusion |
18 | * which Rust maintains by using the hash to distinguish things that would |
19 | * otherwise have the same symbol. |
20 | * |
21 | * Any path component not starting with a XID_Start character is prefixed with |
22 | * "_". |
23 | * |
24 | * The following escape sequences are used: |
25 | * |
26 | * "," => $C$ |
27 | * "@" => $SP$ |
28 | * "*" => $BP$ |
29 | * "&" => $RF$ |
30 | * "<" => $LT$ |
31 | * ">" => $GT$ |
32 | * "(" => $LP$ |
33 | * ")" => $RP$ |
34 | * " " => $u20$ |
35 | * "'" => $u27$ |
36 | * "[" => $u5b$ |
37 | * "]" => $u5d$ |
38 | * "~" => $u7e$ |
39 | * |
40 | * A double ".." means "::" and a single "." means "-". |
41 | * |
42 | * The only characters allowed in the mangled symbol are a-zA-Z0-9 and _.:$ |
43 | */ |
44 | |
45 | static const char *hash_prefix = "::h" ; |
46 | static const size_t hash_prefix_len = 3; |
47 | static const size_t hash_len = 16; |
48 | |
49 | static bool is_prefixed_hash(const char *start); |
50 | static bool looks_like_rust(const char *sym, size_t len); |
51 | static bool unescape(const char **in, char **out, const char *seq, char value); |
52 | |
53 | /* |
54 | * INPUT: |
55 | * sym: symbol that has been through BFD-demangling |
56 | * |
57 | * This function looks for the following indicators: |
58 | * |
59 | * 1. The hash must consist of "h" followed by 16 lowercase hex digits. |
60 | * |
61 | * 2. As a sanity check, the hash must use between 5 and 15 of the 16 possible |
62 | * hex digits. This is true of 99.9998% of hashes so once in your life you |
63 | * may see a false negative. The point is to notice path components that |
64 | * could be Rust hashes but are probably not, like "haaaaaaaaaaaaaaaa". In |
65 | * this case a false positive (non-Rust symbol has an important path |
66 | * component removed because it looks like a Rust hash) is worse than a |
67 | * false negative (the rare Rust symbol is not demangled) so this sets the |
68 | * balance in favor of false negatives. |
69 | * |
70 | * 3. There must be no characters other than a-zA-Z0-9 and _.:$ |
71 | * |
72 | * 4. There must be no unrecognized $-sign sequences. |
73 | * |
74 | * 5. There must be no sequence of three or more dots in a row ("..."). |
75 | */ |
76 | bool |
77 | rust_is_mangled(const char *sym) |
78 | { |
79 | size_t len, len_without_hash; |
80 | |
81 | if (!sym) |
82 | return false; |
83 | |
84 | len = strlen(sym); |
85 | if (len <= hash_prefix_len + hash_len) |
86 | /* Not long enough to contain "::h" + hash + something else */ |
87 | return false; |
88 | |
89 | len_without_hash = len - (hash_prefix_len + hash_len); |
90 | if (!is_prefixed_hash(start: sym + len_without_hash)) |
91 | return false; |
92 | |
93 | return looks_like_rust(sym, len: len_without_hash); |
94 | } |
95 | |
96 | /* |
97 | * A hash is the prefix "::h" followed by 16 lowercase hex digits. The hex |
98 | * digits must comprise between 5 and 15 (inclusive) distinct digits. |
99 | */ |
100 | static bool is_prefixed_hash(const char *str) |
101 | { |
102 | const char *end; |
103 | bool seen[16]; |
104 | size_t i; |
105 | int count; |
106 | |
107 | if (strncmp(str, hash_prefix, hash_prefix_len)) |
108 | return false; |
109 | str += hash_prefix_len; |
110 | |
111 | memset(seen, false, sizeof(seen)); |
112 | for (end = str + hash_len; str < end; str++) |
113 | if (*str >= '0' && *str <= '9') |
114 | seen[*str - '0'] = true; |
115 | else if (*str >= 'a' && *str <= 'f') |
116 | seen[*str - 'a' + 10] = true; |
117 | else |
118 | return false; |
119 | |
120 | /* Count how many distinct digits seen */ |
121 | count = 0; |
122 | for (i = 0; i < 16; i++) |
123 | if (seen[i]) |
124 | count++; |
125 | |
126 | return count >= 5 && count <= 15; |
127 | } |
128 | |
129 | static bool looks_like_rust(const char *str, size_t len) |
130 | { |
131 | const char *end = str + len; |
132 | |
133 | while (str < end) |
134 | switch (*str) { |
135 | case '$': |
136 | if (!strncmp(str, "$C$" , 3)) |
137 | str += 3; |
138 | else if (!strncmp(str, "$SP$" , 4) |
139 | || !strncmp(str, "$BP$" , 4) |
140 | || !strncmp(str, "$RF$" , 4) |
141 | || !strncmp(str, "$LT$" , 4) |
142 | || !strncmp(str, "$GT$" , 4) |
143 | || !strncmp(str, "$LP$" , 4) |
144 | || !strncmp(str, "$RP$" , 4)) |
145 | str += 4; |
146 | else if (!strncmp(str, "$u20$" , 5) |
147 | || !strncmp(str, "$u27$" , 5) |
148 | || !strncmp(str, "$u5b$" , 5) |
149 | || !strncmp(str, "$u5d$" , 5) |
150 | || !strncmp(str, "$u7e$" , 5)) |
151 | str += 5; |
152 | else |
153 | return false; |
154 | break; |
155 | case '.': |
156 | /* Do not allow three or more consecutive dots */ |
157 | if (!strncmp(str, "..." , 3)) |
158 | return false; |
159 | /* Fall through */ |
160 | case 'a' ... 'z': |
161 | case 'A' ... 'Z': |
162 | case '0' ... '9': |
163 | case '_': |
164 | case ':': |
165 | str++; |
166 | break; |
167 | default: |
168 | return false; |
169 | } |
170 | |
171 | return true; |
172 | } |
173 | |
174 | /* |
175 | * INPUT: |
176 | * sym: symbol for which rust_is_mangled(sym) returns true |
177 | * |
178 | * The input is demangled in-place because the mangled name is always longer |
179 | * than the demangled one. |
180 | */ |
181 | void |
182 | rust_demangle_sym(char *sym) |
183 | { |
184 | const char *in; |
185 | char *out; |
186 | const char *end; |
187 | |
188 | if (!sym) |
189 | return; |
190 | |
191 | in = sym; |
192 | out = sym; |
193 | end = sym + strlen(sym) - (hash_prefix_len + hash_len); |
194 | |
195 | while (in < end) |
196 | switch (*in) { |
197 | case '$': |
198 | if (!(unescape(in: &in, out: &out, seq: "$C$" , value: ',') |
199 | || unescape(in: &in, out: &out, seq: "$SP$" , value: '@') |
200 | || unescape(in: &in, out: &out, seq: "$BP$" , value: '*') |
201 | || unescape(in: &in, out: &out, seq: "$RF$" , value: '&') |
202 | || unescape(in: &in, out: &out, seq: "$LT$" , value: '<') |
203 | || unescape(in: &in, out: &out, seq: "$GT$" , value: '>') |
204 | || unescape(in: &in, out: &out, seq: "$LP$" , value: '(') |
205 | || unescape(in: &in, out: &out, seq: "$RP$" , value: ')') |
206 | || unescape(in: &in, out: &out, seq: "$u20$" , value: ' ') |
207 | || unescape(in: &in, out: &out, seq: "$u27$" , value: '\'') |
208 | || unescape(in: &in, out: &out, seq: "$u5b$" , value: '[') |
209 | || unescape(in: &in, out: &out, seq: "$u5d$" , value: ']') |
210 | || unescape(in: &in, out: &out, seq: "$u7e$" , value: '~'))) { |
211 | pr_err("demangle-rust: unexpected escape sequence" ); |
212 | goto done; |
213 | } |
214 | break; |
215 | case '_': |
216 | /* |
217 | * If this is the start of a path component and the next |
218 | * character is an escape sequence, ignore the |
219 | * underscore. The mangler inserts an underscore to make |
220 | * sure the path component begins with a XID_Start |
221 | * character. |
222 | */ |
223 | if ((in == sym || in[-1] == ':') && in[1] == '$') |
224 | in++; |
225 | else |
226 | *out++ = *in++; |
227 | break; |
228 | case '.': |
229 | if (in[1] == '.') { |
230 | /* ".." becomes "::" */ |
231 | *out++ = ':'; |
232 | *out++ = ':'; |
233 | in += 2; |
234 | } else { |
235 | /* "." becomes "-" */ |
236 | *out++ = '-'; |
237 | in++; |
238 | } |
239 | break; |
240 | case 'a' ... 'z': |
241 | case 'A' ... 'Z': |
242 | case '0' ... '9': |
243 | case ':': |
244 | *out++ = *in++; |
245 | break; |
246 | default: |
247 | pr_err("demangle-rust: unexpected character '%c' in symbol\n" , |
248 | *in); |
249 | goto done; |
250 | } |
251 | |
252 | done: |
253 | *out = '\0'; |
254 | } |
255 | |
256 | static bool unescape(const char **in, char **out, const char *seq, char value) |
257 | { |
258 | size_t len = strlen(seq); |
259 | |
260 | if (strncmp(*in, seq, len)) |
261 | return false; |
262 | |
263 | **out = value; |
264 | |
265 | *in += len; |
266 | *out += 1; |
267 | |
268 | return true; |
269 | } |
270 | |