coregrind/m_demangle/cplus-dem.c

   1 /* Demangler for GNU C++
   2    Copyright (C) 1989-2022 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
   6
   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.
  12
  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.)
  21
  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.
  26
  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.  */
  31
  32 /* This file lives in both GCC and libiberty.  When making changes, please
  33    try not to break either.  */
  34
  35 #if 0 /* in valgrind */
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39 #endif /* ! in valgrind */
  40
  41 #if 0 /* in valgrind */
  42 #include "safe-ctype.h"
  43 #endif /* ! in valgrind */
  44
  45 #if 0 /* in valgrind */
  46 #include <string.h>
  47 #endif /* ! in valgrind */
  48
  49 #if 0 /* in valgrind */
  50 #ifdef HAVE_STDLIB_H
  51 #include <stdlib.h>
  52 #else
  53 void * malloc ();
  54 void * realloc ();
  55 #endif
  56 #endif /* ! in valgrind */
  57
  58 #if 0 /* in valgrind */
  59 #include <demangle.h>
  60 #undef CURRENT_DEMANGLING_STYLE
  61 #define CURRENT_DEMANGLING_STYLE options
  62 #endif /* ! in valgrind */
  63
  64 #if 0 /* in valgrind */
  65 #include "libiberty.h"
  66 #endif /* ! in valgrind */
  67
  68 #include "vg_libciface.h"
  69
  70 #include "ansidecl.h"
  71 #include "demangle.h"
  72 #include "safe-ctype.h"
  73
  74 enum demangling_styles current_demangling_style = auto_demangling;
  75
  76 const struct demangler_engine libiberty_demanglers[] =
  77 {
  78   {
  79     NO_DEMANGLING_STYLE_STRING,
  80     no_demangling,
  81     "Demangling disabled"
  82   }
  83   ,
  84   {
  85     AUTO_DEMANGLING_STYLE_STRING,
  86       auto_demangling,
  87       "Automatic selection based on executable"
  88   }
  89   ,
  90   {
  91     GNU_V3_DEMANGLING_STYLE_STRING,
  92     gnu_v3_demangling,
  93     "GNU (g++) V3 (Itanium C++ ABI) style demangling"
  94   }
  95   ,
  96   {
  97     JAVA_DEMANGLING_STYLE_STRING,
  98     java_demangling,
  99     "Java style demangling"
 100   }
 101   ,
 102   {
 103     GNAT_DEMANGLING_STYLE_STRING,
 104     gnat_demangling,
 105     "GNAT style demangling"
 106   }
 107   ,
 108   {
 109     DLANG_DEMANGLING_STYLE_STRING,
 110     dlang_demangling,
 111     "DLANG style demangling"
 112   }
 113   ,
 114   {
 115     RUST_DEMANGLING_STYLE_STRING,
 116     rust_demangling,
 117     "Rust style demangling"
 118   }
 119   ,
 120   {
 121     NULL, unknown_demangling, NULL
 122   }
 123 };
 124
 125 /* Add a routine to set the demangling style to be sure it is valid and
 126    allow for any demangler initialization that maybe necessary. */
 127
 128 enum demangling_styles
 129 cplus_demangle_set_style (enum demangling_styles style)
 130 {
 131   const struct demangler_engine *demangler = libiberty_demanglers;
 132
 133   for (; demangler->demangling_style != unknown_demangling; ++demangler)
 134     if (style == demangler->demangling_style)
 135       {
 136         current_demangling_style = style;
 137         return current_demangling_style;
 138       }
 139
 140   return unknown_demangling;
 141 }
 142
 143 /* Do string name to style translation */
 144
 145 enum demangling_styles
 146 cplus_demangle_name_to_style (const char *name)
 147 {
 148   const struct demangler_engine *demangler = libiberty_demanglers;
 149
 150   for (; demangler->demangling_style != unknown_demangling; ++demangler)
 151     if (strcmp (name, demangler->demangling_style_name) == 0)
 152       return demangler->demangling_style;
 153
 154   return unknown_demangling;
 155 }
 156
 157 /* char *cplus_demangle (const char *mangled, int options)
 158
 159    If MANGLED is a mangled function name produced by GNU C++, then
 160    a pointer to a @code{malloc}ed string giving a C++ representation
 161    of the name will be returned; otherwise NULL will be returned.
 162    It is the caller's responsibility to free the string which
 163    is returned.
 164
 165    Note that any leading underscores, or other such characters prepended by
 166    the compilation system, are presumed to have already been stripped from
 167    MANGLED.  */
 168
 169 char *
 170 ML_(cplus_demangle) (const char *mangled, int options)
 171 {
 172   char *ret;
 173
 174   if (current_demangling_style == no_demangling)
 175     return xstrdup (mangled);
 176
 177   if ((options & DMGL_STYLE_MASK) == 0)
 178     options |= (int) current_demangling_style & DMGL_STYLE_MASK;
 179
 180   /* The Rust demangling is implemented elsewhere.
 181      Legacy Rust symbols overlap with GNU_V3, so try Rust first.  */
 182   if (RUST_DEMANGLING || AUTO_DEMANGLING)
 183     {
 184       ret = rust_demangle (mangled, options);
 185       if (ret || RUST_DEMANGLING)
 186         return ret;
 187     }
 188
 189   /* The V3 ABI demangling is implemented elsewhere.  */
 190   if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
 191     {
 192       ret = cplus_demangle_v3 (mangled, options);
 193       if (ret || GNU_V3_DEMANGLING)
 194         return ret;
 195     }
 196
 197   if (JAVA_DEMANGLING)
 198     {
 199       ret = java_demangle_v3 (mangled);
 200       if (ret)
 201         return ret;
 202     }
 203
 204   if (GNAT_DEMANGLING)
 205     return ada_demangle (mangled, options);
 206
 207   if (DLANG_DEMANGLING)
 208     {
 209       ret = dlang_demangle (mangled, options);
 210       if (ret)
 211         return ret;
 212     }
 213
 214   return (ret);
 215 }
 216
 217 /* Demangle ada names.  The encoding is documented in gcc/ada/exp_dbug.ads.  */
 218
 219 char *
 220 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
 221 {
 222   int len0;
 223   const char* p;
 224   char *d;
 225   char *demangled = NULL;
 226
 227   /* Discard leading _ada_, which is used for library level subprograms.  */
 228   if (strncmp (mangled, "_ada_", 5) == 0)
 229     mangled += 5;
 230
 231   /* All ada unit names are lower-case.  */
 232   if (!ISLOWER (mangled[0]))
 233     goto unknown;
 234
 235   /* Most of the demangling will trivially remove chars.  Operator names
 236      may add one char but because they are always preceded by '__' which is
 237      replaced by '.', they eventually never expand the size.
 238      A few special names such as '___elabs' add a few chars (at most 7), but
 239      they occur only once.  */
 240   len0 = strlen (mangled) + 7 + 1;
 241   demangled = XNEWVEC (char, len0);
 242
 243   d = demangled;
 244   p = mangled;
 245   while (1)
 246     {
 247       /* An entity names is expected.  */
 248       if (ISLOWER (*p))
 249         {
 250           /* An identifier, which is always lower case.  */
 251           do
 252             *d++ = *p++;
 253           while (ISLOWER(*p) || ISDIGIT (*p)
 254                  || (p[0] == '_' && (ISLOWER (p[1]) || ISDIGIT (p[1]))));
 255         }
 256       else if (p[0] == 'O')
 257         {
 258           /* An operator name.  */
 259           static const char * const operators[][2] =
 260             {{"Oabs", "abs"},  {"Oand", "and"},    {"Omod", "mod"},
 261              {"Onot", "not"},  {"Oor", "or"},      {"Orem", "rem"},
 262              {"Oxor", "xor"},  {"Oeq", "="},       {"One", "/="},
 263              {"Olt", "<"},     {"Ole", "<="},      {"Ogt", ">"},
 264              {"Oge", ">="},    {"Oadd", "+"},      {"Osubtract", "-"},
 265              {"Oconcat", "&"}, {"Omultiply", "*"}, {"Odivide", "/"},
 266              {"Oexpon", "**"}, {NULL, NULL}};
 267           int k;
 268
 269           for (k = 0; operators[k][0] != NULL; k++)
 270             {
 271               size_t slen = strlen (operators[k][0]);
 272               if (strncmp (p, operators[k][0], slen) == 0)
 273                 {
 274                   p += slen;
 275                   slen = strlen (operators[k][1]);
 276                   *d++ = '"';
 277                   memcpy (d, operators[k][1], slen);
 278                   d += slen;
 279                   *d++ = '"';
 280                   break;
 281                 }
 282             }
 283           /* Operator not found.  */
 284           if (operators[k][0] == NULL)
 285             goto unknown;
 286         }
 287       else
 288         {
 289           /* Not a GNAT encoding.  */
 290           goto unknown;
 291         }
 292
 293       /* The name can be directly followed by some uppercase letters.  */
 294       if (p[0] == 'T' && p[1] == 'K')
 295         {
 296           /* Task stuff.  */
 297           if (p[2] == 'B' && p[3] == 0)
 298             {
 299               /* Subprogram for task body.  */
 300               break;
 301             }
 302           else if (p[2] == '_' && p[3] == '_')
 303             {
 304               /* Inner declarations in a task.  */
 305               p += 4;
 306               *d++ = '.';
 307               continue;
 308             }
 309           else
 310             goto unknown;
 311         }
 312       if (p[0] == 'E' && p[1] == 0)
 313         {
 314           /* Exception name.  */
 315           goto unknown;
 316         }
 317       if ((p[0] == 'P' || p[0] == 'N') && p[1] == 0)
 318         {
 319           /* Protected type subprogram.  */
 320           break;
 321         }
 322       if ((*p == 'N' || *p == 'S') && p[1] == 0)
 323         {
 324           /* Enumerated type name table.  */
 325           goto unknown;
 326         }
 327       if (p[0] == 'X')
 328         {
 329           /* Body nested.  */
 330           p++;
 331           while (p[0] == 'n' || p[0] == 'b')
 332             p++;
 333         }
 334       if (p[0] == 'S' && p[1] != 0 && (p[2] == '_' || p[2] == 0))
 335         {
 336           /* Stream operations.  */
 337           const char *name;
 338           switch (p[1])
 339             {
 340             case 'R':
 341               name = "'Read";
 342               break;
 343             case 'W':
 344               name = "'Write";
 345               break;
 346             case 'I':
 347               name = "'Input";
 348               break;
 349             case 'O':
 350               name = "'Output";
 351               break;
 352             default:
 353               goto unknown;
 354             }
 355           p += 2;
 356           strcpy (d, name);
 357           d += strlen (name);
 358         }
 359       else if (p[0] == 'D')
 360         {
 361           /* Controlled type operation.  */
 362           const char *name;
 363           switch (p[1])
 364             {
 365             case 'F':
 366               name = ".Finalize";
 367               break;
 368             case 'A':
 369               name = ".Adjust";
 370               break;
 371             default:
 372               goto unknown;
 373             }
 374           strcpy (d, name);
 375           d += strlen (name);
 376           break;
 377         }
 378
 379       if (p[0] == '_')
 380         {
 381           /* Separator.  */
 382           if (p[1] == '_')
 383             {
 384               /* Standard separator.  Handled first.  */
 385               p += 2;
 386
 387               if (ISDIGIT (*p))
 388                 {
 389                   /* Overloading number.  */
 390                   do
 391                     p++;
 392                   while (ISDIGIT (*p) || (p[0] == '_' && ISDIGIT (p[1])));
 393                   if (*p == 'X')
 394                     {
 395                       p++;
 396                       while (p[0] == 'n' || p[0] == 'b')
 397                         p++;
 398                     }
 399                 }
 400               else if (p[0] == '_' && p[1] != '_')
 401                 {
 402                   /* Special names.  */
 403                   static const char * const special[][2] = {
 404                     { "_elabb", "'Elab_Body" },
 405                     { "_elabs", "'Elab_Spec" },
 406                     { "_size", "'Size" },
 407                     { "_alignment", "'Alignment" },
 408                     { "_assign", ".\":=\"" },
 409                     { NULL, NULL }
 410                   };
 411                   int k;
 412
 413                   for (k = 0; special[k][0] != NULL; k++)
 414                     {
 415                       size_t slen = strlen (special[k][0]);
 416                       if (strncmp (p, special[k][0], slen) == 0)
 417                         {
 418                           p += slen;
 419                           slen = strlen (special[k][1]);
 420                           memcpy (d, special[k][1], slen);
 421                           d += slen;
 422                           break;
 423                         }
 424                     }
 425                   if (special[k][0] != NULL)
 426                     break;
 427                   else
 428                     goto unknown;
 429                 }
 430               else
 431                 {
 432                   *d++ = '.';
 433                   continue;
 434                 }
 435             }
 436           else if (p[1] == 'B' || p[1] == 'E')
 437             {
 438               /* Entry Body or barrier Evaluation.  */
 439               p += 2;
 440               while (ISDIGIT (*p))
 441                 p++;
 442               if (p[0] == 's' && p[1] == 0)
 443                 break;
 444               else
 445                 goto unknown;
 446             }
 447           else
 448             goto unknown;
 449         }
 450
 451       if (p[0] == '.' && ISDIGIT (p[1]))
 452         {
 453           /* Nested subprogram.  */
 454           p += 2;
 455           while (ISDIGIT (*p))
 456             p++;
 457         }
 458       if (*p == 0)
 459         {
 460           /* End of mangled name.  */
 461           break;
 462         }
 463       else
 464         goto unknown;
 465     }
 466   *d = 0;
 467   return demangled;
 468
 469  unknown:
 470   XDELETEVEC (demangled);
 471   len0 = strlen (mangled);
 472   demangled = XNEWVEC (char, len0 + 3);
 473
 474   if (mangled[0] == '<')
 475      strcpy (demangled, mangled);
 476   else
 477     sprintf (demangled, "<%s>", mangled);
 478
 479   return demangled;
 480 }