Mercurial > hg > CbC > CbC_gcc

comparison libiberty/cplus-dem.c @ 63:b7f97abdc517 gcc-4.6-20100522

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update gcc from gcc-4.5.0 to gcc-4.6
author ryoma <e075725@ie.u-ryukyu.ac.jp>
date Mon, 24 May 2010 12:47:05 +0900
parents 77e2b8dfacca
children f6334be47118
comparison
equal deleted inserted replaced
56:3c8a44c06a95 63:b7f97abdc517
59 #include <demangle.h> 59 #include <demangle.h>
60 #undef CURRENT_DEMANGLING_STYLE 60 #undef CURRENT_DEMANGLING_STYLE
61 #define CURRENT_DEMANGLING_STYLE work->options 61 #define CURRENT_DEMANGLING_STYLE work->options
62 62
63 #include "libiberty.h" 63 #include "libiberty.h"
64
65 static char *ada_demangle (const char *, int);
66 64
67 #define min(X,Y) (((X) < (Y)) ? (X) : (Y)) 65 #define min(X,Y) (((X) < (Y)) ? (X) : (Y))
68 66
69 /* A value at least one greater than the maximum number of characters 67 /* A value at least one greater than the maximum number of characters
70 that will be output when using the `%d' format with `printf'. */ 68 that will be output when using the `%d' format with `printf'. */
476 demangle_arm_hp_template (struct work_stuff *, const char **, int, string *); 474 demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
477 475
478 static void 476 static void
479 recursively_demangle (struct work_stuff *, const char **, string *, int); 477 recursively_demangle (struct work_stuff *, const char **, string *, int);
480 478
481 static void grow_vect (char **, size_t *, size_t, int);
482
483 /* Translate count to integer, consuming tokens in the process. 479 /* Translate count to integer, consuming tokens in the process.
484 Conversion terminates on the first non-digit character. 480 Conversion terminates on the first non-digit character.
485 481
486 Trying to consume something that isn't a count results in no 482 Trying to consume something that isn't a count results in no
487 consumption of input and a return of -1. 483 consumption of input and a return of -1.
870 if (ret) 866 if (ret)
871 return ret; 867 return ret;
872 } 868 }
873 869
874 if (GNAT_DEMANGLING) 870 if (GNAT_DEMANGLING)
875 return ada_demangle(mangled,options); 871 return ada_demangle (mangled, options);
876 872
877 ret = internal_cplus_demangle (work, mangled); 873 ret = internal_cplus_demangle (work, mangled);
878 squangle_mop_up (work); 874 squangle_mop_up (work);
879 return (ret); 875 return (ret);
880 } 876 }
881 877
882 878 /* Demangle ada names. The encoding is documented in gcc/ada/exp_dbug.ads. */
883 /* Assuming *OLD_VECT points to an array of *SIZE objects of size 879
884 ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects, 880 char *
885 updating *OLD_VECT and *SIZE as necessary. */
886
887 static void
888 grow_vect (char **old_vect, size_t *size, size_t min_size, int element_size)
889 {
890 if (*size < min_size)
891 {
892 *size *= 2;
893 if (*size < min_size)
894 *size = min_size;
895 *old_vect = XRESIZEVAR (char, *old_vect, *size * element_size);
896 }
897 }
898
899 /* Demangle ada names:
900 1. Discard final __{DIGIT}+ or ${DIGIT}+
901 2. Convert other instances of embedded "__" to `.'.
902 3. Discard leading _ada_.
903 4. Remove everything after first ___ if it is followed by 'X'.
904 5. Put symbols that should be suppressed in <...> brackets.
905 The resulting string is valid until the next call of ada_demangle. */
906
907 static char *
908 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED) 881 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
909 { 882 {
910 int i, j;
911 int len0; 883 int len0;
912 const char* p; 884 const char* p;
913 char *demangled = NULL; 885 char *d;
914 int changed; 886 char *demangled;
915 size_t demangled_size = 0;
916 887
917 changed = 0; 888 /* Discard leading _ada_, which is used for library level subprograms. */
918
919 if (strncmp (mangled, "_ada_", 5) == 0) 889 if (strncmp (mangled, "_ada_", 5) == 0)
920 { 890 mangled += 5;
921 mangled += 5; 891
922 changed = 1; 892 /* All ada unit names are lower-case. */
923 } 893 if (!ISLOWER (mangled[0]))
894 goto unknown;
895
896 /* Most of the demangling will trivially remove chars. Operator names
897 may add one char but because they are always preceeded by '__' which is
898 replaced by '.', they eventually never expand the size. '___elabs' and
899 '___elabb' add only 2 chars, but they occur only once. */
900 len0 = strlen (mangled) + 2 + 1;
901 demangled = XNEWVEC (char, len0);
924 902
925 if (mangled[0] == '_' || mangled[0] == '<') 903 d = demangled;
926 goto Suppress; 904 p = mangled;
927 905 while (1)
928 p = strstr (mangled, "___"); 906 {
929 if (p == NULL) 907 /* Convert name, which is always lower-case. */
930 len0 = strlen (mangled); 908 if (ISLOWER (*p))
931 else 909 {
932 { 910 do
933 if (p[3] == 'X') 911 *d++ = *p++;
934 { 912 while (ISLOWER(*p) || ISDIGIT (*p)
935 len0 = p - mangled; 913 || (p[0] == '_' && (ISLOWER (p[1]) || ISDIGIT (p[1]))));
936 changed = 1; 914 }
937 } 915 else if (p[0] == 'O')
916 {
917 static const char * const operators[][2] =
918 {{"Oabs", "abs"}, {"Oand", "and"}, {"Omod", "mod"},
919 {"Onot", "not"}, {"Oor", "or"}, {"Orem", "rem"},
920 {"Oxor", "xor"}, {"Oeq", "="}, {"One", "/="},
921 {"Olt", "<"}, {"Ole", "<="}, {"Ogt", ">"},
922 {"Oge", ">="}, {"Oadd", "+"}, {"Osubtract", "-"},
923 {"Oconcat", "&"}, {"Omultiply", "*"}, {"Odivide", "/"},
924 {"Oexpon", "**"}, {NULL, NULL}};
925 int k;
926
927 for (k = 0; operators[k][0]; k++)
928 {
929 int l = strlen (operators[k][0]);
930 if (!strncmp (p, operators[k][0], l))
931 {
932 p += l;
933 l = strlen (operators[k][1]);
934 *d++ = '"';
935 memcpy (d, operators[k][1], l);
936 d += l;
937 *d++ = '"';
938 break;
939 }
940 }
941 /* Operator not found. */
942 if (!operators[k][0])
943 goto unknown;
944 }
938 else 945 else
939 goto Suppress; 946 {
940 } 947 /* Not a GNAT encoding. */
941 948 goto unknown;
942 /* Make demangled big enough for possible expansion by operator name. */ 949 }
943 grow_vect (&demangled, 950
944 &demangled_size, 2 * len0 + 1, 951 if (p[0] == '_')
945 sizeof (char)); 952 {
946 953 /* Separator. */
947 if (ISDIGIT ((unsigned char) mangled[len0 - 1])) { 954 if (p[1] == '_')
948 for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1) 955 {
949 ; 956 /* Standard separator. Handled first. */
950 if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_') 957 p += 2;
951 { 958 if (ISDIGIT (*p))
952 len0 = i - 1; 959 {
953 changed = 1; 960 /* Overloading. */
954 } 961 do
955 else if (mangled[i] == '$') 962 p++;
956 { 963 while (ISDIGIT (*p) || (p[0] == '_' && ISDIGIT (p[1])));
957 len0 = i; 964 }
958 changed = 1; 965 else if (*p == '_' && !strcmp (p + 1, "elabb"))
959 } 966 {
960 } 967 memcpy (d, "'Elab_Body", 10);
961 968 d += 10;
962 for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]); 969 break;
963 i += 1, j += 1) 970 }
964 demangled[j] = mangled[i]; 971 else if (*p == '_' && !strcmp (p + 1, "elabs"))
965 972 {
966 while (i < len0) 973 memcpy (d, "'Elab_Spec", 10);
967 { 974 d += 10;
968 if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_') 975 break;
969 { 976 }
970 demangled[j] = '.'; 977 else
971 changed = 1; 978 {
972 i += 2; j += 1; 979 *d++ = '.';
973 } 980 continue;
981 }
982 }
983 else if (p[1] == 'B' || p[1] == 'E')
984 {
985 /* Entry Body or barrier Evaluation. */
986 p += 2;
987 while (ISDIGIT (*p))
988 p++;
989 if (p[0] == 's' && p[1] == 0)
990 break;
991 else
992 goto unknown;
993 }
994 else
995 goto unknown;
996 }
997
998 if (p[0] == 'T' && p[1] == 'K')
999 {
1000 if (p[2] == 'B' && p[3] == 0)
1001 {
1002 /* Subprogram for task body. */
1003 break;
1004 }
1005 else if (p[2] == '_' && p[3] == '_')
1006 {
1007 /* Inner declarations in a task. */
1008 p += 4;
1009 *d++ = '.';
1010 continue;
1011 }
1012 else
1013 goto unknown;
1014 }
1015 if ((p[0] == 'P' || p[0] == 'N') && p[1] == 0)
1016 {
1017 /* Protected type subprogram. */
1018 break;
1019 }
1020 if (p[0] == 'E' && p[1] == 0)
1021 {
1022 /* Exception name. */
1023 goto unknown;
1024 }
1025 if (*p == 'N' || *p == 'S')
1026 {
1027 /* Enumerated type name table. */
1028 goto unknown;
1029 }
1030 if (p[0] == 'X')
1031 {
1032 /* Body nested. */
1033 if (p[1] == 'n' || p[1] == 'b')
1034 p += 2;
1035 else if (p[1] == 0)
1036 p++;
1037 }
1038 if (p[0] == '.' && ISDIGIT (p[1]))
1039 {
1040 /* Nested subprogram. */
1041 p += 2;
1042 while (ISDIGIT (*p))
1043 p++;
1044 }
1045 if (*p == 0)
1046 {
1047 /* End of mangled name. */
1048 break;
1049 }
974 else 1050 else
975 { 1051 goto unknown;
976 demangled[j] = mangled[i]; 1052 }
977 i += 1; j += 1; 1053 *d = 0;
978 } 1054 return demangled;
979 } 1055
980 demangled[j] = '\000'; 1056 unknown:
981 1057 len0 = strlen (mangled);
982 for (i = 0; demangled[i] != '\0'; i += 1) 1058 demangled = XNEWVEC (char, len0 + 3);
983 if (ISUPPER ((unsigned char)demangled[i]) || demangled[i] == ' ')
984 goto Suppress;
985
986 if (! changed)
987 {
988 free (demangled);
989 return NULL;
990 }
991 else
992 return demangled;
993
994 Suppress:
995 grow_vect (&demangled,
996 &demangled_size, strlen (mangled) + 3,
997 sizeof (char));
998 1059
999 if (mangled[0] == '<') 1060 if (mangled[0] == '<')
1000 strcpy (demangled, mangled); 1061 strcpy (demangled, mangled);
1001 else 1062 else
1002 sprintf (demangled, "<%s>", mangled); 1063 sprintf (demangled, "<%s>", mangled);