pa.c (hppa_profile_hook): Remove offset adjustment.
[official-gcc.git] / libiberty / cplus-dem.c
blobafceed2a1a751155fcfa4cbccd4e12e3f0377c34
1 /* Demangler for GNU C++
2 Copyright (C) 1989-2019 Free Software Foundation, Inc.
3 Written by James Clark (jjc@jclark.uucp)
4 Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
5 Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
7 This file is part of the libiberty library.
8 Libiberty is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Library General Public
10 License as published by the Free Software Foundation; either
11 version 2 of the License, or (at your option) any later version.
13 In addition to the permissions in the GNU Library General Public
14 License, the Free Software Foundation gives you unlimited permission
15 to link the compiled version of this file into combinations with other
16 programs, and to distribute those combinations without any restriction
17 coming from the use of this file. (The Library Public License
18 restrictions do apply in other respects; for example, they cover
19 modification of the file, and distribution when not linked into a
20 combined executable.)
22 Libiberty is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 Library General Public License for more details.
27 You should have received a copy of the GNU Library General Public
28 License along with libiberty; see the file COPYING.LIB. If
29 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
30 Boston, MA 02110-1301, USA. */
32 /* This file lives in both GCC and libiberty. When making changes, please
33 try not to break either. */
35 #ifdef HAVE_CONFIG_H
36 #include "config.h"
37 #endif
39 #include "safe-ctype.h"
41 #include <string.h>
43 #ifdef HAVE_STDLIB_H
44 #include <stdlib.h>
45 #else
46 void * malloc ();
47 void * realloc ();
48 #endif
50 #include <demangle.h>
51 #undef CURRENT_DEMANGLING_STYLE
52 #define CURRENT_DEMANGLING_STYLE options
54 #include "libiberty.h"
56 enum demangling_styles current_demangling_style = auto_demangling;
58 const struct demangler_engine libiberty_demanglers[] =
61 NO_DEMANGLING_STYLE_STRING,
62 no_demangling,
63 "Demangling disabled"
67 AUTO_DEMANGLING_STYLE_STRING,
68 auto_demangling,
69 "Automatic selection based on executable"
73 GNU_V3_DEMANGLING_STYLE_STRING,
74 gnu_v3_demangling,
75 "GNU (g++) V3 (Itanium C++ ABI) style demangling"
79 JAVA_DEMANGLING_STYLE_STRING,
80 java_demangling,
81 "Java style demangling"
85 GNAT_DEMANGLING_STYLE_STRING,
86 gnat_demangling,
87 "GNAT style demangling"
91 DLANG_DEMANGLING_STYLE_STRING,
92 dlang_demangling,
93 "DLANG style demangling"
97 RUST_DEMANGLING_STYLE_STRING,
98 rust_demangling,
99 "Rust style demangling"
103 NULL, unknown_demangling, NULL
107 /* Add a routine to set the demangling style to be sure it is valid and
108 allow for any demangler initialization that maybe necessary. */
110 enum demangling_styles
111 cplus_demangle_set_style (enum demangling_styles style)
113 const struct demangler_engine *demangler = libiberty_demanglers;
115 for (; demangler->demangling_style != unknown_demangling; ++demangler)
116 if (style == demangler->demangling_style)
118 current_demangling_style = style;
119 return current_demangling_style;
122 return unknown_demangling;
125 /* Do string name to style translation */
127 enum demangling_styles
128 cplus_demangle_name_to_style (const char *name)
130 const struct demangler_engine *demangler = libiberty_demanglers;
132 for (; demangler->demangling_style != unknown_demangling; ++demangler)
133 if (strcmp (name, demangler->demangling_style_name) == 0)
134 return demangler->demangling_style;
136 return unknown_demangling;
139 /* char *cplus_demangle (const char *mangled, int options)
141 If MANGLED is a mangled function name produced by GNU C++, then
142 a pointer to a @code{malloc}ed string giving a C++ representation
143 of the name will be returned; otherwise NULL will be returned.
144 It is the caller's responsibility to free the string which
145 is returned.
147 Note that any leading underscores, or other such characters prepended by
148 the compilation system, are presumed to have already been stripped from
149 MANGLED. */
151 char *
152 cplus_demangle (const char *mangled, int options)
154 char *ret;
156 if (current_demangling_style == no_demangling)
157 return xstrdup (mangled);
159 if ((options & DMGL_STYLE_MASK) == 0)
160 options |= (int) current_demangling_style & DMGL_STYLE_MASK;
162 /* The V3 ABI demangling is implemented elsewhere. */
163 if (GNU_V3_DEMANGLING || RUST_DEMANGLING || AUTO_DEMANGLING)
165 ret = cplus_demangle_v3 (mangled, options);
166 if (GNU_V3_DEMANGLING)
167 return ret;
169 if (ret)
171 /* Rust symbols are GNU_V3 mangled plus some extra subtitutions.
172 The subtitutions are always smaller, so do in place changes. */
173 if (rust_is_mangled (ret))
174 rust_demangle_sym (ret);
175 else if (RUST_DEMANGLING)
177 free (ret);
178 ret = NULL;
182 if (ret || RUST_DEMANGLING)
183 return ret;
186 if (JAVA_DEMANGLING)
188 ret = java_demangle_v3 (mangled);
189 if (ret)
190 return ret;
193 if (GNAT_DEMANGLING)
194 return ada_demangle (mangled, options);
196 if (DLANG_DEMANGLING)
198 ret = dlang_demangle (mangled, options);
199 if (ret)
200 return ret;
203 return (ret);
206 char *
207 rust_demangle (const char *mangled, int options)
209 /* Rust symbols are GNU_V3 mangled plus some extra subtitutions. */
210 char *ret = cplus_demangle_v3 (mangled, options);
212 /* The Rust subtitutions are always smaller, so do in place changes. */
213 if (ret != NULL)
215 if (rust_is_mangled (ret))
216 rust_demangle_sym (ret);
217 else
219 free (ret);
220 ret = NULL;
224 return ret;
227 /* Demangle ada names. The encoding is documented in gcc/ada/exp_dbug.ads. */
229 char *
230 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
232 int len0;
233 const char* p;
234 char *d;
235 char *demangled = NULL;
237 /* Discard leading _ada_, which is used for library level subprograms. */
238 if (strncmp (mangled, "_ada_", 5) == 0)
239 mangled += 5;
241 /* All ada unit names are lower-case. */
242 if (!ISLOWER (mangled[0]))
243 goto unknown;
245 /* Most of the demangling will trivially remove chars. Operator names
246 may add one char but because they are always preceeded by '__' which is
247 replaced by '.', they eventually never expand the size.
248 A few special names such as '___elabs' add a few chars (at most 7), but
249 they occur only once. */
250 len0 = strlen (mangled) + 7 + 1;
251 demangled = XNEWVEC (char, len0);
253 d = demangled;
254 p = mangled;
255 while (1)
257 /* An entity names is expected. */
258 if (ISLOWER (*p))
260 /* An identifier, which is always lower case. */
262 *d++ = *p++;
263 while (ISLOWER(*p) || ISDIGIT (*p)
264 || (p[0] == '_' && (ISLOWER (p[1]) || ISDIGIT (p[1]))));
266 else if (p[0] == 'O')
268 /* An operator name. */
269 static const char * const operators[][2] =
270 {{"Oabs", "abs"}, {"Oand", "and"}, {"Omod", "mod"},
271 {"Onot", "not"}, {"Oor", "or"}, {"Orem", "rem"},
272 {"Oxor", "xor"}, {"Oeq", "="}, {"One", "/="},
273 {"Olt", "<"}, {"Ole", "<="}, {"Ogt", ">"},
274 {"Oge", ">="}, {"Oadd", "+"}, {"Osubtract", "-"},
275 {"Oconcat", "&"}, {"Omultiply", "*"}, {"Odivide", "/"},
276 {"Oexpon", "**"}, {NULL, NULL}};
277 int k;
279 for (k = 0; operators[k][0] != NULL; k++)
281 size_t slen = strlen (operators[k][0]);
282 if (strncmp (p, operators[k][0], slen) == 0)
284 p += slen;
285 slen = strlen (operators[k][1]);
286 *d++ = '"';
287 memcpy (d, operators[k][1], slen);
288 d += slen;
289 *d++ = '"';
290 break;
293 /* Operator not found. */
294 if (operators[k][0] == NULL)
295 goto unknown;
297 else
299 /* Not a GNAT encoding. */
300 goto unknown;
303 /* The name can be directly followed by some uppercase letters. */
304 if (p[0] == 'T' && p[1] == 'K')
306 /* Task stuff. */
307 if (p[2] == 'B' && p[3] == 0)
309 /* Subprogram for task body. */
310 break;
312 else if (p[2] == '_' && p[3] == '_')
314 /* Inner declarations in a task. */
315 p += 4;
316 *d++ = '.';
317 continue;
319 else
320 goto unknown;
322 if (p[0] == 'E' && p[1] == 0)
324 /* Exception name. */
325 goto unknown;
327 if ((p[0] == 'P' || p[0] == 'N') && p[1] == 0)
329 /* Protected type subprogram. */
330 break;
332 if ((*p == 'N' || *p == 'S') && p[1] == 0)
334 /* Enumerated type name table. */
335 goto unknown;
337 if (p[0] == 'X')
339 /* Body nested. */
340 p++;
341 while (p[0] == 'n' || p[0] == 'b')
342 p++;
344 if (p[0] == 'S' && p[1] != 0 && (p[2] == '_' || p[2] == 0))
346 /* Stream operations. */
347 const char *name;
348 switch (p[1])
350 case 'R':
351 name = "'Read";
352 break;
353 case 'W':
354 name = "'Write";
355 break;
356 case 'I':
357 name = "'Input";
358 break;
359 case 'O':
360 name = "'Output";
361 break;
362 default:
363 goto unknown;
365 p += 2;
366 strcpy (d, name);
367 d += strlen (name);
369 else if (p[0] == 'D')
371 /* Controlled type operation. */
372 const char *name;
373 switch (p[1])
375 case 'F':
376 name = ".Finalize";
377 break;
378 case 'A':
379 name = ".Adjust";
380 break;
381 default:
382 goto unknown;
384 strcpy (d, name);
385 d += strlen (name);
386 break;
389 if (p[0] == '_')
391 /* Separator. */
392 if (p[1] == '_')
394 /* Standard separator. Handled first. */
395 p += 2;
397 if (ISDIGIT (*p))
399 /* Overloading number. */
401 p++;
402 while (ISDIGIT (*p) || (p[0] == '_' && ISDIGIT (p[1])));
403 if (*p == 'X')
405 p++;
406 while (p[0] == 'n' || p[0] == 'b')
407 p++;
410 else if (p[0] == '_' && p[1] != '_')
412 /* Special names. */
413 static const char * const special[][2] = {
414 { "_elabb", "'Elab_Body" },
415 { "_elabs", "'Elab_Spec" },
416 { "_size", "'Size" },
417 { "_alignment", "'Alignment" },
418 { "_assign", ".\":=\"" },
419 { NULL, NULL }
421 int k;
423 for (k = 0; special[k][0] != NULL; k++)
425 size_t slen = strlen (special[k][0]);
426 if (strncmp (p, special[k][0], slen) == 0)
428 p += slen;
429 slen = strlen (special[k][1]);
430 memcpy (d, special[k][1], slen);
431 d += slen;
432 break;
435 if (special[k][0] != NULL)
436 break;
437 else
438 goto unknown;
440 else
442 *d++ = '.';
443 continue;
446 else if (p[1] == 'B' || p[1] == 'E')
448 /* Entry Body or barrier Evaluation. */
449 p += 2;
450 while (ISDIGIT (*p))
451 p++;
452 if (p[0] == 's' && p[1] == 0)
453 break;
454 else
455 goto unknown;
457 else
458 goto unknown;
461 if (p[0] == '.' && ISDIGIT (p[1]))
463 /* Nested subprogram. */
464 p += 2;
465 while (ISDIGIT (*p))
466 p++;
468 if (*p == 0)
470 /* End of mangled name. */
471 break;
473 else
474 goto unknown;
476 *d = 0;
477 return demangled;
479 unknown:
480 XDELETEVEC (demangled);
481 len0 = strlen (mangled);
482 demangled = XNEWVEC (char, len0 + 3);
484 if (mangled[0] == '<')
485 strcpy (demangled, mangled);
486 else
487 sprintf (demangled, "<%s>", mangled);
489 return demangled;