Mercurial > hg > CbC > CbC_gcc
comparison libiberty/cplus-dem.c @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | f6334be47118 |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
1 /* Demangler for GNU C++ | 1 /* Demangler for GNU C++ |
2 Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999, | 2 Copyright (C) 1989-2017 Free Software Foundation, Inc. |
3 2000, 2001, 2002, 2003, 2004, 2010 Free Software Foundation, Inc. | |
4 Written by James Clark (jjc@jclark.uucp) | 3 Written by James Clark (jjc@jclark.uucp) |
5 Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling | 4 Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling |
6 Modified by Satish Pai (pai@apollo.hp.com) for HP demangling | 5 Modified by Satish Pai (pai@apollo.hp.com) for HP demangling |
7 | 6 |
8 This file is part of the libiberty library. | 7 This file is part of the libiberty library. |
52 #ifdef HAVE_STDLIB_H | 51 #ifdef HAVE_STDLIB_H |
53 #include <stdlib.h> | 52 #include <stdlib.h> |
54 #else | 53 #else |
55 void * malloc (); | 54 void * malloc (); |
56 void * realloc (); | 55 void * realloc (); |
56 #endif | |
57 | |
58 #ifdef HAVE_LIMITS_H | |
59 #include <limits.h> | |
60 #endif | |
61 #ifndef INT_MAX | |
62 # define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */ | |
57 #endif | 63 #endif |
58 | 64 |
59 #include <demangle.h> | 65 #include <demangle.h> |
60 #undef CURRENT_DEMANGLING_STYLE | 66 #undef CURRENT_DEMANGLING_STYLE |
61 #define CURRENT_DEMANGLING_STYLE work->options | 67 #define CURRENT_DEMANGLING_STYLE work->options |
135 int forgetting_types; /* Nonzero if we are not remembering the types | 141 int forgetting_types; /* Nonzero if we are not remembering the types |
136 we see. */ | 142 we see. */ |
137 string* previous_argument; /* The last function argument demangled. */ | 143 string* previous_argument; /* The last function argument demangled. */ |
138 int nrepeats; /* The number of times to repeat the previous | 144 int nrepeats; /* The number of times to repeat the previous |
139 argument. */ | 145 argument. */ |
146 int *proctypevec; /* Indices of currently processed remembered typevecs. */ | |
147 int proctypevec_size; | |
148 int nproctypes; | |
140 }; | 149 }; |
141 | 150 |
142 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI) | 151 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI) |
143 #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS) | 152 #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS) |
144 | 153 |
235 typedef enum type_kind_t | 244 typedef enum type_kind_t |
236 { | 245 { |
237 tk_none, | 246 tk_none, |
238 tk_pointer, | 247 tk_pointer, |
239 tk_reference, | 248 tk_reference, |
249 tk_rvalue_reference, | |
240 tk_integral, | 250 tk_integral, |
241 tk_bool, | 251 tk_bool, |
242 tk_char, | 252 tk_char, |
243 tk_real | 253 tk_real |
244 } type_kind_t; | 254 } type_kind_t; |
304 gnat_demangling, | 314 gnat_demangling, |
305 "GNAT style demangling" | 315 "GNAT style demangling" |
306 } | 316 } |
307 , | 317 , |
308 { | 318 { |
319 DLANG_DEMANGLING_STYLE_STRING, | |
320 dlang_demangling, | |
321 "DLANG style demangling" | |
322 } | |
323 , | |
324 { | |
325 RUST_DEMANGLING_STYLE_STRING, | |
326 rust_demangling, | |
327 "Rust style demangling" | |
328 } | |
329 , | |
330 { | |
309 NULL, unknown_demangling, NULL | 331 NULL, unknown_demangling, NULL |
310 } | 332 } |
311 }; | 333 }; |
312 | 334 |
313 #define STRING_EMPTY(str) ((str) -> b == (str) -> p) | 335 #define STRING_EMPTY(str) ((str) -> b == (str) -> p) |
420 iterate_demangle_function (struct work_stuff *, | 442 iterate_demangle_function (struct work_stuff *, |
421 const char **, string *, const char *); | 443 const char **, string *, const char *); |
422 | 444 |
423 static void remember_type (struct work_stuff *, const char *, int); | 445 static void remember_type (struct work_stuff *, const char *, int); |
424 | 446 |
447 static void push_processed_type (struct work_stuff *, int); | |
448 | |
449 static void pop_processed_type (struct work_stuff *); | |
450 | |
425 static void remember_Btype (struct work_stuff *, const char *, int, int); | 451 static void remember_Btype (struct work_stuff *, const char *, int, int); |
426 | 452 |
427 static int register_Btype (struct work_stuff *); | 453 static int register_Btype (struct work_stuff *); |
428 | 454 |
429 static void remember_Ktype (struct work_stuff *, const char *, int); | 455 static void remember_Ktype (struct work_stuff *, const char *, int); |
492 if (! ISDIGIT ((unsigned char)**type)) | 518 if (! ISDIGIT ((unsigned char)**type)) |
493 return -1; | 519 return -1; |
494 | 520 |
495 while (ISDIGIT ((unsigned char)**type)) | 521 while (ISDIGIT ((unsigned char)**type)) |
496 { | 522 { |
497 count *= 10; | 523 const int digit = **type - '0'; |
498 | 524 /* Check for overflow. */ |
499 /* Check for overflow. | 525 if (count > ((INT_MAX - digit) / 10)) |
500 We assume that count is represented using two's-complement; | |
501 no power of two is divisible by ten, so if an overflow occurs | |
502 when multiplying by ten, the result will not be a multiple of | |
503 ten. */ | |
504 if ((count % 10) != 0) | |
505 { | 526 { |
506 while (ISDIGIT ((unsigned char) **type)) | 527 while (ISDIGIT ((unsigned char) **type)) |
507 (*type)++; | 528 (*type)++; |
508 return -1; | 529 return -1; |
509 } | 530 } |
510 | 531 |
511 count += **type - '0'; | 532 count *= 10; |
533 count += digit; | |
512 (*type)++; | 534 (*type)++; |
513 } | 535 } |
514 | 536 |
515 if (count < 0) | 537 if (count < 0) |
516 count = -1; | 538 count = -1; |
851 work->options = options; | 873 work->options = options; |
852 if ((work->options & DMGL_STYLE_MASK) == 0) | 874 if ((work->options & DMGL_STYLE_MASK) == 0) |
853 work->options |= (int) current_demangling_style & DMGL_STYLE_MASK; | 875 work->options |= (int) current_demangling_style & DMGL_STYLE_MASK; |
854 | 876 |
855 /* The V3 ABI demangling is implemented elsewhere. */ | 877 /* The V3 ABI demangling is implemented elsewhere. */ |
856 if (GNU_V3_DEMANGLING || AUTO_DEMANGLING) | 878 if (GNU_V3_DEMANGLING || RUST_DEMANGLING || AUTO_DEMANGLING) |
857 { | 879 { |
858 ret = cplus_demangle_v3 (mangled, work->options); | 880 ret = cplus_demangle_v3 (mangled, work->options); |
859 if (ret || GNU_V3_DEMANGLING) | 881 if (GNU_V3_DEMANGLING) |
882 return ret; | |
883 | |
884 if (ret) | |
885 { | |
886 /* Rust symbols are GNU_V3 mangled plus some extra subtitutions. | |
887 The subtitutions are always smaller, so do in place changes. */ | |
888 if (rust_is_mangled (ret)) | |
889 rust_demangle_sym (ret); | |
890 else if (RUST_DEMANGLING) | |
891 { | |
892 free (ret); | |
893 ret = NULL; | |
894 } | |
895 } | |
896 | |
897 if (ret || RUST_DEMANGLING) | |
860 return ret; | 898 return ret; |
861 } | 899 } |
862 | 900 |
863 if (JAVA_DEMANGLING) | 901 if (JAVA_DEMANGLING) |
864 { | 902 { |
868 } | 906 } |
869 | 907 |
870 if (GNAT_DEMANGLING) | 908 if (GNAT_DEMANGLING) |
871 return ada_demangle (mangled, options); | 909 return ada_demangle (mangled, options); |
872 | 910 |
911 if (DLANG_DEMANGLING) | |
912 { | |
913 ret = dlang_demangle (mangled, options); | |
914 if (ret) | |
915 return ret; | |
916 } | |
917 | |
873 ret = internal_cplus_demangle (work, mangled); | 918 ret = internal_cplus_demangle (work, mangled); |
874 squangle_mop_up (work); | 919 squangle_mop_up (work); |
875 return (ret); | 920 return (ret); |
876 } | 921 } |
877 | 922 |
923 char * | |
924 rust_demangle (const char *mangled, int options) | |
925 { | |
926 /* Rust symbols are GNU_V3 mangled plus some extra subtitutions. */ | |
927 char *ret = cplus_demangle_v3 (mangled, options); | |
928 | |
929 /* The Rust subtitutions are always smaller, so do in place changes. */ | |
930 if (ret != NULL) | |
931 { | |
932 if (rust_is_mangled (ret)) | |
933 rust_demangle_sym (ret); | |
934 else | |
935 { | |
936 free (ret); | |
937 ret = NULL; | |
938 } | |
939 } | |
940 | |
941 return ret; | |
942 } | |
943 | |
878 /* Demangle ada names. The encoding is documented in gcc/ada/exp_dbug.ads. */ | 944 /* Demangle ada names. The encoding is documented in gcc/ada/exp_dbug.ads. */ |
879 | 945 |
880 char * | 946 char * |
881 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED) | 947 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED) |
882 { | 948 { |
883 int len0; | 949 int len0; |
884 const char* p; | 950 const char* p; |
885 char *d; | 951 char *d; |
886 char *demangled; | 952 char *demangled = NULL; |
887 | 953 |
888 /* Discard leading _ada_, which is used for library level subprograms. */ | 954 /* Discard leading _ada_, which is used for library level subprograms. */ |
889 if (strncmp (mangled, "_ada_", 5) == 0) | 955 if (strncmp (mangled, "_ada_", 5) == 0) |
890 mangled += 5; | 956 mangled += 5; |
891 | 957 |
1126 } | 1192 } |
1127 *d = 0; | 1193 *d = 0; |
1128 return demangled; | 1194 return demangled; |
1129 | 1195 |
1130 unknown: | 1196 unknown: |
1197 XDELETEVEC (demangled); | |
1131 len0 = strlen (mangled); | 1198 len0 = strlen (mangled); |
1132 demangled = XNEWVEC (char, len0 + 3); | 1199 demangled = XNEWVEC (char, len0 + 3); |
1133 | 1200 |
1134 if (mangled[0] == '<') | 1201 if (mangled[0] == '<') |
1135 strcpy (demangled, mangled); | 1202 strcpy (demangled, mangled); |
1173 example. */ | 1240 example. */ |
1174 | 1241 |
1175 if ((AUTO_DEMANGLING || GNU_DEMANGLING)) | 1242 if ((AUTO_DEMANGLING || GNU_DEMANGLING)) |
1176 { | 1243 { |
1177 success = gnu_special (work, &mangled, &decl); | 1244 success = gnu_special (work, &mangled, &decl); |
1245 if (!success) | |
1246 { | |
1247 delete_work_stuff (work); | |
1248 string_delete (&decl); | |
1249 } | |
1178 } | 1250 } |
1179 if (!success) | 1251 if (!success) |
1180 { | 1252 { |
1181 success = demangle_prefix (work, &mangled, &decl); | 1253 success = demangle_prefix (work, &mangled, &decl); |
1182 } | 1254 } |
1216 /* clean up the B and K type mangling types. */ | 1288 /* clean up the B and K type mangling types. */ |
1217 forget_B_and_K_types (work); | 1289 forget_B_and_K_types (work); |
1218 if (work -> btypevec != NULL) | 1290 if (work -> btypevec != NULL) |
1219 { | 1291 { |
1220 free ((char *) work -> btypevec); | 1292 free ((char *) work -> btypevec); |
1293 work->btypevec = NULL; | |
1294 work->bsize = 0; | |
1221 } | 1295 } |
1222 if (work -> ktypevec != NULL) | 1296 if (work -> ktypevec != NULL) |
1223 { | 1297 { |
1224 free ((char *) work -> ktypevec); | 1298 free ((char *) work -> ktypevec); |
1299 work->ktypevec = NULL; | |
1300 work->ksize = 0; | |
1225 } | 1301 } |
1226 } | 1302 } |
1227 | 1303 |
1228 | 1304 |
1229 /* Copy the work state and storage. */ | 1305 /* Copy the work state and storage. */ |
1270 | 1346 |
1271 to->btypevec[i] = XNEWVEC (char , len); | 1347 to->btypevec[i] = XNEWVEC (char , len); |
1272 memcpy (to->btypevec[i], from->btypevec[i], len); | 1348 memcpy (to->btypevec[i], from->btypevec[i], len); |
1273 } | 1349 } |
1274 | 1350 |
1351 if (from->proctypevec) | |
1352 to->proctypevec = | |
1353 XDUPVEC (int, from->proctypevec, from->proctypevec_size); | |
1354 | |
1275 if (from->ntmpl_args) | 1355 if (from->ntmpl_args) |
1276 to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args); | 1356 to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args); |
1277 | 1357 |
1278 for (i = 0; i < from->ntmpl_args; i++) | 1358 for (i = 0; i < from->ntmpl_args; i++) |
1279 { | 1359 { |
1298 delete_non_B_K_work_stuff (struct work_stuff *work) | 1378 delete_non_B_K_work_stuff (struct work_stuff *work) |
1299 { | 1379 { |
1300 /* Discard the remembered types, if any. */ | 1380 /* Discard the remembered types, if any. */ |
1301 | 1381 |
1302 forget_types (work); | 1382 forget_types (work); |
1303 if (work -> typevec != NULL) | 1383 if (work->typevec != NULL) |
1304 { | 1384 { |
1305 free ((char *) work -> typevec); | 1385 free ((char *) work->typevec); |
1306 work -> typevec = NULL; | 1386 work->typevec = NULL; |
1307 work -> typevec_size = 0; | 1387 work->typevec_size = 0; |
1388 } | |
1389 if (work->proctypevec != NULL) | |
1390 { | |
1391 free (work->proctypevec); | |
1392 work->proctypevec = NULL; | |
1393 work->proctypevec_size = 0; | |
1308 } | 1394 } |
1309 if (work->tmpl_argvec) | 1395 if (work->tmpl_argvec) |
1310 { | 1396 { |
1311 int i; | 1397 int i; |
1312 | 1398 |
1313 for (i = 0; i < work->ntmpl_args; i++) | 1399 for (i = 0; i < work->ntmpl_args; i++) |
1314 if (work->tmpl_argvec[i]) | 1400 free ((char*) work->tmpl_argvec[i]); |
1315 free ((char*) work->tmpl_argvec[i]); | |
1316 | 1401 |
1317 free ((char*) work->tmpl_argvec); | 1402 free ((char*) work->tmpl_argvec); |
1318 work->tmpl_argvec = NULL; | 1403 work->tmpl_argvec = NULL; |
1319 } | 1404 } |
1320 if (work->previous_argument) | 1405 if (work->previous_argument) |
1605 /* A G++ template function. Read the template arguments. */ | 1690 /* A G++ template function. Read the template arguments. */ |
1606 success = demangle_template (work, mangled, declp, 0, 0, | 1691 success = demangle_template (work, mangled, declp, 0, 0, |
1607 0); | 1692 0); |
1608 if (!(work->constructor & 1)) | 1693 if (!(work->constructor & 1)) |
1609 expect_return_type = 1; | 1694 expect_return_type = 1; |
1610 (*mangled)++; | 1695 if (!**mangled) |
1696 success = 0; | |
1697 else | |
1698 (*mangled)++; | |
1611 break; | 1699 break; |
1612 } | 1700 } |
1613 else | 1701 /* fall through */ |
1614 /* fall through */ | |
1615 {;} | |
1616 | 1702 |
1617 default: | 1703 default: |
1618 if (AUTO_DEMANGLING || GNU_DEMANGLING) | 1704 if (AUTO_DEMANGLING || GNU_DEMANGLING) |
1619 { | 1705 { |
1620 /* Assume we have stumbled onto the first outermost function | 1706 /* Assume we have stumbled onto the first outermost function |
2012 else | 2098 else |
2013 success = 0; | 2099 success = 0; |
2014 } | 2100 } |
2015 else if (tk == tk_real) | 2101 else if (tk == tk_real) |
2016 success = demangle_real_value (work, mangled, s); | 2102 success = demangle_real_value (work, mangled, s); |
2017 else if (tk == tk_pointer || tk == tk_reference) | 2103 else if (tk == tk_pointer || tk == tk_reference |
2104 || tk == tk_rvalue_reference) | |
2018 { | 2105 { |
2019 if (**mangled == 'Q') | 2106 if (**mangled == 'Q') |
2020 success = demangle_qualified (work, mangled, s, | 2107 success = demangle_qualified (work, mangled, s, |
2021 /*isfuncname=*/0, | 2108 /*isfuncname=*/0, |
2022 /*append=*/1); | 2109 /*append=*/1); |
2023 else | 2110 else |
2024 { | 2111 { |
2025 int symbol_len = consume_count (mangled); | 2112 int symbol_len = consume_count (mangled); |
2026 if (symbol_len == -1) | 2113 if (symbol_len == -1 |
2114 || symbol_len > (long) strlen (*mangled)) | |
2027 return -1; | 2115 return -1; |
2028 if (symbol_len == 0) | 2116 if (symbol_len == 0) |
2029 string_appendn (s, "0", 1); | 2117 string_appendn (s, "0", 1); |
2030 else | 2118 else |
2031 { | 2119 { |
2084 /* get template name */ | 2172 /* get template name */ |
2085 if (**mangled == 'z') | 2173 if (**mangled == 'z') |
2086 { | 2174 { |
2087 int idx; | 2175 int idx; |
2088 (*mangled)++; | 2176 (*mangled)++; |
2177 if (**mangled == '\0') | |
2178 return (0); | |
2089 (*mangled)++; | 2179 (*mangled)++; |
2090 | 2180 |
2091 idx = consume_count_with_underscores (mangled); | 2181 idx = consume_count_with_underscores (mangled); |
2092 if (idx == -1 | 2182 if (idx == -1 |
2093 || (work->tmpl_argvec && idx >= work->ntmpl_args) | 2183 || (work->tmpl_argvec && idx >= work->ntmpl_args) |
2928 { | 3018 { |
2929 int n; | 3019 int n; |
2930 int success = 1; | 3020 int success = 1; |
2931 const char *p; | 3021 const char *p; |
2932 | 3022 |
2933 if ((*mangled)[0] == '_' | 3023 if ((*mangled)[0] == '_' && (*mangled)[1] != '\0' |
2934 && strchr (cplus_markers, (*mangled)[1]) != NULL | 3024 && strchr (cplus_markers, (*mangled)[1]) != NULL |
2935 && (*mangled)[2] == '_') | 3025 && (*mangled)[2] == '_') |
2936 { | 3026 { |
2937 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */ | 3027 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */ |
2938 (*mangled) += 3; | 3028 (*mangled) += 3; |
2942 && (((*mangled)[1] == '_' | 3032 && (((*mangled)[1] == '_' |
2943 && (*mangled)[2] == 'v' | 3033 && (*mangled)[2] == 'v' |
2944 && (*mangled)[3] == 't' | 3034 && (*mangled)[3] == 't' |
2945 && (*mangled)[4] == '_') | 3035 && (*mangled)[4] == '_') |
2946 || ((*mangled)[1] == 'v' | 3036 || ((*mangled)[1] == 'v' |
2947 && (*mangled)[2] == 't' | 3037 && (*mangled)[2] == 't' && (*mangled)[3] != '\0' |
2948 && strchr (cplus_markers, (*mangled)[3]) != NULL))) | 3038 && strchr (cplus_markers, (*mangled)[3]) != NULL))) |
2949 { | 3039 { |
2950 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>" | 3040 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>" |
2951 and create the decl. Note that we consume the entire mangled | 3041 and create the decl. Note that we consume the entire mangled |
2952 input string, which means that demangle_signature has no work | 3042 input string, which means that demangle_signature has no work |
2978 if (n > (int) strlen (*mangled)) | 3068 if (n > (int) strlen (*mangled)) |
2979 { | 3069 { |
2980 success = 1; | 3070 success = 1; |
2981 break; | 3071 break; |
2982 } | 3072 } |
3073 else if (n == -1) | |
3074 { | |
3075 success = 0; | |
3076 break; | |
3077 } | |
2983 } | 3078 } |
2984 else | 3079 else |
2985 { | 3080 { |
2986 n = strcspn (*mangled, cplus_markers); | 3081 n = strcspn (*mangled, cplus_markers); |
2987 } | 3082 } |
3072 | 3167 |
3073 (*mangled) += 8; | 3168 (*mangled) += 8; |
3074 delta = consume_count (mangled); | 3169 delta = consume_count (mangled); |
3075 if (delta == -1) | 3170 if (delta == -1) |
3076 success = 0; | 3171 success = 0; |
3172 else if (**mangled != '_') | |
3173 success = 0; | |
3077 else | 3174 else |
3078 { | 3175 { |
3079 char *method = internal_cplus_demangle (work, ++*mangled); | 3176 char *method = internal_cplus_demangle (work, ++*mangled); |
3080 | 3177 |
3081 if (method) | 3178 if (method) |
3517 | 3614 |
3518 static int | 3615 static int |
3519 do_type (struct work_stuff *work, const char **mangled, string *result) | 3616 do_type (struct work_stuff *work, const char **mangled, string *result) |
3520 { | 3617 { |
3521 int n; | 3618 int n; |
3619 int i; | |
3620 int is_proctypevec; | |
3522 int done; | 3621 int done; |
3523 int success; | 3622 int success; |
3524 string decl; | 3623 string decl; |
3525 const char *remembered_type; | 3624 const char *remembered_type; |
3526 int type_quals; | 3625 int type_quals; |
3529 string_init (&decl); | 3628 string_init (&decl); |
3530 string_init (result); | 3629 string_init (result); |
3531 | 3630 |
3532 done = 0; | 3631 done = 0; |
3533 success = 1; | 3632 success = 1; |
3633 is_proctypevec = 0; | |
3534 while (success && !done) | 3634 while (success && !done) |
3535 { | 3635 { |
3536 int member; | 3636 int member; |
3537 switch (**mangled) | 3637 switch (**mangled) |
3538 { | 3638 { |
3551 case 'R': | 3651 case 'R': |
3552 (*mangled)++; | 3652 (*mangled)++; |
3553 string_prepend (&decl, "&"); | 3653 string_prepend (&decl, "&"); |
3554 if (tk == tk_none) | 3654 if (tk == tk_none) |
3555 tk = tk_reference; | 3655 tk = tk_reference; |
3656 break; | |
3657 | |
3658 /* An rvalue reference type */ | |
3659 case 'O': | |
3660 (*mangled)++; | |
3661 string_prepend (&decl, "&&"); | |
3662 if (tk == tk_none) | |
3663 tk = tk_rvalue_reference; | |
3556 break; | 3664 break; |
3557 | 3665 |
3558 /* An array */ | 3666 /* An array */ |
3559 case 'A': | 3667 case 'A': |
3560 { | 3668 { |
3576 } | 3684 } |
3577 | 3685 |
3578 /* A back reference to a previously seen type */ | 3686 /* A back reference to a previously seen type */ |
3579 case 'T': | 3687 case 'T': |
3580 (*mangled)++; | 3688 (*mangled)++; |
3581 if (!get_count (mangled, &n) || n >= work -> ntypes) | 3689 if (!get_count (mangled, &n) || n < 0 || n >= work -> ntypes) |
3582 { | 3690 { |
3583 success = 0; | 3691 success = 0; |
3584 } | 3692 } |
3585 else | 3693 else |
3586 { | 3694 for (i = 0; i < work->nproctypes; i++) |
3587 remembered_type = work -> typevec[n]; | 3695 if (work -> proctypevec [i] == n) |
3696 success = 0; | |
3697 | |
3698 if (success) | |
3699 { | |
3700 is_proctypevec = 1; | |
3701 push_processed_type (work, n); | |
3702 remembered_type = work->typevec[n]; | |
3588 mangled = &remembered_type; | 3703 mangled = &remembered_type; |
3589 } | 3704 } |
3590 break; | 3705 break; |
3591 | 3706 |
3592 /* A function */ | 3707 /* A function */ |
3610 if (success && (**mangled == '_')) | 3725 if (success && (**mangled == '_')) |
3611 (*mangled)++; | 3726 (*mangled)++; |
3612 break; | 3727 break; |
3613 | 3728 |
3614 case 'M': | 3729 case 'M': |
3615 case 'O': | |
3616 { | 3730 { |
3617 type_quals = TYPE_UNQUALIFIED; | 3731 type_quals = TYPE_UNQUALIFIED; |
3618 | 3732 |
3619 member = **mangled == 'M'; | 3733 member = **mangled == 'M'; |
3620 (*mangled)++; | 3734 (*mangled)++; |
3655 { | 3769 { |
3656 string_prependn (&decl, temp.b, temp.p - temp.b); | 3770 string_prependn (&decl, temp.b, temp.p - temp.b); |
3657 string_delete (&temp); | 3771 string_delete (&temp); |
3658 } | 3772 } |
3659 else | 3773 else |
3660 break; | 3774 { |
3775 string_delete (&temp); | |
3776 break; | |
3777 } | |
3661 } | 3778 } |
3662 else if (**mangled == 'Q') | 3779 else if (**mangled == 'Q') |
3663 { | 3780 { |
3664 success = demangle_qualified (work, mangled, &decl, | 3781 success = demangle_qualified (work, mangled, &decl, |
3665 /*isfuncnam=*/0, | 3782 /*isfuncnam=*/0, |
3687 | 3804 |
3688 default: | 3805 default: |
3689 break; | 3806 break; |
3690 } | 3807 } |
3691 | 3808 |
3692 if (*(*mangled)++ != 'F') | 3809 if (*(*mangled) != 'F') |
3693 { | 3810 { |
3694 success = 0; | 3811 success = 0; |
3695 break; | 3812 break; |
3696 } | 3813 } |
3814 (*mangled)++; | |
3697 } | 3815 } |
3698 if ((member && !demangle_nested_args (work, mangled, &decl)) | 3816 if ((member && !demangle_nested_args (work, mangled, &decl)) |
3699 || **mangled != '_') | 3817 || **mangled != '_') |
3700 { | 3818 { |
3701 success = 0; | 3819 success = 0; |
3751 } | 3869 } |
3752 | 3870 |
3753 /* A back reference to a previously seen squangled type */ | 3871 /* A back reference to a previously seen squangled type */ |
3754 case 'B': | 3872 case 'B': |
3755 (*mangled)++; | 3873 (*mangled)++; |
3756 if (!get_count (mangled, &n) || n >= work -> numb) | 3874 if (!get_count (mangled, &n) || n < 0 || n >= work -> numb) |
3757 success = 0; | 3875 success = 0; |
3758 else | 3876 else |
3759 string_append (result, work->btypevec[n]); | 3877 string_append (result, work->btypevec[n]); |
3760 break; | 3878 break; |
3761 | 3879 |
3801 } | 3919 } |
3802 } | 3920 } |
3803 else | 3921 else |
3804 string_delete (result); | 3922 string_delete (result); |
3805 string_delete (&decl); | 3923 string_delete (&decl); |
3924 | |
3925 if (is_proctypevec) | |
3926 pop_processed_type (work); | |
3806 | 3927 |
3807 if (success) | 3928 if (success) |
3808 /* Assume an integral type, if we're not sure. */ | 3929 /* Assume an integral type, if we're not sure. */ |
3809 return (int) ((tk == tk_none) ? tk_integral : tk); | 3930 return (int) ((tk == tk_none) ? tk_integral : tk); |
3810 else | 3931 else |
3945 if (!ISDIGIT ((unsigned char)**mangled)) | 4066 if (!ISDIGIT ((unsigned char)**mangled)) |
3946 { | 4067 { |
3947 success = 0; | 4068 success = 0; |
3948 break; | 4069 break; |
3949 } | 4070 } |
4071 /* fall through */ | |
3950 case 'I': | 4072 case 'I': |
3951 (*mangled)++; | 4073 (*mangled)++; |
3952 if (**mangled == '_') | 4074 if (**mangled == '_') |
3953 { | 4075 { |
3954 int i; | 4076 int i; |
4092 | 4214 |
4093 (*mangled)++; | 4215 (*mangled)++; |
4094 | 4216 |
4095 literal_len = consume_count (mangled); | 4217 literal_len = consume_count (mangled); |
4096 | 4218 |
4097 if (literal_len <= 0) | 4219 if (literal_len <= 0 |
4220 || literal_len > (long) strlen (*mangled)) | |
4098 return 0; | 4221 return 0; |
4099 | 4222 |
4100 /* Literal parameters are names of arrays, functions, etc. and the | 4223 /* Literal parameters are names of arrays, functions, etc. and the |
4101 canonical representation uses the address operator */ | 4224 canonical representation uses the address operator */ |
4102 string_append (result, "&"); | 4225 string_append (result, "&"); |
4214 remember_type (work, start, *mangled - start); | 4337 remember_type (work, start, *mangled - start); |
4215 return 1; | 4338 return 1; |
4216 } | 4339 } |
4217 | 4340 |
4218 static void | 4341 static void |
4342 push_processed_type (struct work_stuff *work, int typevec_index) | |
4343 { | |
4344 if (work->nproctypes >= work->proctypevec_size) | |
4345 { | |
4346 if (!work->proctypevec_size) | |
4347 { | |
4348 work->proctypevec_size = 4; | |
4349 work->proctypevec = XNEWVEC (int, work->proctypevec_size); | |
4350 } | |
4351 else | |
4352 { | |
4353 if (work->proctypevec_size < 16) | |
4354 /* Double when small. */ | |
4355 work->proctypevec_size *= 2; | |
4356 else | |
4357 { | |
4358 /* Grow slower when large. */ | |
4359 if (work->proctypevec_size > (INT_MAX / 3) * 2) | |
4360 xmalloc_failed (INT_MAX); | |
4361 work->proctypevec_size = (work->proctypevec_size * 3 / 2); | |
4362 } | |
4363 work->proctypevec | |
4364 = XRESIZEVEC (int, work->proctypevec, work->proctypevec_size); | |
4365 } | |
4366 } | |
4367 work->proctypevec [work->nproctypes++] = typevec_index; | |
4368 } | |
4369 | |
4370 static void | |
4371 pop_processed_type (struct work_stuff *work) | |
4372 { | |
4373 work->nproctypes--; | |
4374 } | |
4375 | |
4376 static void | |
4219 remember_type (struct work_stuff *work, const char *start, int len) | 4377 remember_type (struct work_stuff *work, const char *start, int len) |
4220 { | 4378 { |
4221 char *tem; | 4379 char *tem; |
4222 | 4380 |
4223 if (work->forgetting_types) | 4381 if (work->forgetting_types) |
4230 work -> typevec_size = 3; | 4388 work -> typevec_size = 3; |
4231 work -> typevec = XNEWVEC (char *, work->typevec_size); | 4389 work -> typevec = XNEWVEC (char *, work->typevec_size); |
4232 } | 4390 } |
4233 else | 4391 else |
4234 { | 4392 { |
4393 if (work -> typevec_size > INT_MAX / 2) | |
4394 xmalloc_failed (INT_MAX); | |
4235 work -> typevec_size *= 2; | 4395 work -> typevec_size *= 2; |
4236 work -> typevec | 4396 work -> typevec |
4237 = XRESIZEVEC (char *, work->typevec, work->typevec_size); | 4397 = XRESIZEVEC (char *, work->typevec, work->typevec_size); |
4238 } | 4398 } |
4239 } | 4399 } |
4257 work -> ksize = 5; | 4417 work -> ksize = 5; |
4258 work -> ktypevec = XNEWVEC (char *, work->ksize); | 4418 work -> ktypevec = XNEWVEC (char *, work->ksize); |
4259 } | 4419 } |
4260 else | 4420 else |
4261 { | 4421 { |
4422 if (work -> ksize > INT_MAX / 2) | |
4423 xmalloc_failed (INT_MAX); | |
4262 work -> ksize *= 2; | 4424 work -> ksize *= 2; |
4263 work -> ktypevec | 4425 work -> ktypevec |
4264 = XRESIZEVEC (char *, work->ktypevec, work->ksize); | 4426 = XRESIZEVEC (char *, work->ktypevec, work->ksize); |
4265 } | 4427 } |
4266 } | 4428 } |
4286 work -> bsize = 5; | 4448 work -> bsize = 5; |
4287 work -> btypevec = XNEWVEC (char *, work->bsize); | 4449 work -> btypevec = XNEWVEC (char *, work->bsize); |
4288 } | 4450 } |
4289 else | 4451 else |
4290 { | 4452 { |
4453 if (work -> bsize > INT_MAX / 2) | |
4454 xmalloc_failed (INT_MAX); | |
4291 work -> bsize *= 2; | 4455 work -> bsize *= 2; |
4292 work -> btypevec | 4456 work -> btypevec |
4293 = XRESIZEVEC (char *, work->btypevec, work->bsize); | 4457 = XRESIZEVEC (char *, work->btypevec, work->bsize); |
4294 } | 4458 } |
4295 } | 4459 } |
4471 tem = work -> typevec[t]; | 4635 tem = work -> typevec[t]; |
4472 if (need_comma && PRINT_ARG_TYPES) | 4636 if (need_comma && PRINT_ARG_TYPES) |
4473 { | 4637 { |
4474 string_append (declp, ", "); | 4638 string_append (declp, ", "); |
4475 } | 4639 } |
4640 push_processed_type (work, t); | |
4476 if (!do_arg (work, &tem, &arg)) | 4641 if (!do_arg (work, &tem, &arg)) |
4477 { | 4642 { |
4643 pop_processed_type (work); | |
4478 return (0); | 4644 return (0); |
4479 } | 4645 } |
4646 pop_processed_type (work); | |
4480 if (PRINT_ARG_TYPES) | 4647 if (PRINT_ARG_TYPES) |
4481 { | 4648 { |
4482 string_appends (declp, &arg); | 4649 string_appends (declp, &arg); |
4483 } | 4650 } |
4484 string_delete (&arg); | 4651 string_delete (&arg); |
4740 s->e = s->b + n; | 4907 s->e = s->b + n; |
4741 } | 4908 } |
4742 else if (s->e - s->p < n) | 4909 else if (s->e - s->p < n) |
4743 { | 4910 { |
4744 tem = s->p - s->b; | 4911 tem = s->p - s->b; |
4912 if (n > INT_MAX / 2 - tem) | |
4913 xmalloc_failed (INT_MAX); | |
4745 n += tem; | 4914 n += tem; |
4746 n *= 2; | 4915 n *= 2; |
4747 s->b = XRESIZEVEC (char, s->b, n); | 4916 s->b = XRESIZEVEC (char, s->b, n); |
4748 s->p = s->b + tem; | 4917 s->p = s->b + tem; |
4749 s->e = s->b + n; | 4918 s->e = s->b + n; |