Mercurial > hg > CbC > CbC_gcc
annotate include/demangle.h @ 158:494b0b89df80 default tip
...
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 25 May 2020 18:13:55 +0900 |
| parents | 1830386684a0 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Defs for interface to demanglers. |
| 145 | 2 Copyright (C) 1992-2020 Free Software Foundation, Inc. |
| 111 | 3 |
| 0 | 4 This program is free software; you can redistribute it and/or |
| 5 modify it under the terms of the GNU Library General Public License | |
| 6 as published by the Free Software Foundation; either version 2, or | |
| 7 (at your option) any later version. | |
| 8 | |
| 9 In addition to the permissions in the GNU Library General Public | |
| 10 License, the Free Software Foundation gives you unlimited | |
| 11 permission to link the compiled version of this file into | |
| 12 combinations with other programs, and to distribute those | |
| 13 combinations without any restriction coming from the use of this | |
| 14 file. (The Library Public License restrictions do apply in other | |
| 15 respects; for example, they cover modification of the file, and | |
| 16 distribution when not linked into a combined executable.) | |
| 17 | |
| 18 This program is distributed in the hope that it will be useful, but | |
| 19 WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 21 Library General Public License for more details. | |
| 22 | |
| 23 You should have received a copy of the GNU Library General Public | |
| 24 License along with this program; if not, write to the Free Software | |
| 25 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA | |
| 26 02110-1301, USA. */ | |
| 27 | |
| 28 | |
| 29 #if !defined (DEMANGLE_H) | |
| 30 #define DEMANGLE_H | |
| 31 | |
| 32 #include "libiberty.h" | |
| 33 | |
| 34 #ifdef __cplusplus | |
| 35 extern "C" { | |
| 36 #endif /* __cplusplus */ | |
| 37 | |
| 38 /* Options passed to cplus_demangle (in 2nd parameter). */ | |
| 39 | |
| 40 #define DMGL_NO_OPTS 0 /* For readability... */ | |
| 41 #define DMGL_PARAMS (1 << 0) /* Include function args */ | |
| 42 #define DMGL_ANSI (1 << 1) /* Include const, volatile, etc */ | |
| 43 #define DMGL_JAVA (1 << 2) /* Demangle as Java rather than C++. */ | |
| 44 #define DMGL_VERBOSE (1 << 3) /* Include implementation details. */ | |
| 45 #define DMGL_TYPES (1 << 4) /* Also try to demangle type encodings. */ | |
| 46 #define DMGL_RET_POSTFIX (1 << 5) /* Print function return types (when | |
| 111 | 47 present) after function signature. |
| 48 It applies only to the toplevel | |
| 49 function type. */ | |
| 50 #define DMGL_RET_DROP (1 << 6) /* Suppress printing function return | |
| 51 types, even if present. It applies | |
| 52 only to the toplevel function type. | |
| 53 */ | |
| 0 | 54 |
| 55 #define DMGL_AUTO (1 << 8) | |
| 56 #define DMGL_GNU_V3 (1 << 14) | |
| 57 #define DMGL_GNAT (1 << 15) | |
| 111 | 58 #define DMGL_DLANG (1 << 16) |
| 59 #define DMGL_RUST (1 << 17) /* Rust wraps GNU_V3 style mangling. */ | |
| 0 | 60 |
| 61 /* If none of these are set, use 'current_demangling_style' as the default. */ | |
| 145 | 62 #define DMGL_STYLE_MASK (DMGL_AUTO|DMGL_GNU_V3|DMGL_JAVA|DMGL_GNAT|DMGL_DLANG|DMGL_RUST) |
| 0 | 63 |
| 145 | 64 /* Disable a limit on the depth of recursion in mangled strings. |
| 65 Note if this limit is disabled then stack exhaustion is possible when | |
| 66 demangling pathologically complicated strings. Bug reports about stack | |
| 67 exhaustion when the option is enabled will be rejected. */ | |
| 68 #define DMGL_NO_RECURSE_LIMIT (1 << 18) | |
| 69 | |
| 70 /* If DMGL_NO_RECURSE_LIMIT is not enabled, then this is the value used as | |
| 71 the maximum depth of recursion allowed. It should be enough for any | |
| 72 real-world mangled name. */ | |
| 73 #define DEMANGLE_RECURSION_LIMIT 2048 | |
| 74 | |
| 0 | 75 /* Enumeration of possible demangling styles. |
| 76 | |
| 77 Lucid and ARM styles are still kept logically distinct, even though | |
| 78 they now both behave identically. The resulting style is actual the | |
| 79 union of both. I.E. either style recognizes both "__pt__" and "__rf__" | |
| 80 for operator "->", even though the first is lucid style and the second | |
| 81 is ARM style. (FIXME?) */ | |
| 82 | |
| 83 extern enum demangling_styles | |
| 84 { | |
| 85 no_demangling = -1, | |
| 86 unknown_demangling = 0, | |
| 87 auto_demangling = DMGL_AUTO, | |
| 88 gnu_v3_demangling = DMGL_GNU_V3, | |
| 89 java_demangling = DMGL_JAVA, | |
| 111 | 90 gnat_demangling = DMGL_GNAT, |
| 91 dlang_demangling = DMGL_DLANG, | |
| 92 rust_demangling = DMGL_RUST | |
| 0 | 93 } current_demangling_style; |
| 94 | |
| 95 /* Define string names for the various demangling styles. */ | |
| 96 | |
| 97 #define NO_DEMANGLING_STYLE_STRING "none" | |
| 98 #define AUTO_DEMANGLING_STYLE_STRING "auto" | |
| 99 #define GNU_V3_DEMANGLING_STYLE_STRING "gnu-v3" | |
| 100 #define JAVA_DEMANGLING_STYLE_STRING "java" | |
| 101 #define GNAT_DEMANGLING_STYLE_STRING "gnat" | |
| 111 | 102 #define DLANG_DEMANGLING_STYLE_STRING "dlang" |
| 103 #define RUST_DEMANGLING_STYLE_STRING "rust" | |
| 0 | 104 |
| 105 /* Some macros to test what demangling style is active. */ | |
| 106 | |
| 107 #define CURRENT_DEMANGLING_STYLE current_demangling_style | |
| 108 #define AUTO_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_AUTO) | |
| 109 #define GNU_V3_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_GNU_V3) | |
| 110 #define JAVA_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_JAVA) | |
| 111 #define GNAT_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_GNAT) | |
| 111 | 112 #define DLANG_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_DLANG) |
| 113 #define RUST_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_RUST) | |
| 0 | 114 |
| 115 /* Provide information about the available demangle styles. This code is | |
| 116 pulled from gdb into libiberty because it is useful to binutils also. */ | |
| 117 | |
| 118 extern const struct demangler_engine | |
| 119 { | |
| 120 const char *const demangling_style_name; | |
| 121 const enum demangling_styles demangling_style; | |
| 122 const char *const demangling_style_doc; | |
| 123 } libiberty_demanglers[]; | |
| 124 | |
| 125 extern char * | |
| 126 cplus_demangle (const char *mangled, int options); | |
| 127 | |
| 128 /* Note: This sets global state. FIXME if you care about multi-threading. */ | |
| 129 | |
| 111 | 130 extern enum demangling_styles |
| 0 | 131 cplus_demangle_set_style (enum demangling_styles style); |
| 132 | |
| 111 | 133 extern enum demangling_styles |
| 0 | 134 cplus_demangle_name_to_style (const char *name); |
| 135 | |
| 136 /* Callback typedef for allocation-less demangler interfaces. */ | |
| 137 typedef void (*demangle_callbackref) (const char *, size_t, void *); | |
| 138 | |
| 139 /* V3 ABI demangling entry points, defined in cp-demangle.c. Callback | |
| 140 variants return non-zero on success, zero on error. char* variants | |
| 141 return a string allocated by malloc on success, NULL on error. */ | |
| 142 extern int | |
| 143 cplus_demangle_v3_callback (const char *mangled, int options, | |
| 144 demangle_callbackref callback, void *opaque); | |
| 145 | |
| 146 extern char* | |
| 147 cplus_demangle_v3 (const char *mangled, int options); | |
| 148 | |
| 149 extern int | |
| 150 java_demangle_v3_callback (const char *mangled, | |
| 151 demangle_callbackref callback, void *opaque); | |
| 152 | |
| 153 extern char* | |
| 154 java_demangle_v3 (const char *mangled); | |
| 155 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
156 char * |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
157 ada_demangle (const char *mangled, int options); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
158 |
| 111 | 159 extern char * |
| 160 dlang_demangle (const char *mangled, int options); | |
| 161 | |
| 162 extern int | |
| 145 | 163 rust_demangle_callback (const char *mangled, int options, |
| 164 demangle_callbackref callback, void *opaque); | |
| 111 | 165 |
| 166 | |
| 167 extern char * | |
| 168 rust_demangle (const char *mangled, int options); | |
| 169 | |
| 0 | 170 enum gnu_v3_ctor_kinds { |
| 171 gnu_v3_complete_object_ctor = 1, | |
| 172 gnu_v3_base_object_ctor, | |
| 111 | 173 gnu_v3_complete_object_allocating_ctor, |
| 174 /* These are not part of the V3 ABI. Unified constructors are generated | |
| 175 as a speed-for-space optimization when the -fdeclone-ctor-dtor option | |
| 176 is used, and are always internal symbols. */ | |
| 177 gnu_v3_unified_ctor, | |
| 178 gnu_v3_object_ctor_group | |
| 0 | 179 }; |
| 180 | |
| 181 /* Return non-zero iff NAME is the mangled form of a constructor name | |
| 182 in the G++ V3 ABI demangling style. Specifically, return an `enum | |
| 183 gnu_v3_ctor_kinds' value indicating what kind of constructor | |
| 184 it is. */ | |
| 185 extern enum gnu_v3_ctor_kinds | |
| 186 is_gnu_v3_mangled_ctor (const char *name); | |
| 187 | |
| 188 | |
| 189 enum gnu_v3_dtor_kinds { | |
| 190 gnu_v3_deleting_dtor = 1, | |
| 191 gnu_v3_complete_object_dtor, | |
| 111 | 192 gnu_v3_base_object_dtor, |
| 193 /* These are not part of the V3 ABI. Unified destructors are generated | |
| 194 as a speed-for-space optimization when the -fdeclone-ctor-dtor option | |
| 195 is used, and are always internal symbols. */ | |
| 196 gnu_v3_unified_dtor, | |
| 197 gnu_v3_object_dtor_group | |
| 0 | 198 }; |
| 199 | |
| 200 /* Return non-zero iff NAME is the mangled form of a destructor name | |
| 201 in the G++ V3 ABI demangling style. Specifically, return an `enum | |
| 202 gnu_v3_dtor_kinds' value, indicating what kind of destructor | |
| 203 it is. */ | |
| 204 extern enum gnu_v3_dtor_kinds | |
| 205 is_gnu_v3_mangled_dtor (const char *name); | |
| 206 | |
| 207 /* The V3 demangler works in two passes. The first pass builds a tree | |
| 208 representation of the mangled name, and the second pass turns the | |
| 209 tree representation into a demangled string. Here we define an | |
| 210 interface to permit a caller to build their own tree | |
| 211 representation, which they can pass to the demangler to get a | |
| 212 demangled string. This can be used to canonicalize user input into | |
| 213 something which the demangler might output. It could also be used | |
| 214 by other demanglers in the future. */ | |
| 215 | |
| 216 /* These are the component types which may be found in the tree. Many | |
| 217 component types have one or two subtrees, referred to as left and | |
| 218 right (a component type with only one subtree puts it in the left | |
| 219 subtree). */ | |
| 220 | |
| 221 enum demangle_component_type | |
| 222 { | |
| 223 /* A name, with a length and a pointer to a string. */ | |
| 224 DEMANGLE_COMPONENT_NAME, | |
| 225 /* A qualified name. The left subtree is a class or namespace or | |
| 226 some such thing, and the right subtree is a name qualified by | |
| 227 that class. */ | |
| 228 DEMANGLE_COMPONENT_QUAL_NAME, | |
| 229 /* A local name. The left subtree describes a function, and the | |
| 230 right subtree is a name which is local to that function. */ | |
| 231 DEMANGLE_COMPONENT_LOCAL_NAME, | |
| 232 /* A typed name. The left subtree is a name, and the right subtree | |
| 233 describes that name as a function. */ | |
| 234 DEMANGLE_COMPONENT_TYPED_NAME, | |
| 235 /* A template. The left subtree is a template name, and the right | |
| 236 subtree is a template argument list. */ | |
| 237 DEMANGLE_COMPONENT_TEMPLATE, | |
| 238 /* A template parameter. This holds a number, which is the template | |
| 239 parameter index. */ | |
| 240 DEMANGLE_COMPONENT_TEMPLATE_PARAM, | |
| 241 /* A function parameter. This holds a number, which is the index. */ | |
| 242 DEMANGLE_COMPONENT_FUNCTION_PARAM, | |
| 243 /* A constructor. This holds a name and the kind of | |
| 244 constructor. */ | |
| 245 DEMANGLE_COMPONENT_CTOR, | |
| 246 /* A destructor. This holds a name and the kind of destructor. */ | |
| 247 DEMANGLE_COMPONENT_DTOR, | |
| 248 /* A vtable. This has one subtree, the type for which this is a | |
| 249 vtable. */ | |
| 250 DEMANGLE_COMPONENT_VTABLE, | |
| 251 /* A VTT structure. This has one subtree, the type for which this | |
| 252 is a VTT. */ | |
| 253 DEMANGLE_COMPONENT_VTT, | |
| 254 /* A construction vtable. The left subtree is the type for which | |
| 255 this is a vtable, and the right subtree is the derived type for | |
| 256 which this vtable is built. */ | |
| 257 DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, | |
| 258 /* A typeinfo structure. This has one subtree, the type for which | |
| 259 this is the tpeinfo structure. */ | |
| 260 DEMANGLE_COMPONENT_TYPEINFO, | |
| 261 /* A typeinfo name. This has one subtree, the type for which this | |
| 262 is the typeinfo name. */ | |
| 263 DEMANGLE_COMPONENT_TYPEINFO_NAME, | |
| 264 /* A typeinfo function. This has one subtree, the type for which | |
| 265 this is the tpyeinfo function. */ | |
| 266 DEMANGLE_COMPONENT_TYPEINFO_FN, | |
| 267 /* A thunk. This has one subtree, the name for which this is a | |
| 268 thunk. */ | |
| 269 DEMANGLE_COMPONENT_THUNK, | |
| 270 /* A virtual thunk. This has one subtree, the name for which this | |
| 271 is a virtual thunk. */ | |
| 272 DEMANGLE_COMPONENT_VIRTUAL_THUNK, | |
| 273 /* A covariant thunk. This has one subtree, the name for which this | |
| 274 is a covariant thunk. */ | |
| 275 DEMANGLE_COMPONENT_COVARIANT_THUNK, | |
| 276 /* A Java class. This has one subtree, the type. */ | |
| 277 DEMANGLE_COMPONENT_JAVA_CLASS, | |
| 278 /* A guard variable. This has one subtree, the name for which this | |
| 279 is a guard variable. */ | |
| 280 DEMANGLE_COMPONENT_GUARD, | |
| 111 | 281 /* The init and wrapper functions for C++11 thread_local variables. */ |
| 282 DEMANGLE_COMPONENT_TLS_INIT, | |
| 283 DEMANGLE_COMPONENT_TLS_WRAPPER, | |
| 0 | 284 /* A reference temporary. This has one subtree, the name for which |
| 285 this is a temporary. */ | |
| 286 DEMANGLE_COMPONENT_REFTEMP, | |
| 287 /* A hidden alias. This has one subtree, the encoding for which it | |
| 288 is providing alternative linkage. */ | |
| 289 DEMANGLE_COMPONENT_HIDDEN_ALIAS, | |
| 290 /* A standard substitution. This holds the name of the | |
| 291 substitution. */ | |
| 292 DEMANGLE_COMPONENT_SUB_STD, | |
| 293 /* The restrict qualifier. The one subtree is the type which is | |
| 294 being qualified. */ | |
| 295 DEMANGLE_COMPONENT_RESTRICT, | |
| 296 /* The volatile qualifier. The one subtree is the type which is | |
| 297 being qualified. */ | |
| 298 DEMANGLE_COMPONENT_VOLATILE, | |
| 299 /* The const qualifier. The one subtree is the type which is being | |
| 300 qualified. */ | |
| 301 DEMANGLE_COMPONENT_CONST, | |
| 302 /* The restrict qualifier modifying a member function. The one | |
| 303 subtree is the type which is being qualified. */ | |
| 304 DEMANGLE_COMPONENT_RESTRICT_THIS, | |
| 305 /* The volatile qualifier modifying a member function. The one | |
| 306 subtree is the type which is being qualified. */ | |
| 307 DEMANGLE_COMPONENT_VOLATILE_THIS, | |
| 308 /* The const qualifier modifying a member function. The one subtree | |
| 309 is the type which is being qualified. */ | |
| 310 DEMANGLE_COMPONENT_CONST_THIS, | |
| 111 | 311 /* C++11 A reference modifying a member function. The one subtree is the |
| 312 type which is being referenced. */ | |
| 313 DEMANGLE_COMPONENT_REFERENCE_THIS, | |
| 314 /* C++11: An rvalue reference modifying a member function. The one | |
| 315 subtree is the type which is being referenced. */ | |
| 316 DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS, | |
| 0 | 317 /* A vendor qualifier. The left subtree is the type which is being |
| 318 qualified, and the right subtree is the name of the | |
| 319 qualifier. */ | |
| 320 DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, | |
| 321 /* A pointer. The one subtree is the type which is being pointed | |
| 322 to. */ | |
| 323 DEMANGLE_COMPONENT_POINTER, | |
| 324 /* A reference. The one subtree is the type which is being | |
| 325 referenced. */ | |
| 326 DEMANGLE_COMPONENT_REFERENCE, | |
| 327 /* C++0x: An rvalue reference. The one subtree is the type which is | |
| 328 being referenced. */ | |
| 329 DEMANGLE_COMPONENT_RVALUE_REFERENCE, | |
| 330 /* A complex type. The one subtree is the base type. */ | |
| 331 DEMANGLE_COMPONENT_COMPLEX, | |
| 332 /* An imaginary type. The one subtree is the base type. */ | |
| 333 DEMANGLE_COMPONENT_IMAGINARY, | |
| 334 /* A builtin type. This holds the builtin type information. */ | |
| 335 DEMANGLE_COMPONENT_BUILTIN_TYPE, | |
| 336 /* A vendor's builtin type. This holds the name of the type. */ | |
| 337 DEMANGLE_COMPONENT_VENDOR_TYPE, | |
| 338 /* A function type. The left subtree is the return type. The right | |
| 339 subtree is a list of ARGLIST nodes. Either or both may be | |
| 340 NULL. */ | |
| 341 DEMANGLE_COMPONENT_FUNCTION_TYPE, | |
| 342 /* An array type. The left subtree is the dimension, which may be | |
| 343 NULL, or a string (represented as DEMANGLE_COMPONENT_NAME), or an | |
| 344 expression. The right subtree is the element type. */ | |
| 345 DEMANGLE_COMPONENT_ARRAY_TYPE, | |
| 346 /* A pointer to member type. The left subtree is the class type, | |
| 347 and the right subtree is the member type. CV-qualifiers appear | |
| 348 on the latter. */ | |
| 349 DEMANGLE_COMPONENT_PTRMEM_TYPE, | |
| 350 /* A fixed-point type. */ | |
| 351 DEMANGLE_COMPONENT_FIXED_TYPE, | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
352 /* A vector type. The left subtree is the number of elements, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
353 the right subtree is the element type. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
354 DEMANGLE_COMPONENT_VECTOR_TYPE, |
| 0 | 355 /* An argument list. The left subtree is the current argument, and |
| 356 the right subtree is either NULL or another ARGLIST node. */ | |
| 357 DEMANGLE_COMPONENT_ARGLIST, | |
| 358 /* A template argument list. The left subtree is the current | |
| 359 template argument, and the right subtree is either NULL or | |
| 360 another TEMPLATE_ARGLIST node. */ | |
| 361 DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, | |
| 145 | 362 /* A template parameter object (C++20). The left subtree is the |
| 363 corresponding template argument. */ | |
| 364 DEMANGLE_COMPONENT_TPARM_OBJ, | |
| 111 | 365 /* An initializer list. The left subtree is either an explicit type or |
| 366 NULL, and the right subtree is a DEMANGLE_COMPONENT_ARGLIST. */ | |
| 367 DEMANGLE_COMPONENT_INITIALIZER_LIST, | |
| 0 | 368 /* An operator. This holds information about a standard |
| 369 operator. */ | |
| 370 DEMANGLE_COMPONENT_OPERATOR, | |
| 371 /* An extended operator. This holds the number of arguments, and | |
| 372 the name of the extended operator. */ | |
| 373 DEMANGLE_COMPONENT_EXTENDED_OPERATOR, | |
| 374 /* A typecast, represented as a unary operator. The one subtree is | |
| 375 the type to which the argument should be cast. */ | |
| 376 DEMANGLE_COMPONENT_CAST, | |
| 111 | 377 /* A conversion operator, represented as a unary operator. The one |
| 378 subtree is the type to which the argument should be converted | |
| 379 to. */ | |
| 380 DEMANGLE_COMPONENT_CONVERSION, | |
| 381 /* A nullary expression. The left subtree is the operator. */ | |
| 382 DEMANGLE_COMPONENT_NULLARY, | |
| 0 | 383 /* A unary expression. The left subtree is the operator, and the |
| 384 right subtree is the single argument. */ | |
| 385 DEMANGLE_COMPONENT_UNARY, | |
| 386 /* A binary expression. The left subtree is the operator, and the | |
| 387 right subtree is a BINARY_ARGS. */ | |
| 388 DEMANGLE_COMPONENT_BINARY, | |
| 389 /* Arguments to a binary expression. The left subtree is the first | |
| 390 argument, and the right subtree is the second argument. */ | |
| 391 DEMANGLE_COMPONENT_BINARY_ARGS, | |
| 392 /* A trinary expression. The left subtree is the operator, and the | |
| 393 right subtree is a TRINARY_ARG1. */ | |
| 394 DEMANGLE_COMPONENT_TRINARY, | |
| 395 /* Arguments to a trinary expression. The left subtree is the first | |
| 396 argument, and the right subtree is a TRINARY_ARG2. */ | |
| 397 DEMANGLE_COMPONENT_TRINARY_ARG1, | |
| 398 /* More arguments to a trinary expression. The left subtree is the | |
| 399 second argument, and the right subtree is the third argument. */ | |
| 400 DEMANGLE_COMPONENT_TRINARY_ARG2, | |
| 401 /* A literal. The left subtree is the type, and the right subtree | |
| 402 is the value, represented as a DEMANGLE_COMPONENT_NAME. */ | |
| 403 DEMANGLE_COMPONENT_LITERAL, | |
| 404 /* A negative literal. Like LITERAL, but the value is negated. | |
| 405 This is a minor hack: the NAME used for LITERAL points directly | |
| 406 to the mangled string, but since negative numbers are mangled | |
| 407 using 'n' instead of '-', we want a way to indicate a negative | |
| 408 number which involves neither modifying the mangled string nor | |
| 409 allocating a new copy of the literal in memory. */ | |
| 410 DEMANGLE_COMPONENT_LITERAL_NEG, | |
| 411 /* A libgcj compiled resource. The left subtree is the name of the | |
| 412 resource. */ | |
| 413 DEMANGLE_COMPONENT_JAVA_RESOURCE, | |
| 414 /* A name formed by the concatenation of two parts. The left | |
| 415 subtree is the first part and the right subtree the second. */ | |
| 416 DEMANGLE_COMPONENT_COMPOUND_NAME, | |
| 417 /* A name formed by a single character. */ | |
| 418 DEMANGLE_COMPONENT_CHARACTER, | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
419 /* A number. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
420 DEMANGLE_COMPONENT_NUMBER, |
| 0 | 421 /* A decltype type. */ |
| 422 DEMANGLE_COMPONENT_DECLTYPE, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
423 /* Global constructors keyed to name. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
424 DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
425 /* Global destructors keyed to name. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
426 DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
427 /* A lambda closure type. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
428 DEMANGLE_COMPONENT_LAMBDA, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
429 /* A default argument scope. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
430 DEMANGLE_COMPONENT_DEFAULT_ARG, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
431 /* An unnamed type. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
432 DEMANGLE_COMPONENT_UNNAMED_TYPE, |
| 111 | 433 /* A transactional clone. This has one subtree, the encoding for |
| 434 which it is providing alternative linkage. */ | |
| 435 DEMANGLE_COMPONENT_TRANSACTION_CLONE, | |
| 436 /* A non-transactional clone entry point. In the i386/x86_64 abi, | |
| 437 the unmangled symbol of a tm_callable becomes a thunk and the | |
| 438 non-transactional function version is mangled thus. */ | |
| 439 DEMANGLE_COMPONENT_NONTRANSACTION_CLONE, | |
| 0 | 440 /* A pack expansion. */ |
| 111 | 441 DEMANGLE_COMPONENT_PACK_EXPANSION, |
| 442 /* A name with an ABI tag. */ | |
| 443 DEMANGLE_COMPONENT_TAGGED_NAME, | |
| 444 /* A transaction-safe function type. */ | |
| 445 DEMANGLE_COMPONENT_TRANSACTION_SAFE, | |
| 446 /* A cloned function. */ | |
| 447 DEMANGLE_COMPONENT_CLONE, | |
| 448 DEMANGLE_COMPONENT_NOEXCEPT, | |
| 449 DEMANGLE_COMPONENT_THROW_SPEC | |
| 0 | 450 }; |
| 451 | |
| 452 /* Types which are only used internally. */ | |
| 453 | |
| 454 struct demangle_operator_info; | |
| 455 struct demangle_builtin_type_info; | |
| 456 | |
| 457 /* A node in the tree representation is an instance of a struct | |
| 458 demangle_component. Note that the field names of the struct are | |
| 459 not well protected against macros defined by the file including | |
| 460 this one. We can fix this if it ever becomes a problem. */ | |
| 461 | |
| 462 struct demangle_component | |
| 463 { | |
| 464 /* The type of this component. */ | |
| 465 enum demangle_component_type type; | |
| 466 | |
| 111 | 467 /* Guard against recursive component printing. |
| 468 Initialize to zero. Private to d_print_comp. | |
| 469 All other fields are final after initialization. */ | |
| 470 int d_printing; | |
| 145 | 471 int d_counting; |
| 111 | 472 |
| 0 | 473 union |
| 474 { | |
| 475 /* For DEMANGLE_COMPONENT_NAME. */ | |
| 476 struct | |
| 477 { | |
| 478 /* A pointer to the name (which need not NULL terminated) and | |
| 479 its length. */ | |
| 480 const char *s; | |
| 481 int len; | |
| 482 } s_name; | |
| 483 | |
| 484 /* For DEMANGLE_COMPONENT_OPERATOR. */ | |
| 485 struct | |
| 486 { | |
| 487 /* Operator. */ | |
| 488 const struct demangle_operator_info *op; | |
| 489 } s_operator; | |
| 490 | |
| 491 /* For DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */ | |
| 492 struct | |
| 493 { | |
| 494 /* Number of arguments. */ | |
| 495 int args; | |
| 496 /* Name. */ | |
| 497 struct demangle_component *name; | |
| 498 } s_extended_operator; | |
| 499 | |
| 500 /* For DEMANGLE_COMPONENT_FIXED_TYPE. */ | |
| 501 struct | |
| 502 { | |
| 503 /* The length, indicated by a C integer type name. */ | |
| 504 struct demangle_component *length; | |
| 505 /* _Accum or _Fract? */ | |
| 506 short accum; | |
| 507 /* Saturating or not? */ | |
| 508 short sat; | |
| 509 } s_fixed; | |
| 510 | |
| 511 /* For DEMANGLE_COMPONENT_CTOR. */ | |
| 512 struct | |
| 513 { | |
| 514 /* Kind of constructor. */ | |
| 515 enum gnu_v3_ctor_kinds kind; | |
| 516 /* Name. */ | |
| 517 struct demangle_component *name; | |
| 518 } s_ctor; | |
| 519 | |
| 520 /* For DEMANGLE_COMPONENT_DTOR. */ | |
| 521 struct | |
| 522 { | |
| 523 /* Kind of destructor. */ | |
| 524 enum gnu_v3_dtor_kinds kind; | |
| 525 /* Name. */ | |
| 526 struct demangle_component *name; | |
| 527 } s_dtor; | |
| 528 | |
| 529 /* For DEMANGLE_COMPONENT_BUILTIN_TYPE. */ | |
| 530 struct | |
| 531 { | |
| 532 /* Builtin type. */ | |
| 533 const struct demangle_builtin_type_info *type; | |
| 534 } s_builtin; | |
| 535 | |
| 536 /* For DEMANGLE_COMPONENT_SUB_STD. */ | |
| 537 struct | |
| 538 { | |
| 539 /* Standard substitution string. */ | |
| 540 const char* string; | |
| 541 /* Length of string. */ | |
| 542 int len; | |
| 543 } s_string; | |
| 544 | |
| 545 /* For DEMANGLE_COMPONENT_*_PARAM. */ | |
| 546 struct | |
| 547 { | |
| 548 /* Parameter index. */ | |
| 549 long number; | |
| 550 } s_number; | |
| 551 | |
| 552 /* For DEMANGLE_COMPONENT_CHARACTER. */ | |
| 553 struct | |
| 554 { | |
| 555 int character; | |
| 556 } s_character; | |
| 557 | |
| 558 /* For other types. */ | |
| 559 struct | |
| 560 { | |
| 561 /* Left (or only) subtree. */ | |
| 562 struct demangle_component *left; | |
| 563 /* Right subtree. */ | |
| 564 struct demangle_component *right; | |
| 565 } s_binary; | |
| 566 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
567 struct |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
568 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
569 /* subtree, same place as d_left. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
570 struct demangle_component *sub; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
571 /* integer. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
572 int num; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
573 } s_unary_num; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
574 |
| 0 | 575 } u; |
| 576 }; | |
| 577 | |
| 578 /* People building mangled trees are expected to allocate instances of | |
| 579 struct demangle_component themselves. They can then call one of | |
| 580 the following functions to fill them in. */ | |
| 581 | |
| 582 /* Fill in most component types with a left subtree and a right | |
| 583 subtree. Returns non-zero on success, zero on failure, such as an | |
| 584 unrecognized or inappropriate component type. */ | |
| 585 | |
| 586 extern int | |
| 587 cplus_demangle_fill_component (struct demangle_component *fill, | |
| 588 enum demangle_component_type, | |
| 589 struct demangle_component *left, | |
| 590 struct demangle_component *right); | |
| 591 | |
| 592 /* Fill in a DEMANGLE_COMPONENT_NAME. Returns non-zero on success, | |
| 593 zero for bad arguments. */ | |
| 594 | |
| 595 extern int | |
| 596 cplus_demangle_fill_name (struct demangle_component *fill, | |
| 597 const char *, int); | |
| 598 | |
| 599 /* Fill in a DEMANGLE_COMPONENT_BUILTIN_TYPE, using the name of the | |
| 600 builtin type (e.g., "int", etc.). Returns non-zero on success, | |
| 601 zero if the type is not recognized. */ | |
| 602 | |
| 603 extern int | |
| 604 cplus_demangle_fill_builtin_type (struct demangle_component *fill, | |
| 605 const char *type_name); | |
| 606 | |
| 607 /* Fill in a DEMANGLE_COMPONENT_OPERATOR, using the name of the | |
| 608 operator and the number of arguments which it takes (the latter is | |
| 609 used to disambiguate operators which can be both binary and unary, | |
| 610 such as '-'). Returns non-zero on success, zero if the operator is | |
| 611 not recognized. */ | |
| 612 | |
| 613 extern int | |
| 614 cplus_demangle_fill_operator (struct demangle_component *fill, | |
| 615 const char *opname, int args); | |
| 616 | |
| 617 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR, providing the | |
| 618 number of arguments and the name. Returns non-zero on success, | |
| 619 zero for bad arguments. */ | |
| 620 | |
| 621 extern int | |
| 622 cplus_demangle_fill_extended_operator (struct demangle_component *fill, | |
| 623 int numargs, | |
| 624 struct demangle_component *nm); | |
| 625 | |
| 626 /* Fill in a DEMANGLE_COMPONENT_CTOR. Returns non-zero on success, | |
| 627 zero for bad arguments. */ | |
| 628 | |
| 629 extern int | |
| 630 cplus_demangle_fill_ctor (struct demangle_component *fill, | |
| 631 enum gnu_v3_ctor_kinds kind, | |
| 632 struct demangle_component *name); | |
| 633 | |
| 634 /* Fill in a DEMANGLE_COMPONENT_DTOR. Returns non-zero on success, | |
| 635 zero for bad arguments. */ | |
| 636 | |
| 637 extern int | |
| 638 cplus_demangle_fill_dtor (struct demangle_component *fill, | |
| 639 enum gnu_v3_dtor_kinds kind, | |
| 640 struct demangle_component *name); | |
| 641 | |
| 642 /* This function translates a mangled name into a struct | |
| 643 demangle_component tree. The first argument is the mangled name. | |
| 644 The second argument is DMGL_* options. This returns a pointer to a | |
| 645 tree on success, or NULL on failure. On success, the third | |
| 646 argument is set to a block of memory allocated by malloc. This | |
| 647 block should be passed to free when the tree is no longer | |
| 648 needed. */ | |
| 649 | |
| 650 extern struct demangle_component * | |
| 651 cplus_demangle_v3_components (const char *mangled, int options, void **mem); | |
| 652 | |
| 653 /* This function takes a struct demangle_component tree and returns | |
| 654 the corresponding demangled string. The first argument is DMGL_* | |
| 655 options. The second is the tree to demangle. The third is a guess | |
| 656 at the length of the demangled string, used to initially allocate | |
| 657 the return buffer. The fourth is a pointer to a size_t. On | |
| 658 success, this function returns a buffer allocated by malloc(), and | |
| 659 sets the size_t pointed to by the fourth argument to the size of | |
| 660 the allocated buffer (not the length of the returned string). On | |
| 661 failure, this function returns NULL, and sets the size_t pointed to | |
| 662 by the fourth argument to 0 for an invalid tree, or to 1 for a | |
| 663 memory allocation error. */ | |
| 664 | |
| 665 extern char * | |
| 666 cplus_demangle_print (int options, | |
| 111 | 667 struct demangle_component *tree, |
| 0 | 668 int estimated_length, |
| 669 size_t *p_allocated_size); | |
| 670 | |
| 671 /* This function takes a struct demangle_component tree and passes back | |
| 672 a demangled string in one or more calls to a callback function. | |
| 673 The first argument is DMGL_* options. The second is the tree to | |
| 674 demangle. The third is a pointer to a callback function; on each call | |
| 675 this receives an element of the demangled string, its length, and an | |
| 676 opaque value. The fourth is the opaque value passed to the callback. | |
| 677 The callback is called once or more to return the full demangled | |
| 678 string. The demangled element string is always nul-terminated, though | |
| 679 its length is also provided for convenience. In contrast to | |
| 680 cplus_demangle_print(), this function does not allocate heap memory | |
| 681 to grow output strings (except perhaps where alloca() is implemented | |
| 682 by malloc()), and so is normally safe for use where the heap has been | |
| 683 corrupted. On success, this function returns 1; on failure, 0. */ | |
| 684 | |
| 685 extern int | |
| 686 cplus_demangle_print_callback (int options, | |
| 111 | 687 struct demangle_component *tree, |
| 0 | 688 demangle_callbackref callback, void *opaque); |
| 689 | |
| 690 #ifdef __cplusplus | |
| 691 } | |
| 692 #endif /* __cplusplus */ | |
| 693 | |
| 694 #endif /* DEMANGLE_H */ |