File: rust-demangle.c

package info (click to toggle)
gdb 8.2.1-2
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 223,696 kB
  • sloc: ansic: 1,936,156; asm: 341,757; exp: 146,606; makefile: 56,749; sh: 23,776; cpp: 20,830; yacc: 12,914; perl: 5,331; ada: 4,977; python: 4,617; xml: 4,176; pascal: 3,134; lisp: 1,527; cs: 879; lex: 620; f90: 479; sed: 228; awk: 140; objc: 134; fortran: 43
file content (348 lines) | stat: -rw-r--r-- 10,024 bytes parent folder | download | duplicates (11)
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
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
/* Demangler for the Rust programming language
   Copyright (C) 2016-2018 Free Software Foundation, Inc.
   Written by David Tolnay (dtolnay@gmail.com).

This file is part of the libiberty library.
Libiberty is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.

In addition to the permissions in the GNU Library General Public
License, the Free Software Foundation gives you unlimited permission
to link the compiled version of this file into combinations with other
programs, and to distribute those combinations without any restriction
coming from the use of this file.  (The Library Public License
restrictions do apply in other respects; for example, they cover
modification of the file, and distribution when not linked into a
combined executable.)

Libiberty is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with libiberty; see the file COPYING.LIB.
If not, see <http://www.gnu.org/licenses/>.  */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "safe-ctype.h"

#include <sys/types.h>
#include <string.h>
#include <stdio.h>

#ifdef HAVE_STRING_H
#include <string.h>
#else
extern size_t strlen(const char *s);
extern int strncmp(const char *s1, const char *s2, size_t n);
extern void *memset(void *s, int c, size_t n);
#endif

#include <demangle.h>
#include "libiberty.h"


/* Mangled Rust symbols look like this:
     _$LT$std..sys..fd..FileDesc$u20$as$u20$core..ops..Drop$GT$::drop::hc68340e1baa4987a

   The original symbol is:
     <std::sys::fd::FileDesc as core::ops::Drop>::drop

   The last component of the path is a 64-bit hash in lowercase hex,
   prefixed with "h". Rust does not have a global namespace between
   crates, an illusion which Rust maintains by using the hash to
   distinguish things that would otherwise have the same symbol.

   Any path component not starting with a XID_Start character is
   prefixed with "_".

   The following escape sequences are used:

   ","  =>  $C$
   "@"  =>  $SP$
   "*"  =>  $BP$
   "&"  =>  $RF$
   "<"  =>  $LT$
   ">"  =>  $GT$
   "("  =>  $LP$
   ")"  =>  $RP$
   " "  =>  $u20$
   "\"" =>  $u22$
   "'"  =>  $u27$
   "+"  =>  $u2b$
   ";"  =>  $u3b$
   "["  =>  $u5b$
   "]"  =>  $u5d$
   "{"  =>  $u7b$
   "}"  =>  $u7d$
   "~"  =>  $u7e$

   A double ".." means "::" and a single "." means "-".

   The only characters allowed in the mangled symbol are a-zA-Z0-9 and _.:$  */

static const char *hash_prefix = "::h";
static const size_t hash_prefix_len = 3;
static const size_t hash_len = 16;

static int is_prefixed_hash (const char *start);
static int looks_like_rust (const char *sym, size_t len);
static int unescape (const char **in, char **out, const char *seq, char value);

/* INPUT: sym: symbol that has been through C++ (gnu v3) demangling

   This function looks for the following indicators:

   1. The hash must consist of "h" followed by 16 lowercase hex digits.

   2. As a sanity check, the hash must use between 5 and 15 of the 16
      possible hex digits. This is true of 99.9998% of hashes so once
      in your life you may see a false negative. The point is to
      notice path components that could be Rust hashes but are
      probably not, like "haaaaaaaaaaaaaaaa". In this case a false
      positive (non-Rust symbol has an important path component
      removed because it looks like a Rust hash) is worse than a false
      negative (the rare Rust symbol is not demangled) so this sets
      the balance in favor of false negatives.

   3. There must be no characters other than a-zA-Z0-9 and _.:$

   4. There must be no unrecognized $-sign sequences.

   5. There must be no sequence of three or more dots in a row ("...").  */

int
rust_is_mangled (const char *sym)
{
  size_t len, len_without_hash;

  if (!sym)
    return 0;

  len = strlen (sym);
  if (len <= hash_prefix_len + hash_len)
    /* Not long enough to contain "::h" + hash + something else */
    return 0;

  len_without_hash = len - (hash_prefix_len + hash_len);
  if (!is_prefixed_hash (sym + len_without_hash))
    return 0;

  return looks_like_rust (sym, len_without_hash);
}

/* A hash is the prefix "::h" followed by 16 lowercase hex digits. The
   hex digits must comprise between 5 and 15 (inclusive) distinct
   digits.  */

static int
is_prefixed_hash (const char *str)
{
  const char *end;
  char seen[16];
  size_t i;
  int count;

  if (strncmp (str, hash_prefix, hash_prefix_len))
    return 0;
  str += hash_prefix_len;

  memset (seen, 0, sizeof(seen));
  for (end = str + hash_len; str < end; str++)
    if (*str >= '0' && *str <= '9')
      seen[*str - '0'] = 1;
    else if (*str >= 'a' && *str <= 'f')
      seen[*str - 'a' + 10] = 1;
    else
      return 0;

  /* Count how many distinct digits seen */
  count = 0;
  for (i = 0; i < 16; i++)
    if (seen[i])
      count++;

  return count >= 5 && count <= 15;
}

static int
looks_like_rust (const char *str, size_t len)
{
  const char *end = str + len;

  while (str < end)
    switch (*str)
      {
      case '$':
	if (!strncmp (str, "$C$", 3))
	  str += 3;
	else if (!strncmp (str, "$SP$", 4)
		 || !strncmp (str, "$BP$", 4)
		 || !strncmp (str, "$RF$", 4)
		 || !strncmp (str, "$LT$", 4)
		 || !strncmp (str, "$GT$", 4)
		 || !strncmp (str, "$LP$", 4)
		 || !strncmp (str, "$RP$", 4))
	  str += 4;
	else if (!strncmp (str, "$u20$", 5)
		 || !strncmp (str, "$u22$", 5)
		 || !strncmp (str, "$u27$", 5)
		 || !strncmp (str, "$u2b$", 5)
		 || !strncmp (str, "$u3b$", 5)
		 || !strncmp (str, "$u5b$", 5)
		 || !strncmp (str, "$u5d$", 5)
		 || !strncmp (str, "$u7b$", 5)
		 || !strncmp (str, "$u7d$", 5)
		 || !strncmp (str, "$u7e$", 5))
	  str += 5;
	else
	  return 0;
	break;
      case '.':
	/* Do not allow three or more consecutive dots */
	if (!strncmp (str, "...", 3))
	  return 0;
	/* Fall through */
      case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
      case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
      case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
      case 's': case 't': case 'u': case 'v': case 'w': case 'x':
      case 'y': case 'z':
      case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
      case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
      case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
      case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
      case 'Y': case 'Z':
      case '0': case '1': case '2': case '3': case '4': case '5':
      case '6': case '7': case '8': case '9':
      case '_':
      case ':':
	str++;
	break;
      default:
	return 0;
      }

  return 1;
}

/*
  INPUT: sym: symbol for which rust_is_mangled(sym) returned 1.

  The input is demangled in-place because the mangled name is always
  longer than the demangled one.  */

void
rust_demangle_sym (char *sym)
{
  const char *in;
  char *out;
  const char *end;

  if (!sym)
    return;

  in = sym;
  out = sym;
  end = sym + strlen (sym) - (hash_prefix_len + hash_len);

  while (in < end)
    switch (*in)
      {
      case '$':
	if (!(unescape (&in, &out, "$C$", ',')
	      || unescape (&in, &out, "$SP$", '@')
	      || unescape (&in, &out, "$BP$", '*')
	      || unescape (&in, &out, "$RF$", '&')
	      || unescape (&in, &out, "$LT$", '<')
	      || unescape (&in, &out, "$GT$", '>')
	      || unescape (&in, &out, "$LP$", '(')
	      || unescape (&in, &out, "$RP$", ')')
	      || unescape (&in, &out, "$u20$", ' ')
	      || unescape (&in, &out, "$u22$", '\"')
	      || unescape (&in, &out, "$u27$", '\'')
	      || unescape (&in, &out, "$u2b$", '+')
	      || unescape (&in, &out, "$u3b$", ';')
	      || unescape (&in, &out, "$u5b$", '[')
	      || unescape (&in, &out, "$u5d$", ']')
	      || unescape (&in, &out, "$u7b$", '{')
	      || unescape (&in, &out, "$u7d$", '}')
	      || unescape (&in, &out, "$u7e$", '~'))) {
	  /* unexpected escape sequence, not looks_like_rust. */
	  goto fail;
	}
	break;
      case '_':
	/* If this is the start of a path component and the next
	   character is an escape sequence, ignore the underscore. The
	   mangler inserts an underscore to make sure the path
	   component begins with a XID_Start character. */
	if ((in == sym || in[-1] == ':') && in[1] == '$')
	  in++;
	else
	  *out++ = *in++;
	break;
      case '.':
	if (in[1] == '.')
	  {
	    /* ".." becomes "::" */
	    *out++ = ':';
	    *out++ = ':';
	    in += 2;
	  }
	else
	  {
	    /* "." becomes "-" */
	    *out++ = '-';
	    in++;
	  }
	break;
      case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
      case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
      case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
      case 's': case 't': case 'u': case 'v': case 'w': case 'x':
      case 'y': case 'z':
      case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
      case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
      case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
      case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
      case 'Y': case 'Z':
      case '0': case '1': case '2': case '3': case '4': case '5':
      case '6': case '7': case '8': case '9':
      case ':':
	*out++ = *in++;
	break;
      default:
	/* unexpected character in symbol, not looks_like_rust.  */
	goto fail;
      }
  goto done;

fail:
  *out++ = '?'; /* This is pretty lame, but it's hard to do better. */
done:
  *out = '\0';
}

static int
unescape (const char **in, char **out, const char *seq, char value)
{
  size_t len = strlen (seq);

  if (strncmp (*in, seq, len))
    return 0;

  **out = value;

  *in += len;
  *out += 1;

  return 1;
}